GCC Code Coverage Report

Directory: ./
File: tmp_project/PhoenixPresentation/tmp_project/PhoenixBeamerCreator/tmp_project/PhoenixCore/src/PString.cpp
Date: 2025-07-04 20:24:11
Exec Total Coverage
Lines: 407 413 98.5%
Branches: 344 366 94.0%
Line Branch Exec Source
1 /***************************************
2 Auteur : Pierre Aubert
3 Mail : pierre.aubert@lapp.in2p3.fr
4 Licence : CeCILL-C
5 ****************************************/
6
7
8 #include "PString.h"
9
10 ///Convert a char pointer into a string (event if the char pointer is NULL)
11 /** @param ch : char pointer to be converted into a string
12 * @return corresponding string, or empty string if the input char pointer is NULL
13 */
14 699 PString phoenix_charToString(const char * ch){
15
2/2
✓ Branch 0 taken 694 times.
✓ Branch 1 taken 5 times.
 699 if(ch != NULL){
16
1/1
✓ Branch 1 taken 694 times.
 694 PString str(ch);
17
1/1
✓ Branch 1 taken 694 times.
 694 return str;
18 694 }else{
19 5 return "";
20 }
21 }
22
23 ///Tels if the character is upper case letter
24 /** @param ch : caractère à tester
25 * @return true if character is upper case letter, false otherwise
26 */
27 10489 bool phoenix_isCharUpperCase(char ch){
28
4/4
✓ Branch 0 taken 10427 times.
✓ Branch 1 taken 62 times.
✓ Branch 2 taken 605 times.
✓ Branch 3 taken 9822 times.
 10489 return (ch >= 65 && ch <= 90);
29 }
30
31 ///Tels if the character is lower case letter
32 /** @param ch : caractère à tester
33 * @return true if the character is lower case letter, false otherwise
34 */
35 63 bool phoenix_isCharLowerCase(char ch){
36
3/4
✓ Branch 0 taken 50 times.
✓ Branch 1 taken 13 times.
✓ Branch 2 taken 50 times.
✗ Branch 3 not taken.
 63 return (ch >= 97 && ch <= 122);
37 }
38
39 ///Tels if the character is a number or not
40 /** @param ch : character to be analysed
41 * @return true if it is a number, false otherwise
42 */
43 41 bool phoenix_isCharNumber(char ch){
44
3/4
✓ Branch 0 taken 41 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 17 times.
✓ Branch 3 taken 24 times.
 41 return (ch >= 48 && ch <= 57);
45 }
46
47 ///Erase first and last characters of all PString in given vector
48 /** @param[out] vecOut : output vector of PString
49 * @param vecStr : input PString
50 * @param vecChar : set of characters to be removed
51 */
52 278 void eraseFirstLastChar(PVecString & vecOut, const PVecString & vecStr, const PString & vecChar){
53
2/2
✓ Branch 3 taken 348 times.
✓ Branch 4 taken 278 times.
 626 for(PVecString::const_iterator it(vecStr.begin()); it != vecStr.end(); ++it){
54
2/2
✓ Branch 2 taken 348 times.
✓ Branch 5 taken 348 times.
 348 vecOut.push_back(it->eraseFirstLastChar(vecChar));
55 }
56 278 }
57
58 ///Erase first and last characters of all PString in given vector
59 /** @param vecStr : input PString
60 * @param vecChar : set of characters to be removed
61 * @return output vector of PString
62 */
63 278 PVecString eraseFirstLastChar(const PVecString & vecStr, const PString & vecChar){
64 278 PVecString vecOut;
65
1/1
✓ Branch 1 taken 278 times.
 278 eraseFirstLastChar(vecOut, vecStr, vecChar);
66 278 return vecOut;
67 }
68
69 ///Find a string in a vector of string
70 /** @param vecStr : vector of string
71 * @param str : string to be searched
72 * @return true if the string has been found, false otherwise
73 */
74 9 bool findInVectorString(const PVecString & vecStr, const PString & str){
75
6/6
✓ Branch 1 taken 8 times.
✓ Branch 2 taken 1 times.
✓ Branch 4 taken 1 times.
✓ Branch 5 taken 7 times.
✓ Branch 6 taken 2 times.
✓ Branch 7 taken 7 times.
 9 if(vecStr.size() == 0lu || str == ""){return false;}
76 7 bool isSearch(true);
77 7 PVecString::const_iterator it(vecStr.begin());
78
6/6
✓ Branch 2 taken 15 times.
✓ Branch 3 taken 6 times.
✓ Branch 4 taken 14 times.
✓ Branch 5 taken 1 times.
✓ Branch 6 taken 14 times.
✓ Branch 7 taken 7 times.
 21 while(it != vecStr.end() && isSearch){
79 14 isSearch = *it != str;
80 14 ++it;
81 }
82 7 return !isSearch;
83 }
84
85 ///Default constructor of PString
86 202261500 PString::PString()
87
1/1
✓ Branch 2 taken 202261500 times.
 202261500 :std::string("")
88 {
89
1/1
✓ Branch 1 taken 202261500 times.
 202261500 initialisationPString();
90 202261500 }
91
92 ///Default constructor of PString
93 /** @param str : pointer to initialise the PString
94 */
95 349334723 PString::PString(const char * str)
96
1/1
✓ Branch 2 taken 349334723 times.
 349334723 :std::string(str)
97 {
98
1/1
✓ Branch 1 taken 349334723 times.
 349334723 initialisationPString();
99 349334723 }
100
101 ///Default constructor of PString
102 /** @param str : string to initialise the PString
103 */
104 16601412 PString::PString(const std::string & str)
105 16601412 :std::string(str)
106 {
107
1/1
✓ Branch 1 taken 16601412 times.
 16601412 initialisationPString();
108 16601412 }
109
110 ///Copy constructor of PString
111 /** @param other : class to copy
112 */
113 59409148 PString::PString(const PString & other)
114 59409148 :std::string()
115 {
116
1/1
✓ Branch 1 taken 59409148 times.
 59409148 copyPString(other);
117 59409148 }
118
119 ///Destructeur of PString
120 1255211560 PString::~PString(){
121
122 }
123
124 ///Definition of equal operator of PString
125 /** @param other : class to copy
126 * @return copied class
127 */
128 451111016 PString & PString::operator = (const PString & other){
129 451111016 copyPString(other);
130 451111016 return *this;
131 }
132
133 ///Definition of equal operator of PString and std::string
134 /** @param other : class to copy
135 * @return copied class
136 */
137 3495 PString & PString::operator = (const std::string & other){
138 3495 copyPString(other);
139 3495 return *this;
140 }
141
142 ///Add a PString to an other
143 /** @param other : PString to be added to the current one
144 * @return PString
145 */
146 6893869 PString & PString::operator += (const PString & other){
147 6893869 return add(other);
148 }
149
150 ///Add a std::string to an other
151 /** @param other : std::string to be added to the current one
152 * @return PString
153 */
154 355125 PString & PString::operator += (const std::string & other){
155 355125 return add(other);
156 }
157
158 ///Add a char to an other
159 /** @param ch : char to be added to the current one
160 * @return PString
161 */
162 257843800 PString & PString::operator += (char ch){
163 257843800 return add(ch);
164 }
165
166 ///Add a PString to an other
167 /** @param other : PString to be added to the current one
168 * @return PString
169 */
170 6893939 PString & PString::add(const PString & other){
171 6893939 concatenatePString(other);
172 6893939 return *this;
173 }
174
175 ///Add a std::string to an other
176 /** @param other : std::string to be added to the current one
177 * @return PString
178 */
179 355125 PString & PString::add(const std::string & other){
180 355125 concatenatePString(other);
181 355125 return *this;
182 }
183
184 ///Add a char to an other
185 /** @param ch : char to be added to the current one
186 * @return PString
187 */
188 257843800 PString & PString::add(char ch){
189 257843800 std::string str;
190
1/1
✓ Branch 1 taken 257843800 times.
 257843800 str+= ch;
191
1/1
✓ Branch 1 taken 257843800 times.
 257843800 concatenatePString(str);
192 257843800 return *this;
193 257843800 }
194
195 ///Add a char pointer to an other
196 /** @param str : char pointer to be added to the current one
197 * @return PString
198 */
199 342 PString & PString::add(const char * str){
200
1/1
✓ Branch 2 taken 342 times.
 342 concatenatePString(phoenix_charToString(str));
201 342 return *this;
202 }
203
204 ///Concatenate 2 PString together
205 /** @param other1 : left PString
206 * @param other2 : right PString
207 * @return concatenated PString
208 */
209 8 PString operator + (const PString & other1, const PString & other2){
210 8 PString res(other1);
211
1/1
✓ Branch 1 taken 8 times.
 8 res += other2;
212 8 return res;
213 }
214
215 ///Get the index of the first character of the given pattern
216 /** @param pattern : pattern to be searched
217 * @param offset : offset where to start searching the pattern (0 by default)
218 * @return index of the first character of the pattern, or size of the PString if the pattern wasn't found
219 */
220 8 size_t PString::findPatternIndex(const PString & pattern, size_t offset) const{
221 8 size_t sizePatern(pattern.size());
222 8 const PString & src = *this;
223
6/6
✓ Branch 0 taken 7 times.
✓ Branch 1 taken 1 times.
✓ Branch 3 taken 1 times.
✓ Branch 4 taken 6 times.
✓ Branch 5 taken 2 times.
✓ Branch 6 taken 6 times.
 8 if(sizePatern == 0lu || src.size() < offset + sizePatern){return size();}
224
225 6 size_t sizeSrc(src.size());
226 6 size_t beginTest(0lu), nbMatch(0lu);
227
1/2
✓ Branch 0 taken 59 times.
✗ Branch 1 not taken.
 59 for(size_t i(offset); i < sizeSrc; ++i){
228
2/2
✓ Branch 2 taken 18 times.
✓ Branch 3 taken 41 times.
 59 if(src[i] == pattern[nbMatch]){ //si le caractère i est le même que le caractère nbMatch
229
2/2
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 12 times.
 18 if(nbMatch == 0lu){ //c'est le premier qu'on teste
230 6 beginTest = i; //il faut donc se rappeler où on a commencer à faire le teste
231 }
232 18 ++nbMatch; //la prochaîne fois on testera le caractère suivant
233
2/2
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 12 times.
 18 if(nbMatch == sizePatern){ //dans ce cas, on a tout testé et tout les caractères correspondent, donc on sauvegarde
234 6 return beginTest; //on a trouver le motif pattern, donc on le remplace par le motif replaceStr
235 }
236 }else{ //si le caractère i n'est pas le même caractère que nbMatch
237
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 41 times.
 41 if(nbMatch != 0lu){ //si on avais déjà tester des caractères avant
238 ✗ i = beginTest; //On revient là où l'on avait fait le premier test
239 }
240 41 beginTest = 0lu; //on remet le début des tests à 0 (pour évité les dépassements, on ne sait jamais)
241 41 nbMatch = 0lu; //on remet ne nombre des tests à 0, comme on n'a pas trouver de nouveau le motif
242 }
243 }
244 ✗ return sizeSrc;
245 }
246
247 ///Get the PString between delimiter
248 /** @param beginPattern : pattern before the PString we want to get
249 * @param endPattern : pattern after the PString we want to get
250 * @return PString between beginPattern and endPattern or empty string if one of them is not found
251 */
252 2 PString PString::getBetweenDelimiter(const PString & beginPattern, const PString & endPattern) const{
253 2 size_t indexBeginPattern(findPatternIndex(beginPattern) + beginPattern.size());
254 2 size_t indexEndPattern(findPatternIndex(endPattern, indexBeginPattern));
255
3/6
✓ Branch 1 taken 2 times.
✗ Branch 2 not taken.
✓ Branch 4 taken 2 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 2 times.
✗ Branch 7 not taken.
 2 if(indexBeginPattern != size() && indexEndPattern != size()){
256
1/1
✓ Branch 2 taken 2 times.
 4 return substr(indexBeginPattern, indexEndPattern - indexBeginPattern);
257 }else{
258 ✗ return "";
259 }
260 }
261
262 ///Replace a PString into an other PString
263 /** @param pattern : pattern to be replaced
264 * @param replaceStr : string to replace
265 * @return modified PString
266 */
267 18901245 PString PString::replace(const PString & pattern, const PString & replaceStr) const{
268 18901245 size_t sizePatern(pattern.size());
269 18901245 const PString & src = *this;
270
6/7
✓ Branch 0 taken 18901245 times.
✗ Branch 1 not taken.
✓ Branch 3 taken 481 times.
✓ Branch 4 taken 18900764 times.
✓ Branch 5 taken 481 times.
✓ Branch 6 taken 18900764 times.
✓ Branch 8 taken 481 times.
 18901245 if(sizePatern == 0lu || src.size() == 0lu) return *this;
271
1/1
✓ Branch 1 taken 18900764 times.
 18900764 PString out(""); //on évite les petits désagréments
272 18900764 size_t sizeSrc(src.size());
273 18900764 size_t beginTest(0lu), nbMatch(0lu);
274
2/2
✓ Branch 0 taken 175152925 times.
✓ Branch 1 taken 18900764 times.
 194053689 for(size_t i(0lu); i < sizeSrc; ++i){
275
2/2
✓ Branch 2 taken 709866 times.
✓ Branch 3 taken 174443059 times.
 175152925 if(src[i] == pattern[nbMatch]){ //si le caractère i est le même que le caractère nbMatch
276
2/2
✓ Branch 0 taken 493697 times.
✓ Branch 1 taken 216169 times.
 709866 if(nbMatch == 0lu){ //c'est le premier qu'on teste
277 493697 beginTest = i; //il faut donc se rappeler où on a commencer à faire le teste
278 }
279 709866 ++nbMatch; //la prochaîne fois on testera le caractère suivant
280
2/2
✓ Branch 0 taken 116617 times.
✓ Branch 1 taken 593249 times.
 709866 if(nbMatch == sizePatern){ //dans ce cas, on a tout testé et tout les caractères correspondent, donc on sauvegarde
281
1/1
✓ Branch 1 taken 116617 times.
 116617 out += replaceStr; //on a trouver le motif pattern, donc on le remplace par le motif replaceStr
282 116617 beginTest = 0lu; //on remet le début des tests à 0 (pour évité les dépassements, on ne sait jamais)
283 116617 nbMatch = 0lu; //on remet ne nombre des tests à 0, comme on n'a pas trouver de nouveau le motif
284 }
285 }else{ //si le caractère i n'est pas le même caractère que nbMatch
286
2/2
✓ Branch 0 taken 174065979 times.
✓ Branch 1 taken 377080 times.
 174443059 if(nbMatch == 0lu){ //si on n'en avait pas trouver de bon avant
287
1/1
✓ Branch 2 taken 174065979 times.
 174065979 out += src[i]; //on ne change rien à ce caractère
288 }else{ //si on avais déjà tester des caractères avant
289
1/1
✓ Branch 2 taken 377080 times.
 377080 out += src[beginTest];
290 377080 i = beginTest;
291 }
292 174443059 beginTest = 0lu; //on remet le début des tests à 0 (pour évité les dépassements, on ne sait jamais)
293 174443059 nbMatch = 0lu; //on remet ne nombre des tests à 0, comme on n'a pas trouver de nouveau le motif
294 }
295 }
296 //We are potentially at the end of the source, so no more test
297
1/1
✓ Branch 1 taken 18900764 times.
 18900764 return out;
298 18900764 }
299
300 ///Replace a PString into an other PString
301 /** @param pattern : pattern to be replaced
302 * @param replaceStr : string to replace
303 * @param maxNbReplace : maximum number of replace to perform in the string
304 * @return modified PString
305 */
306 6 PString PString::replace(const PString & pattern, const PString & replaceStr, size_t maxNbReplace) const{
307 6 size_t sizePatern(pattern.size());
308 6 const PString & src = *this;
309
7/9
✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
✓ Branch 3 taken 6 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 1 times.
✓ Branch 6 taken 5 times.
✓ Branch 7 taken 1 times.
✓ Branch 8 taken 5 times.
✓ Branch 10 taken 1 times.
 6 if(sizePatern == 0lu || src.size() == 0lu || maxNbReplace == 0lu) return *this;
310
1/1
✓ Branch 1 taken 5 times.
 5 PString out(""); //on évite les petits désagréments
311 5 size_t sizeSrc(src.size());
312 5 size_t beginTest(0lu), nbMatch(0lu), nbReplace(0lu);
313
2/2
✓ Branch 0 taken 165 times.
✓ Branch 1 taken 5 times.
 170 for(size_t i(0lu); i < sizeSrc; ++i){
314
6/6
✓ Branch 2 taken 28 times.
✓ Branch 3 taken 137 times.
✓ Branch 4 taken 22 times.
✓ Branch 5 taken 6 times.
✓ Branch 6 taken 22 times.
✓ Branch 7 taken 143 times.
 165 if(src[i] == pattern[nbMatch] && nbReplace < maxNbReplace){ //si le caractère i est le même que le caractère nbMatch
315
2/2
✓ Branch 0 taken 5 times.
✓ Branch 1 taken 17 times.
 22 if(nbMatch == 0lu){ //c'est le premier qu'on teste
316 5 beginTest = i; //il faut donc se rappeler où on a commencer à faire le teste
317 }
318 22 ++nbMatch; //la prochaîne fois on testera le caractère suivant
319
2/2
✓ Branch 0 taken 5 times.
✓ Branch 1 taken 17 times.
 22 if(nbMatch == sizePatern){ //dans ce cas, on a tout testé et tout les caractères correspondent, donc on sauvegarde
320
1/1
✓ Branch 1 taken 5 times.
 5 out += replaceStr; //on a trouver le motif pattern, donc on le remplace par le motif replaceStr
321 5 beginTest = 0lu; //on remet le début des tests à 0 (pour évité les dépassements, on ne sait jamais)
322 5 nbMatch = 0lu; //on remet ne nombre des tests à 0, comme on n'a pas trouver de nouveau le motif
323 5 ++nbReplace;
324 }
325 }else{ //si le caractère i n'est pas le même caractère que nbMatch
326
1/2
✓ Branch 0 taken 143 times.
✗ Branch 1 not taken.
 143 if(nbMatch == 0lu){ //si on n'en avait pas trouver de bon avant
327
1/1
✓ Branch 2 taken 143 times.
 143 out += src[i]; //on ne change rien à ce caractère
328 }else{ //si on avais déjà tester des caractères avant
329 ✗ out += src[beginTest];
330 ✗ i = beginTest;
331 }
332 143 beginTest = 0lu; //on remet le début des tests à 0 (pour évité les dépassements, on ne sait jamais)
333 143 nbMatch = 0lu; //on remet ne nombre des tests à 0, comme on n'a pas trouver de nouveau le motif
334 }
335 }
336 //We are potentially at the end of the source, so no more test
337
1/1
✓ Branch 1 taken 5 times.
 5 return out;
338 5 }
339
340 ///Replace characters in vecChar by replaceStr
341 /** @param vecChar : set of characters to be replaced
342 * @param replaceStr : replacement string
343 * @return modified PString
344 */
345 1 PString PString::replaceChar(const PString & vecChar, const PString & replaceStr) const{
346 1 PString out;
347
2/2
✓ Branch 4 taken 32 times.
✓ Branch 5 taken 1 times.
 33 for(PString::const_iterator it(begin()); it != end(); ++it){
348
3/3
✓ Branch 2 taken 32 times.
✓ Branch 4 taken 5 times.
✓ Branch 5 taken 27 times.
 32 if(vecChar.find(*it)){
349
1/1
✓ Branch 1 taken 5 times.
 5 out += replaceStr;
350 }else{
351
1/1
✓ Branch 2 taken 27 times.
 27 out += *it;
352 }
353 }
354 1 return out;
355 }
356
357 ///Replace first {} with arg
358 /** @param arg : PString to be replaced
359 * @return modified PString
360 */
361 2 PString PString::format(const PString & arg) const{
362
1/1
✓ Branch 2 taken 2 times.
 2 return replace("{}", arg, 1lu);
363 }
364
365 ///Say if the current PString has the same begining of beginStr
366 /** @param beginStr : begining string to check
367 * @return true if the current PString has the same begining of beginStr, false otherhwise
368 */
369 7454 bool PString::isSameBegining(const PString & beginStr) const{
370 7454 const PString & src = *this;
371
2/2
✓ Branch 2 taken 4018 times.
✓ Branch 3 taken 3436 times.
 7454 if(src.size() < beginStr.size()) return false;
372 3436 std::string::const_iterator it = src.begin();
373 3436 std::string::const_iterator it2 = beginStr.begin();
374
6/6
✓ Branch 2 taken 7370 times.
✓ Branch 3 taken 21 times.
✓ Branch 6 taken 7252 times.
✓ Branch 7 taken 118 times.
✓ Branch 8 taken 7252 times.
✓ Branch 9 taken 139 times.
 7391 while(it != src.end() && it2 != beginStr.end()){
375
2/2
✓ Branch 2 taken 3297 times.
✓ Branch 3 taken 3955 times.
 7252 if(*it != *it2){ return false;}
376 3955 it++;
377 3955 it2++;
378 }
379 139 return true;
380 }
381
382 ///Count the number of char ch in the current PString
383 /** @param ch : char to be counted
384 * @return number of char ch in the current PString
385 */
386 317 size_t PString::count(char ch) const{
387 317 const PString & str(*this);
388 317 size_t nbChar(0lu);
389 317 std::string::const_iterator it(str.begin());
390
2/2
✓ Branch 2 taken 68379 times.
✓ Branch 3 taken 317 times.
 68696 while(it != str.end()){
391
2/2
✓ Branch 1 taken 2221 times.
✓ Branch 2 taken 66158 times.
 68379 if(*it == ch) nbChar++;
392 68379 it++;
393 }
394 317 return nbChar;
395 }
396
397 ///Count the number of patern in string
398 /** @param patern : patern to be serached
399 * @return number of occurence of patern in src
400 */
401 5 size_t PString::count(const PString & patern) const{
402 5 const PString & src = *this;
403 5 long unsigned int sizePatern(patern.size()), sizeSrc(src.size());
404
4/4
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 2 times.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 2 times.
 5 if(sizePatern == 0lu || sizeSrc == 0lu){return 0lu;}
405 2 size_t nbPaternFound(0lu);
406
407 2 long unsigned int beginTest(0lu), nbMatch(0lu);
408
2/2
✓ Branch 0 taken 43 times.
✓ Branch 1 taken 2 times.
 45 for(long unsigned int i(0lu); i < sizeSrc; ++i){
409
2/2
✓ Branch 2 taken 12 times.
✓ Branch 3 taken 31 times.
 43 if(src[i] == patern[nbMatch]){ //si le caractère i est le même que le caractère nbMatch
410
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 9 times.
 12 if(nbMatch == 0lu){ //c'est le premier qu'on teste
411 3 beginTest = i; //il faut donc se rappeler où on a commencer à faire le teste
412 }
413 12 ++nbMatch; //la prochaîne fois on testera le caractère suivant
414
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 9 times.
 12 if(nbMatch == sizePatern){ //dans ce cas, on a tout testé et tout les caractères correspondent, donc on sauvegarde
415 3 ++nbPaternFound;
416 3 beginTest = 0lu; //on remet le début des tests à 0 (pour évité les dépassements, on ne sait jamais)
417 3 nbMatch = 0lu; //on remet ne nombre des tests à 0, comme on n'a pas trouver de nouveau le motif
418 }
419 }else{ //si le caractère i n'est pas le même caractère que nbMatch
420
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 31 times.
 31 if(nbMatch != 0lu){ //si on avais déjà tester des caractères avant
421 ✗ i = beginTest;
422 }
423 31 beginTest = 0lu; //on remet le début des tests à 0 (pour évité les dépassements, on ne sait jamais)
424 31 nbMatch = 0lu; //on remet ne nombre des tests à 0, comme on n'a pas trouver de nouveau le motif
425 }
426 }
427 2 return nbPaternFound;
428 }
429
430 ///Find a char in a string
431 /** @param ch : char to be searched
432 * @return true if the char has been found, false otherwise
433 */
434 81920333 bool PString::find(char ch) const{
435 81920333 PString::const_iterator it = begin();
436
2/2
✓ Branch 2 taken 555839412 times.
✓ Branch 3 taken 59329930 times.
 615169342 while(it != end()){
437
2/2
✓ Branch 1 taken 22590403 times.
✓ Branch 2 taken 533249009 times.
 555839412 if(*it == ch) return true;
438 533249009 ++it;
439 }
440 59329930 return false;
441 }
442
443 ///Find multiple chars in a string
444 /** @param listChar : chars to be searched
445 * @return true if one of the chars has been found, false otherwise
446 */
447 50 bool PString::find(const PString & listChar) const{
448
6/6
✓ Branch 1 taken 49 times.
✓ Branch 2 taken 1 times.
✓ Branch 4 taken 1 times.
✓ Branch 5 taken 48 times.
✓ Branch 6 taken 2 times.
✓ Branch 7 taken 48 times.
 50 if(size() == 0lu || listChar.size() == 0lu){return false;}
449 48 bool foundChar = false;
450 48 long unsigned int i(0lu), size(listChar.size());
451
4/4
✓ Branch 0 taken 309 times.
✓ Branch 1 taken 4 times.
✓ Branch 2 taken 265 times.
✓ Branch 3 taken 44 times.
 313 while(!foundChar && i < size){
452 265 foundChar = find(listChar[i]);
453 265 ++i;
454 }
455 48 return foundChar;
456 }
457
458 ///Keep only the characters in the given listChar
459 /** @param listChar : list of characters to be kept
460 * @return PString which contains only characters in listChar
461 */
462 2 PString PString::keepChar(const PString & listChar) const{
463
3/3
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 1 times.
✓ Branch 4 taken 1 times.
 2 if(listChar.size() == 0lu){return "";}
464
1/1
✓ Branch 1 taken 1 times.
 1 PString out;
465
2/2
✓ Branch 4 taken 9 times.
✓ Branch 5 taken 1 times.
 10 for(PString::const_iterator it = begin(); it != end(); ++it){
466
3/3
✓ Branch 2 taken 9 times.
✓ Branch 4 taken 6 times.
✓ Branch 5 taken 3 times.
 9 if(listChar.find(*it)){
467
1/1
✓ Branch 2 taken 6 times.
 6 out += *it;
468 }
469 }
470
1/1
✓ Branch 1 taken 1 times.
 1 return out;
471 1 }
472
473 ///Get the common begining between the current PString and other
474 /** @param other : string
475 * @return common begining between the current PString and other
476 */
477 5 PString PString::getCommonBegining(const PString & other) const{
478
1/1
✓ Branch 1 taken 5 times.
 5 PString out("");
479 5 const PString & str1(*this);
480 5 PString::const_iterator it = str1.begin();
481 5 PString::const_iterator it2 = other.begin();
482
6/6
✓ Branch 2 taken 7 times.
✓ Branch 3 taken 2 times.
✓ Branch 6 taken 6 times.
✓ Branch 7 taken 1 times.
✓ Branch 8 taken 6 times.
✓ Branch 9 taken 3 times.
 9 while(it != str1.end() && it2 != other.end()){
483
2/2
✓ Branch 2 taken 4 times.
✓ Branch 3 taken 2 times.
 6 if(*it == *it2){
484
1/1
✓ Branch 2 taken 4 times.
 4 out += *it;
485 }else{
486 2 break;
487 }
488 4 it++;
489 4 it2++;
490 }
491 10 return out;
492 }
493
494 ///Cut a PString on the given separator char
495 /** @param separator : separtor char
496 * @return vector of PString
497 */
498 2367 std::vector<PString> PString::split(char separator) const{
499 2367 std::vector<PString> vec;
500
1/1
✓ Branch 1 taken 2367 times.
 2367 PString buffer = "";
501
2/2
✓ Branch 4 taken 95086 times.
✓ Branch 5 taken 2367 times.
 97453 for(PString::const_iterator it = begin(); it != end(); ++it){
502
2/2
✓ Branch 1 taken 87096 times.
✓ Branch 2 taken 7990 times.
 95086 if(*it != separator){
503
1/1
✓ Branch 2 taken 87096 times.
 87096 buffer += *it;
504 }else{
505
1/1
✓ Branch 1 taken 7990 times.
 7990 vec.push_back(buffer);
506
1/1
✓ Branch 1 taken 7990 times.
 7990 buffer = "";
507 }
508 }
509
3/3
✓ Branch 1 taken 1399 times.
✓ Branch 2 taken 968 times.
✓ Branch 4 taken 1399 times.
 2367 if(buffer != ""){vec.push_back(buffer);}
510 4734 return vec;
511 2367 }
512
513 ///Split the PString on any given characters of vecSeparator
514 /** @param vecSeparator : PString of separator characters
515 * @return split PString
516 */
517 4 std::vector<PString> PString::split(const PString & vecSeparator) const{
518 4 std::vector<PString> vec;
519
6/6
✓ Branch 1 taken 2 times.
✓ Branch 2 taken 2 times.
✓ Branch 4 taken 1 times.
✓ Branch 5 taken 1 times.
✓ Branch 6 taken 1 times.
✓ Branch 7 taken 3 times.
 4 if(size() != 0lu && vecSeparator.size() != 0lu){
520
1/1
✓ Branch 1 taken 1 times.
 1 PString buffer("");
521
2/2
✓ Branch 4 taken 20 times.
✓ Branch 5 taken 1 times.
 21 for(PString::const_iterator it(begin()); it != end(); ++it){
522
3/3
✓ Branch 2 taken 20 times.
✓ Branch 4 taken 17 times.
✓ Branch 5 taken 3 times.
 20 if(!vecSeparator.find(*it)){
523
1/1
✓ Branch 2 taken 17 times.
 17 buffer += *it;
524 }else{
525
1/2
✓ Branch 1 taken 3 times.
✗ Branch 2 not taken.
 3 if(buffer != ""){
526
1/1
✓ Branch 1 taken 3 times.
 3 vec.push_back(buffer);
527
1/1
✓ Branch 1 taken 3 times.
 3 buffer = "";
528 }
529 }
530 }
531
2/3
✓ Branch 1 taken 1 times.
✗ Branch 2 not taken.
✓ Branch 4 taken 1 times.
 1 if(buffer != "") vec.push_back(buffer);
532 1 }
533 4 return vec;
534 }
535
536
537 ///Merge a set of PString
538 /** @param vecStr : vector of PString ot be merged
539 * @param separator : separator between PString
540 * @return corresponding PString
541 */
542 2 PString & PString::merge(const std::vector<PString> & vecStr, const PString & separator){
543
2/2
✓ Branch 1 taken 2 times.
✓ Branch 4 taken 2 times.
 2 PString out(""), comma("");;
544
2/2
✓ Branch 4 taken 8 times.
✓ Branch 5 taken 2 times.
 10 for(std::vector<PString>::const_iterator it(vecStr.begin()); it != vecStr.end(); ++it){
545
2/2
✓ Branch 2 taken 8 times.
✓ Branch 5 taken 8 times.
 8 out += comma + (*it);
546
1/1
✓ Branch 1 taken 8 times.
 8 comma = separator;
547 }
548
1/1
✓ Branch 1 taken 2 times.
 2 *this = out;
549 2 return *this;
550 2 }
551
552 ///Erase char ch of current string
553 /** @param ch : char to be removed
554 * @return modified PString
555 */
556 230471061 PString PString::eraseChar(char ch) const{
557 230471061 PString buffer = "";
558
2/2
✓ Branch 4 taken 81596180 times.
✓ Branch 5 taken 230471061 times.
 312067241 for(PString::const_iterator it = begin(); it != end(); it++){
559
3/3
✓ Branch 1 taken 81592586 times.
✓ Branch 2 taken 3594 times.
✓ Branch 5 taken 81592586 times.
 81596180 if(*it != ch) buffer += *it;
560 }
561 230471061 return buffer;
562 }
563
564 ///Erase char ch of current string
565 /** @param vecChar : chars to be removed
566 * @return modified PString
567 */
568 3540083 PString PString::eraseChar(const PString & vecChar) const{
569 3540083 PString buffer(*this);
570
2/2
✓ Branch 3 taken 230470352 times.
✓ Branch 4 taken 3540083 times.
 234010435 for(PString::const_iterator it = vecChar.begin(); it != vecChar.end(); it++){
571
2/2
✓ Branch 2 taken 230470352 times.
✓ Branch 5 taken 230470352 times.
 230470352 buffer = buffer.eraseChar(*it);
572 }
573 3540083 return buffer;
574 }
575
576 ///Erase first char in a string
577 /** @param vecChar : chars to be searched and removed
578 * @return modifed string
579 */
580 14258 PString PString::eraseFirstChar(const PString & vecChar) const{
581
1/1
✓ Branch 1 taken 14258 times.
 14258 PString buffer(*this);
582 14258 bool continuer = true;
583 14258 PString::iterator it = buffer.begin();
584 //Let's remove the first chars
585
6/6
✓ Branch 2 taken 26655 times.
✓ Branch 3 taken 2495 times.
✓ Branch 4 taken 14892 times.
✓ Branch 5 taken 11763 times.
✓ Branch 6 taken 14892 times.
✓ Branch 7 taken 14258 times.
 29150 while(it != buffer.end() && continuer){
586
4/4
✓ Branch 2 taken 14892 times.
✓ Branch 4 taken 2968 times.
✓ Branch 5 taken 11924 times.
✓ Branch 8 taken 2968 times.
 14892 if(vecChar.find(*it)){it = buffer.erase(it);}
587 else{
588 11924 continuer = false;
589 11924 it++;
590 }
591 }
592 28516 return buffer;
593 }
594
595 ///Erase first and last char in a string
596 /** @param vecChar : chars to be searched and removed
597 * @return modifed string
598 */
599 13777 PString PString::eraseLastChar(const PString & vecChar) const{
600
2/2
✓ Branch 1 taken 11556 times.
✓ Branch 2 taken 2221 times.
 13777 if(size() > 0lu){
601 11556 size_t nbCharToRemove(0lu);
602 11556 PString::const_reverse_iterator it(rbegin());
603
3/3
✓ Branch 2 taken 14248 times.
✓ Branch 4 taken 2692 times.
✓ Branch 5 taken 11556 times.
 14248 while(vecChar.find(*it)){
604 2692 ++it;
605 2692 ++nbCharToRemove;
606 }
607
608
2/2
✓ Branch 0 taken 9098 times.
✓ Branch 1 taken 2458 times.
 11556 if(nbCharToRemove == 0lu){
609
1/1
✓ Branch 1 taken 9098 times.
 9098 return *this;
610 }else{
611
2/2
✓ Branch 2 taken 2458 times.
✓ Branch 5 taken 2458 times.
 2458 PString buffer(substr(0, size() - nbCharToRemove));
612
1/1
✓ Branch 1 taken 2458 times.
 2458 return buffer;
613 2458 }
614 }else{
615 2221 return *this;
616 }
617 }
618
619 ///Erase first and last char in a string
620 /** @param vecChar : chars to be searched and removed
621 * @return modifed string
622 */
623 13465 PString PString::eraseFirstLastChar(const PString & vecChar) const{
624
1/1
✓ Branch 1 taken 13465 times.
 13465 PString buffer(eraseFirstChar(vecChar));
625
1/1
✓ Branch 1 taken 13465 times.
 26930 return buffer.eraseLastChar(vecChar);
626 13465 }
627
628 ///Say if the given PString is in uppercase
629 /** @return true if the PString is in uppercase, false if not
630 */
631 3 bool PString::isUpperCase() const{
632
2/2
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 2 times.
 3 if(size() == 0lu){return false;}
633 2 const PString & str = *this;
634 2 bool isUpper(true);
635 2 size_t i(0lu);
636
6/6
✓ Branch 1 taken 19 times.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 18 times.
✓ Branch 4 taken 1 times.
✓ Branch 5 taken 18 times.
✓ Branch 6 taken 2 times.
 20 while(i < str.size() && isUpper){
637 18 isUpper = phoenix_isCharUpperCase(str[i]);
638 18 ++i;
639 }
640 2 return isUpper;
641 }
642
643 ///Say if the given PString is in lowercase
644 /** @return true if the PString is in lowercase, false if not
645 */
646 3 bool PString::isLowerCase() const{
647
2/2
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 2 times.
 3 if(size() == 0lu){return false;}
648 2 const PString & str = *this;
649 2 bool isLower(true);
650 2 size_t i(0lu);
651
6/6
✓ Branch 1 taken 18 times.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 17 times.
✓ Branch 4 taken 1 times.
✓ Branch 5 taken 17 times.
✓ Branch 6 taken 2 times.
 19 while(i < str.size() && isLower){
652 17 isLower = phoenix_isCharLowerCase(str[i]);
653 17 ++i;
654 }
655 2 return isLower;
656 }
657
658 ///Say if the given PString is composed of numbers
659 /** @return true if the PString is composed of numbers, false if not
660 */
661 38 bool PString::isNumber() const{
662
2/2
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 37 times.
 38 if(size() == 0lu){return false;}
663 37 const PString & str = *this;
664 37 bool isNumber(true);
665 37 size_t i(0lu);
666
6/6
✓ Branch 1 taken 54 times.
✓ Branch 2 taken 24 times.
✓ Branch 3 taken 41 times.
✓ Branch 4 taken 13 times.
✓ Branch 5 taken 41 times.
✓ Branch 6 taken 37 times.
 78 while(i < str.size() && isNumber){
667 41 isNumber = phoenix_isCharNumber(str[i]);
668 41 ++i;
669 }
670 37 return isNumber;
671 }
672
673 ///Convert PString in lower case
674 /** @return lower case PString
675 */
676 2985 PString PString::toLower() const{
677
3/3
✓ Branch 1 taken 4 times.
✓ Branch 2 taken 2981 times.
✓ Branch 4 taken 4 times.
 2985 if(size() == 0lu){return *this;}
678 2981 const PString & str = *this;
679
1/1
✓ Branch 2 taken 2981 times.
 2981 std::string strOut("");
680 char currentChar;
681 2981 long unsigned int size(str.size());
682
2/2
✓ Branch 0 taken 10447 times.
✓ Branch 1 taken 2981 times.
 13428 for(long unsigned int i(0lu); i < size; ++i){
683 10447 currentChar = str[i];
684
3/3
✓ Branch 1 taken 10447 times.
✓ Branch 3 taken 582 times.
✓ Branch 4 taken 9865 times.
 10447 if(phoenix_isCharUpperCase(currentChar)){
685
1/1
✓ Branch 1 taken 582 times.
 582 strOut += currentChar + (char)32;
686 }else{
687
1/1
✓ Branch 1 taken 9865 times.
 9865 strOut += currentChar;
688 }
689 }
690
1/1
✓ Branch 1 taken 2981 times.
 2981 return strOut;
691 2981 }
692
693 ///Convert std::string in lower case and space in '_'
694 /** @return std::string in lower case and space in '_'
695 */
696 3 PString PString::toLowerUnderscore() const{
697
3/3
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 2 times.
✓ Branch 4 taken 1 times.
 3 if(size() == 0lu){return *this;}
698 2 const PString & str = *this;
699
1/1
✓ Branch 2 taken 2 times.
 2 std::string strOut("");
700 char currentChar;
701 2 long unsigned int size(str.size());
702
2/2
✓ Branch 0 taken 21 times.
✓ Branch 1 taken 2 times.
 23 for(long unsigned int i(0lu); i < size; ++i){
703 21 currentChar = str[i];
704
3/3
✓ Branch 1 taken 21 times.
✓ Branch 3 taken 4 times.
✓ Branch 4 taken 17 times.
 21 if(phoenix_isCharUpperCase(currentChar)){
705
1/1
✓ Branch 1 taken 4 times.
 4 strOut += currentChar + (char)32;
706 }else{
707
3/3
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 16 times.
✓ Branch 3 taken 1 times.
 17 if(currentChar == ' '){strOut += '_';}
708
1/1
✓ Branch 1 taken 16 times.
 16 else{strOut += currentChar;}
709 }
710 }
711
1/1
✓ Branch 1 taken 2 times.
 2 return strOut;
712 2 }
713
714 ///Convert std::string in upper case
715 /** @return lower case std::string
716 */
717 4 PString PString::toUpper() const{
718
3/3
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 3 times.
✓ Branch 4 taken 1 times.
 4 if(size() == 0lu){return *this;}
719 3 const PString & str = *this;
720
1/1
✓ Branch 2 taken 3 times.
 3 std::string strOut("");
721 char currentChar;
722 3 long unsigned int size(str.size());
723
2/2
✓ Branch 0 taken 42 times.
✓ Branch 1 taken 3 times.
 45 for(long unsigned int i(0); i < size; ++i){
724 42 currentChar = str[i];
725
3/3
✓ Branch 1 taken 42 times.
✓ Branch 3 taken 32 times.
✓ Branch 4 taken 10 times.
 42 if(phoenix_isCharLowerCase(currentChar)){
726
1/1
✓ Branch 1 taken 32 times.
 32 strOut += currentChar - (char)32;
727 }else{
728
1/1
✓ Branch 1 taken 10 times.
 10 strOut += currentChar;
729 }
730 }
731
1/1
✓ Branch 1 taken 3 times.
 3 return strOut;
732 3 }
733
734 ///Convert first letter of the PString in lower case
735 /** @return PString with first letter of the PString in lower case
736 */
737 4 PString PString::firstToLower() const{
738
3/3
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 3 times.
✓ Branch 4 taken 1 times.
 4 if(size() == 0lu){return *this;}
739 3 const PString & str = *this;
740
1/1
✓ Branch 1 taken 3 times.
 3 std::string strOut(str);
741
1/1
✓ Branch 1 taken 3 times.
 3 char currentChar = strOut[0lu];
742
3/3
✓ Branch 1 taken 3 times.
✓ Branch 3 taken 2 times.
✓ Branch 4 taken 1 times.
 3 if(phoenix_isCharUpperCase(currentChar)){
743
1/1
✓ Branch 1 taken 2 times.
 2 strOut[0lu] = currentChar + (char)32;
744 }
745
1/1
✓ Branch 1 taken 3 times.
 3 return strOut;
746 3 }
747
748 ///Convert first letter of the PString in upper case
749 /** @return PString with first letter of the PString in upper case
750 */
751 5 PString PString::firstToUpper() const{
752
3/3
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 4 times.
✓ Branch 4 taken 1 times.
 5 if(size() == 0lu){return *this;}
753 4 const PString & str = *this;
754
1/1
✓ Branch 1 taken 4 times.
 4 std::string strOut(str);
755
1/1
✓ Branch 1 taken 4 times.
 4 char currentChar = strOut[0lu];
756
3/3
✓ Branch 1 taken 4 times.
✓ Branch 3 taken 2 times.
✓ Branch 4 taken 2 times.
 4 if(phoenix_isCharLowerCase(currentChar)){
757
1/1
✓ Branch 1 taken 2 times.
 2 strOut[0lu] = currentChar - (char)32;
758 }
759
1/1
✓ Branch 1 taken 4 times.
 4 return strOut;
760 4 }
761
762 ///Escape given string with passed characters
763 /** @param strCharToEscape : list of the characters to be escaped
764 * @param escapeSeq : escape sequence (could be one char)
765 * @return escaped string
766 */
767 8 PString PString::escapeStr(const PString & strCharToEscape, const PString & escapeSeq) const{
768
4/10
✓ Branch 1 taken 8 times.
✗ Branch 2 not taken.
✓ Branch 4 taken 8 times.
✗ Branch 5 not taken.
✗ Branch 7 not taken.
✓ Branch 8 taken 8 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 8 times.
✗ Branch 12 not taken.
✗ Branch 13 not taken.
 8 if(size() == 0lu || strCharToEscape.size() == 0lu || escapeSeq.size() == 0lu){return *this;}
769 8 const PString & src = *this;
770
1/1
✓ Branch 2 taken 8 times.
 8 std::string out("");
771
2/2
✓ Branch 1 taken 668 times.
✓ Branch 2 taken 8 times.
 676 for(size_t i(0lu); i < src.size(); ++i){
772 668 char ch = src[i];
773
3/3
✓ Branch 1 taken 668 times.
✓ Branch 3 taken 7 times.
✓ Branch 4 taken 661 times.
 668 if(strCharToEscape.find(ch)){
774
1/1
✓ Branch 1 taken 7 times.
 7 out += escapeSeq;
775 }
776
1/1
✓ Branch 1 taken 668 times.
 668 out += ch;
777 }
778
1/1
✓ Branch 1 taken 8 times.
 8 return out;
779 8 }
780
781 ///Copy function of PString
782 /** @param other : class to copy
783 */
784 510526410 void PString::copyPString(const PString & other){
785 510526410 resize(other.size());
786 510526410 memcpy((char*)data(), other.data(), other.size());
787 510526410 }
788
789 ///Copy function of PString
790 /** @param other : class to copy
791 */
792 7065476 void PString::copyPString(const std::string & other){
793 7065476 resize(other.size());
794 7065476 memcpy((char*)data(), other.data(), other.size());
795 7065476 }
796
797 ///Concatenate a PString into the current PString
798 /** @param other : PString to be added
799 */
800 6894281 void PString::concatenatePString(const PString & other){
801
1/1
✓ Branch 1 taken 6894281 times.
 6894281 std::string tmp(*this);
802
1/1
✓ Branch 3 taken 6894281 times.
 6894281 resize(tmp.size() + other.size());
803 6894281 memcpy((char*)data(), tmp.data(), tmp.size());
804 6894281 memcpy((char*)data() + tmp.size(), other.data(), other.size());
805 6894281 }
806
807 ///Concatenate a std::string into the current PString
808 /** @param other : std::string to be added
809 */
810 258548848 void PString::concatenatePString(const std::string & other){
811
1/1
✓ Branch 1 taken 258548848 times.
 258548848 std::string tmp(*this);
812
1/1
✓ Branch 3 taken 258548848 times.
 258548848 resize(tmp.size() + other.size());
813 258548848 memcpy((char*)data(), tmp.data(), tmp.size());
814 258548848 memcpy((char*)data() + tmp.size(), other.data(), other.size());
815 258548848 }
816
817 ///Initialisation function of the class PString
818 568197635 void PString::initialisationPString(){
819
820 568197635 }
821
822
823
824
825
826