Geant4 Cross Reference |
1 // 1 // 2 // ******************************************* 2 // ******************************************************************** 3 // * License and Disclaimer << 3 // * DISCLAIMER * 4 // * 4 // * * 5 // * The Geant4 software is copyright of th << 5 // * The following disclaimer summarizes all the specific disclaimers * 6 // * the Geant4 Collaboration. It is provided << 6 // * of contributors to this software. The specific disclaimers,which * 7 // * conditions of the Geant4 Software License << 7 // * govern, are listed with their locations in: * 8 // * LICENSE and available at http://cern.ch/ << 8 // * http://cern.ch/geant4/license * 9 // * include a list of copyright holders. << 10 // * 9 // * * 11 // * Neither the authors of this software syst 10 // * Neither the authors of this software system, nor their employing * 12 // * institutes,nor the agencies providing fin 11 // * institutes,nor the agencies providing financial support for this * 13 // * work make any representation or warran 12 // * work make any representation or warranty, express or implied, * 14 // * regarding this software system or assum 13 // * regarding this software system or assume any liability for its * 15 // * use. Please see the license in the file << 14 // * use. * 16 // * for the full disclaimer and the limitatio << 17 // * 15 // * * 18 // * This code implementation is the result << 16 // * This code implementation is the intellectual property of the * 19 // * technical work of the GEANT4 collaboratio << 17 // * GEANT4 collaboration. * 20 // * By using, copying, modifying or distri << 18 // * By copying, distributing or modifying the Program (or any work * 21 // * any work based on the software) you ag << 19 // * based on the Program) you indicate your acceptance of this * 22 // * use in resulting scientific publicati << 20 // * statement, and all its terms. * 23 // * acceptance of all terms of the Geant4 Sof << 24 // ******************************************* 21 // ******************************************************************** 25 // 22 // 26 // G4String << 27 // 23 // 28 // Class description: << 24 // $Id: G4String.hh,v 1.5 2005/03/15 19:11:35 gcosmo Exp $ >> 25 // GEANT4 tag $Name: geant4-07-01 $ 29 // 26 // 30 // Common string type for Geant4 << 27 // >> 28 //--------------------------------------------------------------- >> 29 // GEANT 4 class header file 31 // 30 // 32 // Provides a `std::string` compliant implemen << 31 // G4String 33 // strings. It currently inherits from `std::s << 34 // not be assumed other than that it will impl << 35 // as `std::string` as of the minimum C++ stan << 36 // (currently C++17). << 37 // 32 // 38 // It can be passed to any function accepting << 33 // Class description: 39 // arguments. Whilst it currently implements a << 40 // this should be considered deprecated for us << 41 // non-Geant4 functions taking `const char*` a << 42 // `std::string::c_str` member function to exp << 43 // << 44 // See `std::string` for primary interfaces, ` << 45 // 34 // 46 // Author: G.Cosmo, 11 November 1999 << 35 // Definition of a Geant4 string. 47 //-------------------------------------------- << 36 // Derived from the Rogue Wave implementation of RWCString; >> 37 // it uses intrinsically STL string. 48 38 49 #ifndef G4String_hh << 39 //--------------------------------------------------------------- 50 #define G4String_hh 1 << 51 40 52 #include "G4Types.hh" << 41 #ifndef __G4String >> 42 #define __G4String 53 43 54 #include <algorithm> << 44 #include <stdio.h> 55 #include <cstdio> << 56 #include <cstring> << 57 #include <iostream> << 58 #include <string> 45 #include <string> 59 #include <string_view> << 46 #include "G4Types.hh" >> 47 #include <iostream> >> 48 >> 49 #ifdef WIN32 >> 50 #define strcasecmp _stricmp >> 51 #endif >> 52 >> 53 typedef std::string::size_type str_size; >> 54 >> 55 class G4String; >> 56 >> 57 class G4SubString >> 58 { >> 59 public: >> 60 >> 61 inline G4SubString(const G4SubString&); >> 62 >> 63 inline G4SubString& operator=(const char*); >> 64 >> 65 inline G4SubString& operator=(const G4String&); >> 66 inline G4SubString& operator=(const G4SubString&); >> 67 >> 68 inline char& operator()(str_size); >> 69 inline char operator()(str_size) const; >> 70 inline char& operator[](str_size); >> 71 inline char operator[](str_size) const; >> 72 >> 73 inline G4int operator!() const; >> 74 >> 75 inline G4bool operator==(G4String) const; >> 76 inline G4bool operator==(const char*) const; >> 77 inline G4bool operator!=(G4String) const; >> 78 inline G4bool operator!=(const char*) const; >> 79 >> 80 inline str_size length() const; >> 81 inline str_size start() const; >> 82 >> 83 // For detecting null substrings >> 84 // >> 85 inline G4bool isNull() const; >> 86 >> 87 private: >> 88 >> 89 inline G4SubString(G4String&, str_size, str_size); >> 90 >> 91 G4String* mystring; >> 92 str_size mystart; >> 93 str_size extent; >> 94 >> 95 friend class G4String; >> 96 >> 97 }; >> 98 60 99 61 class G4String : public std::string 100 class G4String : public std::string 62 { 101 { 63 public: << 102 64 /// @brief << 103 typedef std::string std_string; 65 /// @deprecated Will be removed in future re << 104 66 enum caseCompare << 105 public: 67 { << 106 68 exact, << 107 enum caseCompare { exact, ignoreCase }; 69 ignoreCase << 108 enum stripType { leading, trailing, both }; 70 }; << 109 71 << 110 inline G4String (); 72 /// @brief << 111 inline G4String ( char ); 73 /// @deprecated Will be removed in future re << 112 inline G4String ( const char * ); 74 enum stripType << 113 inline G4String ( const G4String& ); 75 { << 114 inline G4String ( const G4SubString& ); 76 leading, << 115 inline G4String ( const std::string & ); 77 trailing, << 116 virtual ~G4String () {} 78 both << 117 79 }; << 80 << 81 using std::string::string; << 82 using std::string::operator=; << 83 << 84 inline G4String() = default; << 85 inline G4String(const std::string&); << 86 inline G4String(const G4String&); << 87 inline G4String(std::string&&); << 88 inline G4String(G4String&&); << 89 inline G4String& operator=(const G4String&); 118 inline G4String& operator=(const G4String&); 90 inline G4String& operator=(G4String&&); << 119 inline G4String& operator=(const std::string &); >> 120 inline G4String& operator=(const char*); >> 121 >> 122 inline char operator () (str_size) const; >> 123 inline char& operator () (str_size); 91 124 92 /// @brief Implicitly convert to `const char << 125 inline G4String& operator+=(const G4SubString&); 93 /// @deprecated Will be removed in future re << 126 inline G4String& operator+=(const char*); 94 /// If passing `G4String` to functions req << 127 inline G4String& operator+=(const std::string &); 95 /// to explicitly convert. `G4String` also << 128 inline G4String& operator+=(const char&); 96 /// to match the `std::string` interface. << 129 inline G4bool operator==(const G4String&) const; >> 130 inline G4bool operator==(const char*) const; >> 131 inline G4bool operator!=(const G4String&) const; >> 132 inline G4bool operator!=(const char*) const; >> 133 >> 134 //inline G4String operator () (unsigned int, unsigned int); 97 inline operator const char*() const; 135 inline operator const char*() const; >> 136 inline G4SubString operator()(str_size, str_size); >> 137 >> 138 inline G4int compareTo(const char*, caseCompare mode=exact); >> 139 inline G4int compareTo(const G4String&, caseCompare mode=exact); >> 140 >> 141 inline G4String& prepend (const char*); >> 142 inline G4String& append (const G4String&); 98 143 99 /// @brief Override of subscript operator fo << 144 inline std::istream& readLine (std::istream&, G4bool skipWhite=true); 100 /// @deprecated Will be removed at the same << 101 /// << 102 /// This override is required because of G4S << 103 /// operator to `const char*`. Together with << 104 /// `operator[](const char*, int) operator, << 105 /// [MSVC error C2666](https://docs.microsof << 106 /// This is a known issue with mixing implic << 107 /// operators. Provision of the override wit << 108 /// until the conversion operator is removed << 109 inline reference operator[](int); << 110 << 111 /// @overload << 112 inline const_reference operator[](int) const << 113 << 114 /// @brief Deprecated function << 115 /// @deprecated Use `std::string::compare` o << 116 [[deprecated("Use std::string::compare, or G << 117 inline G4int compareTo(std::string_view, cas << 118 << 119 /// @brief Deprecated function << 120 /// @deprecated Use `std::getline` plus `G4S << 121 [[deprecated("Use std::getline instead, plus << 122 inline std::istream& readLine(std::istream&, << 123 145 124 /// @brief Deprecated function << 146 inline G4String& replace (unsigned int, unsigned int, 125 /// @deprecated Use `std::string::erase` ins << 147 const char*, unsigned int ); 126 [[deprecated("Use std::string::erase instead << 148 inline G4String& replace(str_size, str_size, const char*); 127 inline G4String& remove(size_type); << 149 128 << 150 inline G4String& remove(str_size); 129 /// @brief Deprecated function << 151 inline G4String& remove(str_size, str_size); 130 /// @deprecated Use `G4StrUtil::contains` in << 152 131 [[deprecated("Use G4StrUtil::contains instea << 153 inline G4int first(char) const; 132 inline G4bool contains(const std::string&) c << 154 inline G4int last(char) const; 133 << 155 134 /// @brief Deprecated function << 156 inline G4bool contains(std::string) const; 135 /// @deprecated Use `G4StrUtil::contains` in << 136 [[deprecated("Use G4StrUtil::contains instea << 137 inline G4bool contains(char) const; 157 inline G4bool contains(char) const; 138 158 139 /// @brief Deprecated function << 159 // stripType = 0 beginning 140 /// @deprecated Use `G4StrUtil` functions in << 160 // stripType = 1 end 141 [[deprecated("Use G4StrUtil::{lstrip,rstrip, << 161 // stripType = 2 both 142 [[nodiscard]] inline G4String strip(stripTyp << 162 // 143 << 163 inline G4String strip (G4int stripType=trailing, char c=' '); 144 /// @brief Deprecated function << 145 /// @deprecated Use `G4StrUtil` functions in << 146 [[deprecated("Use G4StrUtil::to_lower/to_low << 147 inline void toLower(); << 148 << 149 /// @brief Deprecated function << 150 /// @deprecated Use `G4StrUtil` functions in << 151 [[deprecated("Use G4StrUtil::to_upper/to_upp << 152 inline void toUpper(); << 153 }; << 154 164 155 /// @brief Query and manipulation functions fo << 165 inline void toLower (); 156 // << 166 inline void toUpper (); 157 /// Additional free functions that are not par << 167 158 /// of the minimum C++ standard supported by G << 168 inline G4bool isNull() const; 159 /// << 169 160 /// @see `G4String` << 170 inline str_size index (const char*, G4int pos=0) const; 161 namespace G4StrUtil << 171 inline str_size index (char, G4int pos=0) const; 162 { << 172 inline str_size index (const G4String&, str_size, str_size, caseCompare) const; 163 /// @brief Convert string to lowercase << 173 164 /// @param[in, out] str the string to lowerc << 174 inline const char* data() const; 165 inline void to_lower(G4String& str); << 175 166 << 176 inline G4int strcasecompare(const char*, const char*) const; 167 /// @brief Return lowercased copy of string << 177 168 /// @param[in] str the string to lowercase << 178 inline unsigned int hash( caseCompare cmp = exact ) const; 169 /// @return lowercased copy of `str` << 179 inline unsigned int stlhash() const; 170 inline G4String to_lower_copy(G4String str); << 180 171 << 181 // useful for supplying hash functions to template hash collection ctors 172 /// @brief Convert string to uppercase << 182 // 173 /// @param[in, out] str the string to upperc << 183 static inline unsigned int hash(const G4String&); 174 inline void to_upper(G4String& str); << 184 175 << 185 }; 176 /// @brief Return uppercase copy of string << 177 /// @param[in] str the string to upper case << 178 /// @return uppercased copy of `str` << 179 inline G4String to_upper_copy(G4String str); << 180 << 181 /// @brief Remove leading characters from st << 182 /// @param[in,out] str string to strip << 183 /// @param[in] ch character to remove << 184 /// @post `str` has any leading sequence of << 185 void lstrip(G4String& str, char ch = ' '); << 186 << 187 /// @brief Remove trailing characters from s << 188 /// @param[in,out] str string to strip << 189 /// @param[in] ch character to remove << 190 /// @post `str` has any trailing sequence of << 191 void rstrip(G4String& str, char ch = ' '); << 192 << 193 /// @brief Remove leading and trailing chara << 194 /// @param[in,out] str string to strip << 195 /// @param[in] ch character to remove << 196 /// @post `str` has any leading and trailing << 197 void strip(G4String& str, char ch = ' '); << 198 << 199 /// @brief Return copy of string with leadin << 200 /// @param[in] str string to copy and strip << 201 /// @param[in] ch character to remove << 202 /// @return copy of `str` with any leading s << 203 G4String lstrip_copy(G4String str, char ch = << 204 << 205 /// @brief Return copy of string with traili << 206 /// @param[in] str string to copy and strip << 207 /// @param[in] ch character to remove << 208 /// @return copy of `str` with any trailing << 209 G4String rstrip_copy(G4String str, char ch = << 210 << 211 /// @brief Return copy of string with leadin << 212 /// @param[in] str string to copy and strip << 213 /// @param[in] ch character to remove << 214 /// @return copy of `str` with any leading a << 215 G4String strip_copy(G4String str, char ch = << 216 << 217 /// @brief Check if a string contains a give << 218 /// @param[in] str string to be checked << 219 /// @param[in] ss substring to check for << 220 /// @retval true if `str` contains `ss` << 221 /// @retval false otherwise << 222 inline G4bool contains(const G4String& str, << 223 << 224 /// @overload << 225 inline G4bool contains(const G4String& str, << 226 << 227 /// @overload << 228 inline G4bool contains(const G4String& str, << 229 << 230 /// @overload << 231 /// @note this overload is required to resol << 232 /// signatures taking `std::string_view` a << 233 /// arguments. G4String currently provides << 234 /// `const char*`, which makes the calls a << 235 /// implicit conversion to `std::string_vi << 236 inline G4bool contains(const G4String& str, << 237 << 238 /// @brief Case insensitive comparison of tw << 239 /// << 240 /// Converts both input arguments to lower c << 241 /// result of `std::string::compare` with th << 242 /// << 243 /// @param[in] lhs the first string in the c << 244 /// @param[in] rhs the second string in the << 245 /// @return negative(positive) `G4int` if lo << 246 /// before(after) lowercased `rhs` in lexi << 247 /// compare equivalent after lowercasing. << 248 inline G4int icompare(std::string_view lhs, << 249 << 250 /// @brief Return true if a string starts wi << 251 /// @param[in] str string to be checked << 252 /// @param[in] ss prefix to check for << 253 /// @retval true if `str` starts with `ss` << 254 /// @retval false otherwise << 255 inline bool starts_with(const G4String& str, << 256 << 257 /// @overload << 258 inline bool starts_with(const G4String& str, << 259 << 260 /// @overload << 261 inline bool starts_with(const G4String& str, << 262 << 263 /// @overload << 264 /// @note this overload is required to resol << 265 /// signatures taking `std::string_view` a << 266 /// arguments. G4String currently provides << 267 /// `const char*`, which makes the calls a << 268 /// implicit conversion to `std::string_vi << 269 inline bool starts_with(const G4String& str, << 270 << 271 /// @brief Return true if a string ends with << 272 /// @param[in] str string to be checked << 273 /// @param[in] ss suffix to check for << 274 /// @retval true if `str` ends with `ss` << 275 /// @retval false otherwise << 276 inline bool ends_with(const G4String& str, s << 277 << 278 /// @overload << 279 inline bool ends_with(const G4String& str, G << 280 << 281 /// @overload << 282 inline bool ends_with(const G4String& str, c << 283 << 284 /// @overload << 285 inline bool ends_with(const G4String& str, c << 286 << 287 /// @brief Remove specified in-range charact << 288 /// << 289 /// Equivalent to `std::string::erase(index, << 290 /// if `index <= size()`. When `index > size << 291 /// << 292 /// @deprecated It is strongly recommended t << 293 /// start index is already checked, or oth << 294 /// implement the index-size comparison in << 295 /// << 296 /// @param[in,out] str string to erase chara << 297 /// @param[in] index position to start remov << 298 /// @param[in] count number of characters to << 299 /// @post `str` is unchanged if `index > str << 300 /// `min(count, str.size() - index)` chara << 301 inline void safe_erase(G4String& str, G4Stri << 302 G4String::size_type c << 303 << 304 /// @brief Read characters into a G4String f << 305 /// << 306 /// @deprecated It is strongly recommended t << 307 /// function, plus `G4StrUtil::lstrip` if << 308 /// << 309 /// @param[in] is input stream to read from << 310 /// @param[in,out] str string to read into << 311 /// @param[in] skipWhite if true, discard le << 312 /// @return `is` << 313 inline std::istream& readline(std::istream& << 314 } // namespace G4StrUtil << 315 186 316 #include "G4String.icc" 187 #include "G4String.icc" 317 188 318 #endif 189 #endif 319 190