src/OSspecific/POSIX/regExp.H

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
   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
  13     the Free Software Foundation, either version 3 of the License, or
  14     (at your 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, see <http://www.gnu.org/licenses/>.
  23
  24 Class
  25     Foam::regExp
  26
  27 Description
  28     Wrapper around POSIX extended regular expressions.
  29
  30 SeeAlso
  31     The manpage regex(7) for more information about POSIX regular expressions.
  32     These differ somewhat from \c Perl and \c sed regular expressions.
  33
  34 SourceFiles
  35     regExp.C
  36
  37 \*---------------------------------------------------------------------------*/
  38
  39 #ifndef regExp_H
  40 #define regExp_H
  41
  42 #include <regex.h>
  43 #include <string>
  44
  45 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  46
  47 namespace Foam
  48 {
  49
  50 // Forward declaration of classes
  51 class string;
  52 template<class T> class List;
  53
  54 /*---------------------------------------------------------------------------*\
  55                            Class regExp Declaration
  56 \*---------------------------------------------------------------------------*/
  57
  58 class regExp
  59 {
  60     // Private data
  61
  62         //- Precompiled regular expression
  63         mutable regex_t* preg_;
  64
  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     // Static Member Functions
  77
  78         //- Is character a regular expression meta-character?
  79         //  any character: '.' \n
  80         //  quantifiers: '*', '+', '?' \n
  81         //  grouping: '(', '|', ')' \n
  82         //  range: '[', ']' \n
  83         //
  84         //  Don't bother checking for '{digit}' bounds
  85         inline static bool meta(char c)
  86         {
  87             return
  88             (
  89                 (c == '.')                           // any character
  90              || (c == '*' || c == '+' || c == '?')   // quantifiers
  91              || (c == '(' || c == ')' || c == '|')   // grouping/branching
  92              || (c == '[' || c == ']')               // range
  93             );
  94         }
  95
  96
  97     // Constructors
  98
  99         //- Construct null
 100         regExp();
 101
 102         //- Construct from character array, optionally ignoring case
 103         regExp(const char*, const bool ignoreCase=false);
 104
 105         //- Construct from std::string (or string), optionally ignoring case
 106         regExp(const std::string&, const bool ignoreCase=false);
 107
 108
 109     //- Destructor
 110     ~regExp();
 111
 112
 113     // Member functions
 114
 115         // Access
 116
 117             //- Return true if a precompiled expression does not exist
 118             inline bool empty() const
 119             {
 120                 return !preg_;
 121             }
 122
 123             //- Does a precompiled expression exist?
 124             inline bool exists() const
 125             {
 126                 return preg_ ? true : false;
 127             }
 128
 129             //- Return the number of (groups)
 130             inline int ngroups() const
 131             {
 132                 return preg_ ? preg_->re_nsub : 0;
 133             }
 134
 135
 136         // Editing
 137
 138             //- Compile pattern into a regular expression, optionally ignoring
 139             //  case
 140             void set(const char*, const bool ignoreCase=false) const;
 141
 142             //- Compile pattern into a regular expression, optionally ignoring
 143             //  case
 144             void set(const std::string&, const bool ignoreCase=false) const;
 145
 146
 147             //- Release precompiled expression.
 148             //  Returns true if precompiled expression existed before clear
 149             bool clear() const;
 150
 151
 152         // Searching
 153
 154             //- Find position within string.
 155             //  Returns the index where it begins or string::npos if not found
 156             std::string::size_type find(const std::string& str) const;
 157
 158             //- Return true if it matches the entire string
 159             //  The begin-of-line (^) and end-of-line ($) anchors are implicit
 160             bool match(const std::string&) const;
 161
 162             //- Return true if it matches and sets the sub-groups matched
 163             //  The begin-of-line (^) and end-of-line ($) anchors are implicit
 164             bool match(const string&, List<string>& groups) const;
 165
 166             //- Return true if the regex was found within string
 167             bool search(const std::string& str) const
 168             {
 169                 return std::string::npos != find(str);
 170             }
 171
 172
 173     // Member Operators
 174
 175         //- Assign and compile pattern from a character array
 176         //  Always case sensitive
 177         void operator=(const char*);
 178
 179         //- Assign and compile pattern from string
 180         //  Always case sensitive
 181         void operator=(const std::string&);
 182 };
 183
 184
 185 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 186
 187 } // End namespace Foam
 188
 189 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 190
 191 #endif
 192
 193 // ************************************************************************* //