src/OpenFOAM/primitives/strings/wordRe/wordRe.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::wordRe
  27
  28 Description
  29     A wordRe is a word, but can also have a regular expression for matching
  30     words.
  31
  32     By default the constructors will generally preserve the argument as
  33     string literal and the assignment operators will use the wordRe::DETECT
  34     compOption to scan the string for regular expression meta characters
  35     and/or invalid word characters and react accordingly.
  36
  37     The exceptions are when constructing/assigning from another
  38     Foam::wordRe (preserve the same type) or from a Foam::word (always
  39     literal).
  40
  41 Note
  42     If the string contents are changed - eg, by the operator+=() or by
  43     string::replace(), etc - it will be necessary to use compile() or
  44     recompile() to synchronize the regular expression.
  45
  46 SourceFiles
  47     wordRe.C
  48     wordReIO.C
  49
  50 \*---------------------------------------------------------------------------*/
  51
  52 #ifndef wordRe_H
  53 #define wordRe_H
  54
  55 #include <OpenFOAM/word.H>
  56 #include <OSspecific/regExp.H>
  57
  58 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  59
  60 namespace Foam
  61 {
  62
  63 // Forward declaration of friend functions and operators
  64 class wordRe;
  65
  66 class Istream;
  67 class Ostream;
  68
  69 Istream& operator>>(Istream&, wordRe&);
  70 Ostream& operator<<(Ostream&, const wordRe&);
  71
  72
  73 /*---------------------------------------------------------------------------*\
  74                            Class wordRe Declaration
  75 \*---------------------------------------------------------------------------*/
  76
  77 class wordRe
  78 :
  79     public word
  80 {
  81     // Private member data
  82
  83         //- The regular expression
  84         mutable regExp re_;
  85
  86 public:
  87
  88     // Public data types
  89
  90         //- Enumeration with compile options
  91         //  Note that 'REGEXP' is implicit if 'NOCASE' is specified alone.
  92         enum compOption
  93         {
  94             LITERAL = 0, /*!< treat as a string literal */
  95             DETECT  = 1, /*!< treat as regular expression */
  96             REGEXP  = 2, /*!< detect if the string contains meta-characters */
  97             NOCASE  = 4, /*!< ignore case in regular expression */
  98             DETECT_NOCASE = DETECT | NOCASE,
  99             REGEXP_NOCASE = REGEXP | NOCASE
 100         };
 101
 102
 103         //- Is this a meta character?
 104         static inline bool meta(char);
 105
 106         //- Test string for regular expression meta characters
 107         static inline bool isPattern(const string&);
 108
 109     // Constructors
 110
 111         //- Construct null
 112         inline wordRe();
 113
 114         //- Construct as copy
 115         inline wordRe(const wordRe&);
 116
 117         //- Construct as copy of word
 118         inline wordRe(const word&);
 119
 120         //- Construct as copy of character array
 121         //  Optionally specify how it should be treated.
 122         inline wordRe(const char*, const compOption=LITERAL);
 123
 124         //- Construct as copy of string.
 125         //  Optionally specify how it should be treated.
 126         inline wordRe(const string&, const compOption=LITERAL);
 127
 128         //- Construct as copy of std::string
 129         //  Optionally specify how it should be treated.
 130         inline wordRe(const std::string&, const compOption=LITERAL);
 131
 132         //- Construct from Istream
 133         //  Words are treated as literals, strings with an auto-test
 134         wordRe(Istream&);
 135
 136     // Member functions
 137
 138     //- Access
 139
 140         //- Should be treated as a match rather than a literal string?
 141         inline bool isPattern() const;
 142
 143     //- Infrastructure
 144
 145         //- Compile the regular expression
 146         inline bool compile() const;
 147
 148         //- Possibly compile the regular expression, with greater control
 149         inline bool compile(const compOption) const;
 150
 151         //- Recompile an existing regular expression
 152         inline bool recompile() const;
 153
 154         //- Frees precompiled regular expression, making wordRe a literal.
 155         //  Optionally strips invalid word characters
 156         inline void uncompile(const bool doStripInvalid=false) const;
 157
 158     //- Editing
 159
 160         //- Copy string, auto-test for regular expression or other options
 161         inline void set(const std::string&, const compOption=DETECT);
 162
 163         //- Copy string, auto-test for regular expression or other options
 164         inline void set(const char*, const compOption=DETECT);
 165
 166         //- Clear string and precompiled regular expression
 167         inline void clear();
 168
 169     //- Searching
 170
 171         //- Smart match as regular expression or as a string
 172         //  Optionally specify a literal match only
 173         inline bool match(const string&, bool literalMatch=false) const;
 174
 175     //- Miscellaneous
 176
 177         //- Return a string with quoted meta-characters
 178         inline string quotemeta() const;
 179
 180         //- Output some basic info
 181         Ostream& info(Ostream&) const;
 182
 183
 184     // Member operators
 185
 186         // Assignment
 187
 188             //- Assign copy
 189             //  Always case sensitive
 190             inline const wordRe& operator=(const wordRe&);
 191
 192             //- Copy word, never a regular expression
 193             inline const wordRe& operator=(const word&);
 194
 195             //- Copy string, auto-test for regular expression
 196             //  Always case sensitive
 197             inline const wordRe& operator=(const string&);
 198
 199             //- Copy string, auto-test for regular expression
 200             //  Always case sensitive
 201             inline const wordRe& operator=(const std::string&);
 202
 203             //- Copy string, auto-test for regular expression
 204             //  Always case sensitive
 205             inline const wordRe& operator=(const char*);
 206
 207
 208     // IOstream operators
 209
 210         friend Istream& operator>>(Istream&, wordRe&);
 211         friend Ostream& operator<<(Ostream&, const wordRe&);
 212 };
 213
 214
 215 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 216
 217 } // End namespace Foam
 218
 219 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 220
 221 #include "wordReI.H"
 222
 223 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 224
 225 #endif
 226
 227 // ************************ vim: set sw=4 sts=4 et: ************************ //