src/OpenFOAM/primitives/strings/wordRe/wordReI.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 \*---------------------------------------------------------------------------*/
  25
  26 // * * * * * * * * * * * * Static Member Functions * * * * * * * * * * * * * //
  27
  28 inline bool Foam::wordRe::meta(char c)
  29 {
  30     return regExp::meta(c);
  31 }
  32
  33
  34 inline bool Foam::wordRe::isPattern(const string& str)
  35 {
  36     return string::meta<regExp>(str);
  37 }
  38
  39
  40 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
  41
  42 inline Foam::wordRe::wordRe()
  43 :
  44     word(),
  45     re_()
  46 {}
  47
  48
  49 inline Foam::wordRe::wordRe(const wordRe& str)
  50 :
  51     word(str),
  52     re_()
  53 {
  54     if (str.isPattern())
  55     {
  56         compile();
  57     }
  58 }
  59
  60
  61 inline Foam::wordRe::wordRe(const word& str)
  62 :
  63     word(str),
  64     re_()
  65 {}
  66
  67
  68 inline Foam::wordRe::wordRe(const keyType& str, const compOption opt)
  69 :
  70     word(str, false),
  71     re_()
  72 {
  73     if (str.isPattern())
  74     {
  75         compile(opt);
  76     }
  77 }
  78
  79
  80 inline Foam::wordRe::wordRe(const char* str, const compOption opt)
  81 :
  82     word(str, false),
  83     re_()
  84 {
  85     compile(opt);
  86 }
  87
  88
  89 inline Foam::wordRe::wordRe(const string& str, const compOption opt)
  90 :
  91     word(str, false),
  92     re_()
  93 {
  94     compile(opt);
  95 }
  96
  97
  98 inline Foam::wordRe::wordRe(const std::string& str, const compOption opt)
  99 :
 100     word(str, false),
 101     re_()
 102 {
 103     compile(opt);
 104 }
 105
 106
 107 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 108
 109 inline bool Foam::wordRe::isPattern() const
 110 {
 111     return re_.exists();
 112 }
 113
 114
 115 inline bool Foam::wordRe::compile(const compOption opt) const
 116 {
 117     bool doCompile = false;
 118
 119     if (opt & wordRe::REGEXP)
 120     {
 121         doCompile = true;
 122     }
 123     else if (opt & wordRe::DETECT)
 124     {
 125         if (string::meta<regExp>(*this) || !string::valid<word>(*this))
 126         {
 127             doCompile = true;
 128         }
 129     }
 130     else if (opt & wordRe::NOCASE)
 131     {
 132         doCompile = true;
 133     }
 134
 135
 136     if (doCompile)
 137     {
 138         re_.set(*this, (opt & wordRe::NOCASE));
 139     }
 140     else
 141     {
 142         re_.clear();
 143     }
 144
 145     return re_.exists();
 146 }
 147
 148
 149 inline bool Foam::wordRe::compile() const
 150 {
 151     re_ = *this;
 152     return re_.exists();
 153 }
 154
 155
 156 inline bool Foam::wordRe::recompile() const
 157 {
 158     if (re_.exists())
 159     {
 160         re_ = *this;
 161     }
 162
 163     return re_.exists();
 164 }
 165
 166
 167 inline void Foam::wordRe::uncompile(const bool doStripInvalid) const
 168 {
 169     if (re_.clear())
 170     {
 171         // skip stripping unless debug is active to avoid costly operations
 172         if (word::debug && doStripInvalid)
 173         {
 174             string::stripInvalid<word>
 175             (
 176                 const_cast<word&>(static_cast<const word&>(*this))
 177             );
 178         }
 179     }
 180 }
 181
 182
 183 inline void Foam::wordRe::clear()
 184 {
 185     word::clear();
 186     re_.clear();
 187 }
 188
 189
 190 inline bool Foam::wordRe::match(const std::string& str, bool literalMatch) const
 191 {
 192     if (literalMatch || !re_.exists())
 193     {
 194         // check as string
 195         return (str == *this);
 196     }
 197     else
 198     {
 199         // check as regex
 200         return re_.match(str);
 201     }
 202 }
 203
 204
 205 inline Foam::string Foam::wordRe::quotemeta() const
 206 {
 207     return string::quotemeta<regExp>(*this);
 208 }
 209
 210
 211 inline void Foam::wordRe::set(const std::string& str, const compOption opt)
 212 {
 213     string::operator=(str);
 214     compile(opt);
 215 }
 216
 217
 218 inline void Foam::wordRe::set(const char* str, const compOption opt)
 219 {
 220     string::operator=(str);
 221     compile(opt);
 222 }
 223
 224
 225 // * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
 226
 227 inline const Foam::wordRe& Foam::wordRe::operator=(const wordRe& str)
 228 {
 229     string::operator=(str);
 230
 231     if (str.isPattern())
 232     {
 233         compile();
 234     }
 235     else
 236     {
 237         re_.clear();
 238     }
 239     return *this;
 240 }
 241
 242
 243 inline const Foam::wordRe& Foam::wordRe::operator=(const word& str)
 244 {
 245     word::operator=(str);
 246     re_.clear();
 247     return *this;
 248 }
 249
 250
 251 inline const Foam::wordRe& Foam::wordRe::operator=(const keyType& str)
 252 {
 253     string::operator=(str);
 254     if (str.isPattern())
 255     {
 256         compile();
 257     }
 258     return *this;
 259 }
 260
 261
 262 inline const Foam::wordRe& Foam::wordRe::operator=(const string& str)
 263 {
 264     string::operator=(str);
 265     compile(DETECT);  // auto-detect regex
 266     return *this;
 267 }
 268
 269
 270 inline const Foam::wordRe& Foam::wordRe::operator=(const std::string& str)
 271 {
 272     string::operator=(str);
 273     compile(DETECT);  // auto-detect regex
 274     return *this;
 275 }
 276
 277
 278 inline const Foam::wordRe& Foam::wordRe::operator=(const char* str)
 279 {
 280     string::operator=(str);
 281     compile(DETECT);  // auto-detect regex
 282     return *this;
 283 }
 284
 285
 286 // ************************************************************************* //