src/OpenFOAM/primitives/strings/string/string.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::string
  26
  27 Description
  28     A class for handling character strings derived from std::string.
  29
  30     Strings may contain any characters and therefore are delimited by quotes
  31     for IO : "any list of characters".
  32
  33     Used as a base class for word and fileName.
  34
  35 See Also
  36     Foam::findEtcFile() for information about the site/user OpenFOAM
  37     configuration directory
  38
  39 SourceFiles
  40     string.C
  41     stringIO.C
  42
  43 \*---------------------------------------------------------------------------*/
  44
  45 #ifndef string_H
  46 #define string_H
  47
  48 #include "char.H"
  49 #include "Hasher.H"
  50
  51 #include <string>
  52 #include <cstring>
  53 #include <cstdlib>
  54
  55 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  56
  57 namespace Foam
  58 {
  59
  60 // Forward declaration of classes
  61 class Istream;
  62 class Ostream;
  63
  64 // Forward declaration of friend functions and operators
  65 class string;
  66 Istream& operator>>(Istream&, string&);
  67 Ostream& operator<<(Ostream&, const string&);
  68 Ostream& operator<<(Ostream&, const std::string&);
  69
  70
  71 /*---------------------------------------------------------------------------*\
  72                            Class string Declaration
  73 \*---------------------------------------------------------------------------*/
  74
  75 class string
  76 :
  77     public std::string
  78 {
  79 public:
  80
  81     // Static data members
  82
  83         static const char* const typeName;
  84         static int debug;
  85
  86         //- An empty string
  87         static const string null;
  88
  89
  90     //- Hashing function class, shared by all the derived classes
  91     class hash
  92     {
  93     public:
  94         hash()
  95         {}
  96
  97         inline unsigned operator()(const string&, unsigned seed = 0) const;
  98     };
  99
 100
 101     // Constructors
 102
 103         //- Construct null
 104         inline string();
 105
 106         //- Construct from std::string
 107         inline string(const std::string&);
 108
 109         //- Construct as copy of character array
 110         inline string(const char*);
 111
 112         //- Construct as copy of specified number of characters
 113         inline string(const char*, const size_type);
 114
 115         //- Construct from a single character
 116         inline string(const char);
 117
 118         //- Construct from Istream
 119         string(Istream&);
 120
 121
 122     // Member Functions
 123
 124         //- Count and return the number of a given character in the string
 125         size_type count(const char) const;
 126
 127         //- Is this string type valid?
 128         template<class String>
 129         static inline bool valid(const string&);
 130
 131         //- Does this string have particular meta-characters?
 132         //  The meta characters can be optionally quoted.
 133         template<class String>
 134         static inline bool meta(const string&, const char quote='\\');
 135
 136         //- Strip invalid characters from the given string
 137         template<class String>
 138         static inline bool stripInvalid(string&);
 139
 140         //- Return a valid String from the given string
 141         template<class String>
 142         static inline String validate(const string&);
 143
 144         //- Return a String with quoted meta-characters from the given string
 145         template<class String>
 146         static inline string quotemeta(const string&, const char quote='\\');
 147
 148         //- True when strings match literally
 149         inline bool match(const std::string&) const;
 150
 151         //- Avoid masking the normal std::string replace
 152         using std::string::replace;
 153
 154         //- Replace first occurence of sub-string oldStr with newStr
 155         //  starting at start
 156         string& replace
 157         (
 158             const string& oldStr,
 159             const string& newStr,
 160             size_type start = 0
 161         );
 162
 163         //- Replace all occurences of sub-string oldStr with newStr
 164         //  starting at start
 165         string& replaceAll
 166         (
 167             const string& oldStr,
 168             const string& newStr,
 169             size_type start = 0
 170         );
 171
 172         //- Expand initial tildes and all occurences of environment variables
 173         //  Expansion includes:
 174         //  -# environment variables
 175         //    - "$VAR", "${VAR}"
 176         //  -# current directory
 177         //    - leading "./" : the current directory
 178         //  -# tilde expansion
 179         //    - leading "~/" : home directory
 180         //    - leading "~user" : home directory for specified user
 181         //    - leading "~OpenFOAM" : site/user OpenFOAM configuration directory
 182         //
 183         //  Any unknown entries are removed silently if allowEmpty is true
 184         //  \sa
 185         //  Foam::findEtcFile
 186         string& expand(const bool allowEmpty = false);
 187
 188         //- Remove repeated characters returning true if string changed
 189         bool removeRepeated(const char);
 190
 191         //- Return string with repeated characters removed
 192         string removeRepeated(const char) const;
 193
 194         //- Remove trailing character returning true if string changed
 195         bool removeTrailing(const char);
 196
 197         //- Return string with trailing character removed
 198         string removeTrailing(const char) const;
 199
 200
 201     // Member Operators
 202
 203         //- Return the sub-string from the i-th character for \a n characters
 204         inline string operator()
 205         (
 206             const size_type i,
 207             const size_type n
 208         ) const;
 209
 210         //- Return the sub-string from the first character for \a n characters
 211         inline string operator()
 212         (
 213             const size_type n
 214         ) const;
 215
 216
 217     // IOstream Operators
 218
 219         friend Istream& operator>>(Istream&, string&);
 220         friend Ostream& operator<<(Ostream&, const string&);
 221 };
 222
 223
 224 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 225
 226 } // End namespace Foam
 227
 228 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 229
 230 #include "stringI.H"
 231
 232 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 233
 234 #endif
 235
 236 // ************************************************************************* //