src/OSspecific/POSIX/regExp.H

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright (C) 1991-2009 OpenCFD Ltd.
   6      \\/     M anipulation  |
   7 -------------------------------------------------------------------------------
   8 License
   9     This file is part of OpenFOAM.
  10
  11     OpenFOAM is free software; you can redistribute it and/or modify it
  12     under the terms of the GNU General Public License as published by the
  13     Free Software Foundation; either version 2 of the License, or (at your
  14     option) any later version.
  15
  16     OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
  17     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  18     FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  19     for more details.
  20
  21     You should have received a copy of the GNU General Public License
  22     along with OpenFOAM; if not, write to the Free Software Foundation,
  23     Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  24
  25 Class
  26     Foam::regExp
  27
  28 Description
  29     Wrapper around POSIX extended regular expressions.
  30
  31 SeeAlso
  32     The manpage regex(7) for more information about POSIX regular expressions.
  33     These differ somewhat from @c Perl and @c sed regular expressions.
  34
  35 SourceFiles
  36     regExp.C
  37
  38 \*---------------------------------------------------------------------------*/
  39
  40 #ifndef regExp_H
  41 #define regExp_H
  42
  43 #include <regex.h>
  44 #include <string>
  45
  46 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  47
  48 namespace Foam
  49 {
  50
  51 // Forward declaration of classes
  52 class string;
  53 template<class T> class List;
  54
  55 /*---------------------------------------------------------------------------*\
  56                            Class regExp Declaration
  57 \*---------------------------------------------------------------------------*/
  58
  59 class regExp
  60 {
  61     // Private data
  62
  63         //- Precompiled regular expression
  64         mutable regex_t* preg_;
  65
  66     // Private member functions
  67
  68         //- Disallow default bitwise copy construct
  69         regExp(const regExp&);
  70
  71         //- Disallow default bitwise assignment
  72         void operator=(const regExp&);
  73
  74 public:
  75
  76         //- Is character a regular expression meta-character?
  77         //  any character: '.' \n
  78         //  quantifiers: '*', '+', '?' \n
  79         //  grouping: '(', '|', ')' \n
  80         //  range: '[', ']' \n
  81         //
  82         //  Don't bother checking for '{digit}' bounds
  83         inline static bool meta(char c)
  84         {
  85             return
  86             (
  87                 (c == '.')                           // any character
  88              || (c == '*' || c == '+' || c == '?')   // quantifiers
  89              || (c == '(' || c == ')' || c == '|')   // grouping/branching
  90              || (c == '[' || c == ']')               // range
  91             );
  92         }
  93
  94
  95     // Constructors
  96
  97         //- Construct null
  98         regExp();
  99
 100         //- Construct from character array, optionally ignoring case
 101         regExp(const char*, const bool ignoreCase=false);
 102
 103         //- Construct from std::string (or string), optionally ignoring case
 104         regExp(const std::string&, const bool ignoreCase=false);
 105
 106     // Destructor
 107
 108         ~regExp();
 109
 110
 111     // Member functions
 112
 113     //- Access
 114
 115         //- Return true if a precompiled expression does not exist
 116         inline bool empty() const
 117         {
 118             return !preg_;
 119         }
 120
 121         //- Does a precompiled expression exist?
 122         inline bool exists() const
 123         {
 124             return preg_ ? true : false;
 125         }
 126
 127         //- Return the number of (groups)
 128         inline int ngroups() const
 129         {
 130             return preg_ ? preg_->re_nsub : 0;
 131         }
 132
 133
 134     //- Editing
 135
 136         //- Compile pattern into a regular expression, optionally ignoring case
 137         void set(const char*, const bool ignoreCase=false) const;
 138
 139         //- Compile pattern into a regular expression, optionally ignoring case
 140         void set(const std::string&, const bool ignoreCase=false) const;
 141
 142
 143         //- Release precompiled expression.
 144         //  Returns true if precompiled expression existed before clear
 145         bool clear() const;
 146
 147
 148     //- Searching
 149
 150         //- Find position within string.
 151         //  Returns the index where it begins or string::npos if not found
 152         std::string::size_type find(const std::string& str) const;
 153
 154         //- Return true if it matches the entire string
 155         //  The begin-of-line (^) and end-of-line ($) anchors are implicit
 156         bool match(const std::string&) const;
 157
 158         //- Return true if it matches and sets the sub-groups matched
 159         //  The begin-of-line (^) and end-of-line ($) anchors are implicit
 160         bool match(const string&, List<string>& groups) const;
 161
 162         //- Return true if the regex was found in within string
 163         bool search(const std::string& str) const
 164         {
 165             return std::string::npos != find(str);
 166         }
 167
 168
 169     // Member Operators
 170
 171         //- Assign and compile pattern from a character array
 172         //  Always case sensitive
 173         void operator=(const char*);
 174
 175         //- Assign and compile pattern from string
 176         //  Always case sensitive
 177         void operator=(const std::string&);
 178
 179 };
 180
 181
 182 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 183
 184 } // End namespace Foam
 185
 186 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 187
 188 #endif
 189
 190 // ************************************************************************* //