string_function.cpp

Go to the documentation of this file.

/***************************************
        Auteur : Pierre Aubert
        Mail : pierre.aubert@lapp.in2p3.fr
        Licence : CeCILL-C
****************************************/
 
 
#include "string_function.h"
 
 
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;
}
 
 
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;
}
 
 
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;
}
 
 
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;
}
 
 
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;
}
 
 
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;
        }
}
 
 
std::string eraseFirstLastChars(const std::string& str, const std::string & chars){
        std::string buffer(eraseFirstCharsInStr(str, chars));
        return eraseLastCharsInStr(buffer, chars);
}
 
 
std::vector<std::string> eraseFirstLastChars(const std::vector<std::string> & vecStr, const std::string & chars){
        std::vector<std::string> vecOut;
        for(std::vector<std::string>::const_iterator it(vecStr.begin()); it != vecStr.end(); ++it){
                vecOut.push_back(eraseFirstLastChars(*it, chars));
        }
        return vecOut;
}
 
 
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;
}
 
 
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;
}
 
 
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;
}
 
 
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;
}
 
 
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;
}
 
 
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;
}
 
 
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;
}
 
 
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
}
 
 
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;
}
 
 
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;
}
 
 
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);
        }
}
 
 
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);
        }
}
 
 
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;
        }
}
 
 
std::string replaceStrInStr(const std::string & src, const std::map<std::string, std::string> & mapReplace){
        std::string out("");
        replaceStrInStr(out, src, mapReplace);
        return out;
}
 
 
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;
}
 
 
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;
}
 
 
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;
}
 
 
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;
}
 
 
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;
}
 
 
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;
}
 
 
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;
}
 
 
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;
}
 
 
 
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;
}
 
 
std::string phoenix_charToString(const char * ch){
        if(ch != NULL){
                std::string str(ch);
                return str;
        }else{
                return "";
        }
}
 
 
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;
}