| Geant4 Cross Reference |
1 // 1
2 // *******************************************
3 // * License and Disclaimer
4 // *
5 // * The Geant4 software is copyright of th
6 // * the Geant4 Collaboration. It is provided
7 // * conditions of the Geant4 Software License
8 // * LICENSE and available at http://cern.ch/
9 // * include a list of copyright holders.
10 // *
11 // * Neither the authors of this software syst
12 // * institutes,nor the agencies providing fin
13 // * work make any representation or warran
14 // * regarding this software system or assum
15 // * use. Please see the license in the file
16 // * for the full disclaimer and the limitatio
17 // *
18 // * This code implementation is the result
19 // * technical work of the GEANT4 collaboratio
20 // * By using, copying, modifying or distri
21 // * any work based on the software) you ag
22 // * use in resulting scientific publicati
23 // * acceptance of all terms of the Geant4 Sof
24 // *******************************************
25 //
26 // G4String
27 //
28 // Class description:
29 //
30 // Common string type for Geant4
31 //
32 // Provides a `std::string` compliant implemen
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 //
38 // It can be passed to any function accepting
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 //
46 // Author: G.Cosmo, 11 November 1999
47 //--------------------------------------------
48
49 #ifndef G4String_hh
50 #define G4String_hh 1
51
52 #include "G4Types.hh"
53
54 #include <algorithm>
55 #include <cstdio>
56 #include <cstring>
57 #include <iostream>
58 #include <string>
59 #include <string_view>
60
61 class G4String : public std::string
62 {
63 public:
64 /// @brief
65 /// @deprecated Will be removed in future re
66 enum caseCompare
67 {
68 exact,
69 ignoreCase
70 };
71
72 /// @brief
73 /// @deprecated Will be removed in future re
74 enum stripType
75 {
76 leading,
77 trailing,
78 both
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&);
90 inline G4String& operator=(G4String&&);
91
92 /// @brief Implicitly convert to `const char
93 /// @deprecated Will be removed in future re
94 /// If passing `G4String` to functions req
95 /// to explicitly convert. `G4String` also
96 /// to match the `std::string` interface.
97 inline operator const char*() const;
98
99 /// @brief Override of subscript operator fo
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
124 /// @brief Deprecated function
125 /// @deprecated Use `std::string::erase` ins
126 [[deprecated("Use std::string::erase instead
127 inline G4String& remove(size_type);
128
129 /// @brief Deprecated function
130 /// @deprecated Use `G4StrUtil::contains` in
131 [[deprecated("Use G4StrUtil::contains instea
132 inline G4bool contains(const std::string&) c
133
134 /// @brief Deprecated function
135 /// @deprecated Use `G4StrUtil::contains` in
136 [[deprecated("Use G4StrUtil::contains instea
137 inline G4bool contains(char) const;
138
139 /// @brief Deprecated function
140 /// @deprecated Use `G4StrUtil` functions in
141 [[deprecated("Use G4StrUtil::{lstrip,rstrip,
142 [[nodiscard]] inline G4String strip(stripTyp
143
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
155 /// @brief Query and manipulation functions fo
156 //
157 /// Additional free functions that are not par
158 /// of the minimum C++ standard supported by G
159 ///
160 /// @see `G4String`
161 namespace G4StrUtil
162 {
163 /// @brief Convert string to lowercase
164 /// @param[in, out] str the string to lowerc
165 inline void to_lower(G4String& str);
166
167 /// @brief Return lowercased copy of string
168 /// @param[in] str the string to lowercase
169 /// @return lowercased copy of `str`
170 inline G4String to_lower_copy(G4String str);
171
172 /// @brief Convert string to uppercase
173 /// @param[in, out] str the string to upperc
174 inline void to_upper(G4String& str);
175
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
316 #include "G4String.icc"
317
318 #endif
319