PString.cpp

Go to the documentation of this file.

/***************************************
        Auteur : Pierre Aubert
        Mail : pierre.aubert@lapp.in2p3.fr
        Licence : CeCILL-C
****************************************/
 
 
#include "PString.h"
 
 
PString phoenix_charToString(const char * ch){
        if(ch != NULL){
                PString str(ch);
                return str;
        }else{
                return "";
        }
}
 
 
bool phoenix_isCharUpperCase(char ch){
        return (ch >= 65 && ch <= 90);
}
 
 
bool phoenix_isCharLowerCase(char ch){
        return (ch >= 97 && ch <= 122);
}
 
 
bool phoenix_isCharNumber(char ch){
        return (ch >= 48 && ch <= 57);
}
 
 
void eraseFirstLastChar(PVecString & vecOut, const PVecString & vecStr, const PString & vecChar){
        for(PVecString::const_iterator it(vecStr.begin()); it != vecStr.end(); ++it){
                vecOut.push_back(it->eraseFirstLastChar(vecChar));
        }
}
 
 
PVecString eraseFirstLastChar(const PVecString & vecStr, const PString & vecChar){
        PVecString vecOut;
        eraseFirstLastChar(vecOut, vecStr, vecChar);
        return vecOut;
}
 
 
bool findInVectorString(const PVecString & vecStr, const PString & str){
        if(vecStr.size() == 0lu || str == ""){return false;}
        bool isSearch(true);
        PVecString::const_iterator it(vecStr.begin());
        while(it != vecStr.end() && isSearch){
                isSearch = *it != str;
                ++it;
        }
        return !isSearch;
}
 
PString::PString()
        :std::string("")
{
        initialisationPString();
}
 
 
PString::PString(const char * str)
        :std::string(str)
{
        initialisationPString();
}
 
 
PString::PString(const std::string & str)
        :std::string(str)
{
        initialisationPString();
}
 
 
PString::PString(const PString & other)
        :std::string()
{
        copyPString(other);
}
 
PString::~PString(){
        
}
 
 
PString & PString::operator = (const PString & other){
        copyPString(other);
        return *this;
}
 
 
PString & PString::operator = (const std::string & other){
        copyPString(other);
        return *this;
}
 
 
PString & PString::operator += (const PString & other){
        return add(other);
}
 
 
PString & PString::operator += (const  std::string & other){
        return add(other);
}
 
 
PString & PString::operator += (char ch){
        return add(ch);
}
 
 
PString & PString::add(const PString & other){
        concatenatePString(other);
        return *this;
}
 
 
PString & PString::add(const std::string & other){
        concatenatePString(other);
        return *this;
}
 
 
PString & PString::add(char ch){
        std::string str;
        str+= ch;
        concatenatePString(str);
        return *this;
}
 
 
PString & PString::add(const char * str){
        concatenatePString(phoenix_charToString(str));
        return *this;
}
 
 
PString operator + (const PString & other1, const PString & other2){
        PString res(other1);
        res += other2;
        return res;
}
 
 
size_t PString::findPatternIndex(const PString & pattern, size_t offset) const{
        size_t sizePatern(pattern.size());
        const PString & src = *this;
        if(sizePatern == 0lu || src.size() < offset + sizePatern){return size();}
        
        size_t sizeSrc(src.size());
        size_t beginTest(0lu), nbMatch(0lu);
        for(size_t i(offset); i < sizeSrc; ++i){
                if(src[i] == pattern[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
                                return beginTest;       //on a trouver le motif pattern, donc on le remplace par le motif replaceStr
                        }
                }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;  //On revient là où l'on avait fait le premier test
                        }
                        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 sizeSrc;
}
 
 
PString PString::getBetweenDelimiter(const PString & beginPattern, const PString & endPattern) const{
        size_t indexBeginPattern(findPatternIndex(beginPattern) + beginPattern.size());
        size_t indexEndPattern(findPatternIndex(endPattern, indexBeginPattern));
        if(indexBeginPattern != size() && indexEndPattern != size()){
                return substr(indexBeginPattern, indexEndPattern - indexBeginPattern);
        }else{
                return "";
        }
}
 
 
PString PString::replace(const PString & pattern, const PString & replaceStr) const{
        size_t sizePatern(pattern.size());
        const PString & src = *this;
        if(sizePatern == 0lu || src.size() == 0lu) return *this;
        PString out(""); //on évite les petits désagréments
        size_t sizeSrc(src.size());
        size_t beginTest(0lu), nbMatch(0lu);
        for(size_t i(0lu); i < sizeSrc; ++i){
                if(src[i] == pattern[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 += replaceStr; //on a trouver le motif pattern, donc on le remplace par le motif replaceStr
                                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
        return out;
}
 
 
PString PString::replace(const PString & pattern, const PString & replaceStr, size_t maxNbReplace) const{
        size_t sizePatern(pattern.size());
        const PString & src = *this;
        if(sizePatern == 0lu || src.size() == 0lu || maxNbReplace == 0lu) return *this;
        PString out(""); //on évite les petits désagréments
        size_t sizeSrc(src.size());
        size_t beginTest(0lu), nbMatch(0lu), nbReplace(0lu);
        for(size_t i(0lu); i < sizeSrc; ++i){
                if(src[i] == pattern[nbMatch] && nbReplace < maxNbReplace){ //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 += replaceStr; //on a trouver le motif pattern, donc on le remplace par le motif replaceStr
                                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
                                ++nbReplace;
                        }
                }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
        return out;
}
 
 
PString PString::replaceChar(const PString & vecChar, const PString & replaceStr) const{
        PString out;
        for(PString::const_iterator it(begin()); it != end(); ++it){
                if(vecChar.find(*it)){
                        out += replaceStr;
                }else{
                        out += *it;
                }
        }
        return out;
}
 
 
PString PString::format(const PString & arg) const{
        return replace("{}", arg, 1lu);
}
 
 
bool PString::isSameBegining(const PString & beginStr) const{
        const PString & src = *this;
        if(src.size() < beginStr.size()) return false;
        std::string::const_iterator it = src.begin();
        std::string::const_iterator it2 = beginStr.begin();
        while(it != src.end() && it2 != beginStr.end()){
                if(*it != *it2){ return false;}
                it++;
                it2++;
        }
        return true;
}
 
 
size_t PString::count(char ch) const{
        const PString & str(*this);
        size_t nbChar(0lu);
        std::string::const_iterator it(str.begin());
        while(it != str.end()){
                if(*it == ch) nbChar++;
                it++;
        }
        return nbChar;
}
 
 
size_t PString::count(const PString & patern) const{
        const PString & src = *this;
        long unsigned int sizePatern(patern.size()), sizeSrc(src.size());
        if(sizePatern == 0lu || sizeSrc == 0lu){return 0lu;}
        size_t nbPaternFound(0lu);
        
        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;
}
 
 
bool PString::find(char ch) const{
        PString::const_iterator it = begin();
        while(it != end()){
                if(*it == ch) return true;
                ++it;
        }
        return false;
}
 
 
bool PString::find(const PString & listChar) const{
        if(size() == 0lu || listChar.size() == 0lu){return false;}
        bool foundChar = false;
        long unsigned int i(0lu), size(listChar.size());
        while(!foundChar && i < size){
                foundChar = find(listChar[i]);
                ++i;
        }
        return foundChar;
}
 
 
PString PString::keepChar(const PString & listChar) const{
        if(listChar.size() == 0lu){return "";}
        PString out;
        for(PString::const_iterator it = begin(); it != end(); ++it){
                if(listChar.find(*it)){
                        out += *it;
                }
        }
        return out;
}
 
 
PString PString::getCommonBegining(const PString & other) const{
        PString out("");
        const PString & str1(*this);
        PString::const_iterator it = str1.begin();
        PString::const_iterator it2 = other.begin();
        while(it != str1.end() && it2 != other.end()){
                if(*it == *it2){
                        out += *it;
                }else{
                        break;
                }
                it++;
                it2++;
        }
        return out;
}
 
 
std::vector<PString> PString::split(char separator) const{
        std::vector<PString> vec;
        PString buffer = "";
        for(PString::const_iterator it = begin(); it != end(); ++it){
                if(*it != separator){
                        buffer += *it;
                }else{
                        vec.push_back(buffer);
                        buffer = "";
                }
        }
        if(buffer != ""){vec.push_back(buffer);}
        return vec;
}
 
 
std::vector<PString> PString::split(const PString & vecSeparator) const{
        std::vector<PString> vec;
        if(size() != 0lu && vecSeparator.size() != 0lu){
                PString buffer("");
                for(PString::const_iterator it(begin()); it != end(); ++it){
                        if(!vecSeparator.find(*it)){
                                buffer += *it;
                        }else{
                                if(buffer != ""){
                                        vec.push_back(buffer);
                                        buffer = "";
                                }
                        }
                }
                if(buffer != "") vec.push_back(buffer);
        }
        return vec;
}
 
 
 
PString & PString::merge(const std::vector<PString> & vecStr, const PString & separator){
        PString out(""), comma("");;
        for(std::vector<PString>::const_iterator it(vecStr.begin()); it != vecStr.end(); ++it){
                out += comma + (*it);
                comma = separator;
        }
        *this = out;
        return *this;
}
 
 
PString PString::eraseChar(char ch) const{
        PString buffer = "";
        for(PString::const_iterator it = begin(); it != end(); it++){
                if(*it != ch) buffer += *it;
        }
        return buffer;
}
 
 
PString PString::eraseChar(const PString & vecChar) const{
        PString buffer(*this);
        for(PString::const_iterator it = vecChar.begin(); it != vecChar.end(); it++){
                buffer = buffer.eraseChar(*it);
        }
        return buffer;
}
 
 
PString PString::eraseFirstChar(const PString & vecChar) const{
        PString buffer(*this);
        bool continuer = true;
        PString::iterator it = buffer.begin();
        //Let's remove the first chars
        while(it != buffer.end() && continuer){
                if(vecChar.find(*it)){it = buffer.erase(it);}
                else{
                        continuer = false;
                        it++;
                }
        }
        return buffer;
}
 
 
PString PString::eraseLastChar(const PString & vecChar) const{
        if(size() > 0lu){
                size_t nbCharToRemove(0lu);
                PString::const_reverse_iterator it(rbegin());
                while(vecChar.find(*it)){
                        ++it;
                        ++nbCharToRemove;
                }
                
                if(nbCharToRemove == 0lu){
                        return *this;
                }else{
                        PString buffer(substr(0, size() - nbCharToRemove));
                        return buffer;
                }
        }else{
                return *this;
        }
}
 
 
PString PString::eraseFirstLastChar(const PString & vecChar) const{
        PString buffer(eraseFirstChar(vecChar));
        return buffer.eraseLastChar(vecChar);
}
 
 
bool PString::isUpperCase() const{
        if(size() == 0lu){return false;}
        const PString & str = *this;
        bool isUpper(true);
        size_t i(0lu);
        while(i < str.size() && isUpper){
                isUpper = phoenix_isCharUpperCase(str[i]);
                ++i;
        }
        return isUpper;
}
 
 
bool PString::isLowerCase() const{
        if(size() == 0lu){return false;}
        const PString & str = *this;
        bool isLower(true);
        size_t i(0lu);
        while(i < str.size() && isLower){
                isLower = phoenix_isCharLowerCase(str[i]);
                ++i;
        }
        return isLower;
}
 
 
bool PString::isNumber() const{
        if(size() == 0lu){return false;}
        const PString & str = *this;
        bool isNumber(true);
        size_t i(0lu);
        while(i < str.size() && isNumber){
                isNumber = phoenix_isCharNumber(str[i]);
                ++i;
        }
        return isNumber;
}
 
 
PString PString::toLower() const{
        if(size() == 0lu){return *this;}
        const PString & str = *this;
        std::string strOut("");
        char currentChar;
        long unsigned int size(str.size());
        for(long unsigned int i(0lu); i < size; ++i){
                currentChar = str[i];
                if(phoenix_isCharUpperCase(currentChar)){
                        strOut += currentChar + (char)32;
                }else{
                        strOut += currentChar;
                }
        }
        return strOut;
}
 
 
PString PString::toLowerUnderscore() const{
        if(size() == 0lu){return *this;}
        const PString & str = *this;
        std::string strOut("");
        char currentChar;
        long unsigned int size(str.size());
        for(long unsigned int i(0lu); i < size; ++i){
                currentChar = str[i];
                if(phoenix_isCharUpperCase(currentChar)){
                        strOut += currentChar + (char)32;
                }else{
                        if(currentChar == ' '){strOut += '_';}
                        else{strOut += currentChar;}
                }
        }
        return strOut;
}
 
 
PString PString::toUpper() const{
        if(size() == 0lu){return *this;}
        const PString & str = *this;
        std::string strOut("");
        char currentChar;
        long unsigned int size(str.size());
        for(long unsigned int i(0); i < size; ++i){
                currentChar = str[i];
                if(phoenix_isCharLowerCase(currentChar)){
                        strOut += currentChar - (char)32;
                }else{
                        strOut += currentChar;
                }
        }
        return strOut;
}
 
 
PString PString::firstToLower() const{
        if(size() == 0lu){return *this;}
        const PString & str = *this;
        std::string strOut(str);
        char currentChar = strOut[0lu];
        if(phoenix_isCharUpperCase(currentChar)){
                strOut[0lu] = currentChar + (char)32;
        }
        return strOut;
}
 
 
PString PString::firstToUpper() const{
        if(size() == 0lu){return *this;}
        const PString & str = *this;
        std::string strOut(str);
        char currentChar = strOut[0lu];
        if(phoenix_isCharLowerCase(currentChar)){
                strOut[0lu] = currentChar - (char)32;
        }
        return strOut;
}
 
 
PString PString::escapeStr(const PString & strCharToEscape, const PString & escapeSeq) const{
        if(size() == 0lu || strCharToEscape.size() == 0lu || escapeSeq.size() == 0lu){return *this;}
        const PString & src = *this;
        std::string out("");
        for(size_t i(0lu); i < src.size(); ++i){
                char ch = src[i];
                if(strCharToEscape.find(ch)){
                        out += escapeSeq;
                }
                out += ch;
        }
        return out;
}
 
 
void PString::copyPString(const PString & other){
        resize(other.size());
        memcpy((char*)data(), other.data(), other.size());
}
 
 
void PString::copyPString(const std::string & other){
        resize(other.size());
        memcpy((char*)data(), other.data(), other.size());
}
 
 
void PString::concatenatePString(const PString & other){
        std::string tmp(*this);
        resize(tmp.size() + other.size());
        memcpy((char*)data(), tmp.data(), tmp.size());
        memcpy((char*)data() + tmp.size(), other.data(), other.size());
}
 
 
void PString::concatenatePString(const std::string & other){
        std::string tmp(*this);
        resize(tmp.size() + other.size());
        memcpy((char*)data(), tmp.data(), tmp.size());
        memcpy((char*)data() + tmp.size(), other.data(), other.size());
}
 
void PString::initialisationPString(){
        
}