Head

GCC Code Coverage Report
Directory:	./		Exec	Total	Coverage
File:	tmp_project/StringUtils/src/string_function.cpp	Lines:	252	253	99.6 %
Date:	2024-09-10 03:06:26	Branches:	261	272	96.0 %

/***************************************
	Auteur : Pierre Aubert
	Mail : pierre.aubert@lapp.in2p3.fr
	Licence : CeCILL-C
****************************************/


#include "string_function.h"

///Find a char in a string
/**	@param str : string to be used
 * 	@param ch : char to be searched
 * 	@return true if the char has been found, false otherwise
*/
bool findInString(const std::string& str, char ch){
	std::string::const_iterator it = str.begin();
	while(it != str.end()){
		if(*it == ch) return true;
		++it;
	}
	return false;
}

///Find multiple chars in a string
/**	@param str : string to be used
 * 	@param chars : chars to be searched
 * 	@return true if one of the chars has been found, false otherwise
*/
bool findCharsInString(const std::string & str, const std::string & chars){
	if(str.size() == 0lu || chars.size() == 0lu){return false;}
	bool foundChar = false;
	long unsigned int i(0lu), size(chars.size());
	while(!foundChar && i < size){
		foundChar = findInString(str, chars[i]);
		++i;
	}
	return foundChar;
}

///Find a string in a list of string
/**	@param listStr : list of string
 * 	@param str : string to be searched
 * 	@return true if the string has been found, false otherwise
*/
bool findInListString(const std::list<std::string> & listStr, const std::string & str){
	if(listStr.size() == 0lu || str == ""){return false;}
	bool isSearch(true);
	std::list<std::string>::const_iterator it(listStr.begin());
	while(it != listStr.end() && isSearch){
		isSearch = *it != str;
		++it;
	}
	return !isSearch;
}

///Find a string in a vector of string
/**	@param vecStr : vector of string
 * 	@param str : string to be searched
 * 	@return true if the string has been found, false otherwise
*/
bool findInVectorString(const std::vector<std::string> & vecStr, const std::string & str){
	if(vecStr.size() == 0lu || str == ""){return false;}
	bool isSearch(true);
	std::vector<std::string>::const_iterator it(vecStr.begin());
	while(it != vecStr.end() && isSearch){
		isSearch = *it != str;
		++it;
	}
	return !isSearch;
}

///Erase first char in a string
/**	@param str : string to be modifed
 * 	@param chars : chars to be searched and removed
	@return modifed string
*/
std::string eraseFirstCharsInStr(const std::string& str, const std::string & chars){
	std::string buffer(str);
	bool continuer = true;
	std::string::iterator it = buffer.begin();
	//Let's remove the first chars
	while(it != buffer.end() && continuer){
		if(findInString(chars, *it)){it = buffer.erase(it);}
		else{
			continuer = false;
			it++;
		}
	}
	return buffer;
}

///Erase first and last char in a string
/**	@param str : string to be modifed
 * 	@param chars : chars to be searched and removed
	@return modifed string
*/
std::string eraseLastCharsInStr(const std::string& str, const std::string & chars){
	if(str.size() > 0lu){
		size_t nbCharToRemove(0lu);
		std::string::const_reverse_iterator it(str.rbegin());
		while(findInString(chars, *it)){
			++it;
			++nbCharToRemove;
		}

		if(nbCharToRemove == 0lu){
			return str;
		}else{
			std::string buffer(str.substr(0, str.size() - nbCharToRemove));
			return buffer;
		}
	}else{
		return str;
	}
}

///Erase first and last char in a string
/**	@param str : string to be modifed
 * 	@param chars : chars to be searched and removed
	@return modifed string
*/
std::string eraseFirstLastChars(const std::string& str, const std::string & chars){
	std::string buffer(eraseFirstCharsInStr(str, chars));
	return eraseLastCharsInStr(buffer, chars);
}

///Count number of chararacters ch in string
/**	@param str : string to be used
 * 	@param ch : character to be serached
 * 	@return number of character ch in string
*/
size_t countNbChar(const std::string & str, char ch){
	size_t nbChar(0lu);
	std::string::const_iterator it(str.begin());
	while(it != str.end()){
		if(*it == ch) nbChar++;
		it++;
	}
	return nbChar;
}

///copie la string str en effaçant le caractère ch
/**	@param str : chaîne à copier
	@param ch : caractère à effacer
	@return string sans le caractère ch
*/
std::string eraseCharInStr(const std::string& str, char ch){
	std::string buffer = "";
	for(std::string::const_iterator it = str.begin(); it != str.end(); it++){
		if(*it != ch) buffer += *it;
	}
	return buffer;
}

///copie la string str en effaçant les caractères rmchs
/**	@param str : chaîne à copier
	@param rmchs : caractères à effacer
	@return string sans les caractères rmchs
*/
std::string eraseCharsInStr(const std::string& str, const std::string & rmchs){
	std::string buffer = str;
	for(std::string::const_iterator it = rmchs.begin(); it != rmchs.end(); it++){
		buffer = eraseCharInStr(buffer, *it);
	}
	return buffer;
}

///fonction qui remplace un caractère par un autre dans une string
/**	@param str : string à modifier
 * 	@param find : caractère à trouver dans la string
 * 	@param replace : caractère à remplacer dans la string
 * 	@return string modifiée
*/
std::string replaceCharInStr(const std::string& str, char find, char replace){
	std::string buffer = "";
	for(std::string::const_iterator it = str.begin(); it != str.end(); it++){
		if(*it == find){
			buffer += replace;
		}else{
			buffer += *it;
		}
	}
	return buffer;
}

///Replace all char in the strFind by char replace
/**	@param str : string to be modified
 * 	@param strFind : string of the characters to be found
 * 	@param replace : character to be found
 * 	@return modified string
*/
std::string replaceCharsInStr(const std::string & str, const std::string & strFind, char replace){
	if(str == "" || strFind == "") return str;
	std::string out(str);
	for(long unsigned int i(0lu); i < strFind.size(); ++i){
		out = replaceCharInStr(out, strFind[i], replace);
	}
	return out;
}

///fonction qui remplace un caractère par un autre dans une string
/**	@param str : string à modifier
 * 	@param find : caractère à trouver dans la string
 * 	@param replace : chaîne à remplacer dans la string
 * 	@return string modifiée
*/
std::string replaceCharInStr(const std::string& str, char find, const std::string& replace){
	std::string buffer = "";
	for(std::string::const_iterator it = str.begin(); it != str.end(); it++){
		if(*it == find){
			buffer += replace;
		}else{
			buffer += *it;
		}
	}
	return buffer;
}

///Count the number of patern in string
/**	@param src : string to be analysed
 * 	@param patern : patern to be serached
 * 	@return number of occurence of patern in src
*/
size_t countStrInStr(const std::string & src, const std::string & patern){
	long unsigned int sizePatern(patern.size());
	if(sizePatern == 0lu || src == ""){return 0lu;}
	size_t nbPaternFound(0lu);

	long unsigned int sizeSrc(src.size());
	long unsigned int beginTest(0lu), nbMatch(0lu);
	for(long unsigned int i(0lu); i < sizeSrc; ++i){
		if(src[i] == patern[nbMatch]){ //si le caractère i est le même que le caractère nbMatch
			if(nbMatch == 0lu){ //c'est le premier qu'on teste
				beginTest = i; //il faut donc se rappeler où on a commencer à faire le teste
			}
			++nbMatch;          //la prochaîne fois on testera le caractère suivant
			if(nbMatch == sizePatern){ //dans ce cas, on a tout testé et tout les caractères correspondent, donc on sauvegarde
				++nbPaternFound;
				beginTest = 0lu;  //on remet le début des tests à 0 (pour évité les dépassements, on ne sait jamais)
				nbMatch = 0lu;    //on remet ne nombre des tests à 0, comme on n'a pas trouver de nouveau le motif
			}
		}else{                      //si le caractère i n'est pas le même caractère que nbMatch
			if(nbMatch != 0lu){        //si on avais déjà tester des caractères avant
				i = beginTest;
			}
			beginTest = 0lu;  //on remet le début des tests à 0 (pour évité les dépassements, on ne sait jamais)
			nbMatch = 0lu;    //on remet ne nombre des tests à 0, comme on n'a pas trouver de nouveau le motif
		}
	}
	return nbPaternFound;
}

///Replace a patern by an other in the input string
/**	@param[out] out : output string
 * 	@param src : input string
 * 	@param patern : patern to be searched
 * 	@param replace : string which replace patern
*/
void replaceStrInStr(std::string & out, const std::string & src, const std::string & patern, const std::string & replace){
	long unsigned int sizePatern(patern.size());
	if(sizePatern == 0lu || src == "") return;
	out = ""; //on évite les petits désagréments
	long unsigned int sizeSrc(src.size());
	long unsigned int beginTest(0lu), nbMatch(0lu);
	for(long unsigned int i(0lu); i < sizeSrc; ++i){
		if(src[i] == patern[nbMatch]){ //si le caractère i est le même que le caractère nbMatch
			if(nbMatch == 0lu){ //c'est le premier qu'on teste
				beginTest = i; //il faut donc se rappeler où on a commencer à faire le teste
			}
			++nbMatch;          //la prochaîne fois on testera le caractère suivant
			if(nbMatch == sizePatern){ //dans ce cas, on a tout testé et tout les caractères correspondent, donc on sauvegarde
				out += replace; //on a trouver le motif patern, donc on le remplace par le motif replace
				beginTest = 0lu;  //on remet le début des tests à 0 (pour évité les dépassements, on ne sait jamais)
				nbMatch = 0lu;    //on remet ne nombre des tests à 0, comme on n'a pas trouver de nouveau le motif
			}
		}else{                      //si le caractère i n'est pas le même caractère que nbMatch
			if(nbMatch == 0lu){        //si on n'en avait pas trouver de bon avant
				out += src[i];       //on ne change rien à ce caractère
			}else{                  //si on avais déjà tester des caractères avant
				out += src[beginTest];
				i = beginTest;
			}
			beginTest = 0lu;  //on remet le début des tests à 0 (pour évité les dépassements, on ne sait jamais)
			nbMatch = 0lu;    //on remet ne nombre des tests à 0, comme on n'a pas trouver de nouveau le motif
		}
	}
	//We are potentially at the end of the source, so no more test
}

///Replace a patern by an other in the input string
/**	@param src : input string
 * 	@param patern : patern to be searched
 * 	@param replace : string which replace patern
 * 	@return output string
*/
std::string replaceStrInStr(const std::string & src, const std::string & patern, const std::string & replace){
	std::string result("");
	replaceStrInStr(result, src, patern, replace);
	return result;
}

///Replace a patern by an other in the input string in a vector of string
/**	@param vecSrc : vector of input strings
 * 	@param patern : patern to be searched
 * 	@param replace : string which replace patern
 * 	@return output string
*/
std::vector<std::string> replaceStrInStr(const std::vector<std::string> & vecSrc, const std::string & patern, const std::string & replace){
	std::vector<std::string> vecOut;
	for(std::vector<std::string>::const_iterator it(vecSrc.begin()); it != vecSrc.end(); ++it){
		vecOut.push_back(replaceStrInStr(*it, patern, replace));
	}
	return vecOut;
}

///Replace all the vector patern in the string srcDest by the replace string
/**	@param[out] srcDest : source and modified string
 * 	@param vecPatern : vector of the paterns we want to search
 * 	@param replace : string we want to replace
*/
void replaceVectorStrInStr(std::string & srcDest, const std::vector<std::string> & vecPatern, const std::string & replace){
	if(srcDest == "" || vecPatern.size() == 0lu) return;
	for(std::vector<std::string>::const_iterator it(vecPatern.begin()); it != vecPatern.end(); ++it){
		srcDest = replaceStrInStr(srcDest, *it, replace);
	}
}

///Replace all the list patern in the string srcDest by the replace string
/**	@param[out] srcDest : source and modified string
 * 	@param listPatern : vector of the paterns we want to search
 * 	@param replace : string we want to replace
*/
void replaceListStrInStr(std::string & srcDest, const std::list<std::string> & listPatern, const std::string & replace){
	if(srcDest == "" || listPatern.size() == 0lu) return;
	for(std::list<std::string>::const_iterator it(listPatern.begin()); it != listPatern.end(); ++it){
		srcDest = replaceStrInStr(srcDest, *it, replace);
	}
}

///Replace a map of string in  a string
/**	@param[out] out : updated string
 * 	@param src : source string
 * 	@param mapReplace : map of patterns (keys) and value to replace (values)
*/
void replaceStrInStr(std::string & out, const std::string & src, const std::map<std::string, std::string> & mapReplace){
	if(mapReplace.size() == 0lu){
		out = src;
		return;
	}
	std::string tmpStr(src);
	for(std::map<std::string, std::string>::const_iterator it(mapReplace.begin()); it != mapReplace.end(); ++it){
		replaceStrInStr(out, tmpStr, it->first, it->second);
		tmpStr = out;
	}
}

///Replace a map of string in  a string
/**	@param src : source string
 * 	@param mapReplace : map of patterns (keys) and value to replace (values)
 * 	@return updated string
*/
std::string replaceStrInStr(const std::string & src, const std::map<std::string, std::string> & mapReplace){
	std::string out("");
	replaceStrInStr(out, src, mapReplace);
	return out;
}

///Replace all the vector patern in the string srcDest by the replace string
/**	@param src : source string
 * 	@param vecPatern : vector of the paterns we want to search
 * 	@param replace : string we want to replace
 * 	@return modified string
*/
std::string replaceVectorStrInStr(const std::string & src, const std::vector<std::string> & vecPatern, const std::string & replace){
	std::string result(src);
	replaceVectorStrInStr(result, vecPatern, replace);
	return result;
}

///Replace all the list patern in the string srcDest by the replace string
/**	@param src : source string
 * 	@param vecPatern : vector of the paterns we want to search
 * 	@param replace : string we want to replace
 * 	@return modified string
*/
std::string replaceListStrInStr(const std::string & src, const std::list<std::string> & vecPatern, const std::string & replace){
	std::string result(src);
	replaceListStrInStr(result, vecPatern, replace);
	return result;
}

///Escape given string with passed characters
/**	@param src : string to be excaped
 * 	@param strCharToEscape : list of the characters to be escaped
 * 	@param escapeStr : escape sequence (could be one char)
 * 	@return escaped string
*/
std::string phoenix_escapeStr(const std::string & src, const std::string & strCharToEscape, const std::string & escapeStr){
	std::string out("");
	for(size_t i(0lu); i < src.size(); ++i){
		char ch = src[i];
		if(findInString(strCharToEscape, ch)){
			out += escapeStr;
		}
		out += ch;
	}
	return out;
}

///Cut a string the the given separator char
/**	@param str : string to be cut
	@param separator : separtor char
	@return list of string
*/
std::list<std::string> cutStringList(const std::string & str, char separator){
	std::list<std::string> liste;
	std::string buffer = "";
	for(std::string::const_iterator it = str.begin(); it != str.end(); ++it){
		if(*it != separator){
			buffer += *it;
		}else{
			liste.push_back(buffer);
			buffer = "";
		}
	}
	if(buffer != ""){liste.push_back(buffer);}
	return liste;
}

///Cut a string the the given separator char
/**	@param str : string to be cut
	@param separator : separtor char
	@return vector of string
*/
std::vector<std::string> cutStringVector(const std::string & str, char separator){
	std::vector<std::string> vec;
	std::string buffer = "";
	for(std::string::const_iterator it = str.begin(); it != str.end(); ++it){
		if(*it != separator){
			buffer += *it;
		}else{
			vec.push_back(buffer);
			buffer = "";
		}
	}
	if(buffer != ""){vec.push_back(buffer);}
	return vec;
}

///Cut a string on white characters ('&#92;t' ou ' ')
/**	@param str : string to be cut
	@return list of string
*/
std::list<std::string> cutStringOnSpacesList(const std::string& str){
	std::list<std::string> liste;
	if(str.size() != 0lu){
		std::string buffer("");
		for(std::string::const_iterator it(str.begin()); it != str.end(); ++it){
			if(*it != '\t' && *it != ' ' && *it !='\n'){
				buffer += *it;
			}else{
				if(buffer != ""){
					liste.push_back(buffer);
					buffer = "";
				}
			}
		}
		if(buffer != "") liste.push_back(buffer);
	}
	return liste;
}

///Cut a string on white characters ('&#92;t' ou ' ')
/**	@param str : string to be cut
	@return vector of string
*/
std::vector<std::string> cutStringOnSpacesVector(const std::string& str){
	std::vector<std::string> vec;
	if(str.size() != 0lu){
		std::string buffer("");
		for(std::string::const_iterator it(str.begin()); it != str.end(); ++it){
			if(*it != '\t' && *it != ' ' && *it !='\n'){
				buffer += *it;
			}else{
				if(buffer != ""){
					vec.push_back(buffer);
					buffer = "";
				}
			}
		}
		if(buffer != "") vec.push_back(buffer);
	}
	return vec;
}

///Copy a string of nbCh starting from begin char
/**	@param str : string to be copied
	@param begin : first character index
	@param nbCh : number of characters to be copied
	@return sub string of input string
*/
std::string copyStr(const std::string& str, long unsigned int begin, long unsigned int nbCh){
	if(str.size() < begin) return "";
	if(str.size() < begin + nbCh) nbCh = str.size() - begin;
	std::string str2("");
	for(long unsigned int i(begin); i <  begin + nbCh; ++i){
		str2 += str[i];
	}
	return str2;
}


///Check if two string start the same way
/**	@param str : string to be tested
	@param beginig : begining to be checked
	@return true if str starts as beginig
*/
bool isSameBegining(const std::string & str, const std::string & beginig){
	if(str.size() < beginig.size()) return false;
	std::string::const_iterator it = str.begin();
	std::string::const_iterator it2 = beginig.begin();
	while(it != str.end() && it2 != beginig.end()){
		if(*it != *it2){ return false;}
		it++;
		it2++;
	}
	return true;
}

///Convert a char pointer into a string (event if the char pointer is NULL)
/**	@param ch : char pointer to be converted into a string
 * 	@return corresponding string, or empty string if the input char pointer is NULL
*/
std::string phoenix_charToString(const char * ch){
	if(ch != NULL){
		std::string str(ch);
		return str;
	}else{
		return "";
	}
}

///Get the common begining between str1 and str2
/**	@param str1 : string
 * 	@param str2 : string
 * 	@return common begining between str1 and str2
*/
std::string phoenix_getCommonBegining(const std::string & str1, const std::string & str2){
	std::string out("");
	std::string::const_iterator it = str1.begin();
	std::string::const_iterator it2 = str2.begin();
	while(it != str1.end() && it2 != str2.end()){
		if(*it == *it2){
			out += *it;
		}else{
			break;
		}
		it++;
		it2++;
	}
	return out;
}


Generated by: GCOVR (Version 4.2)