PHighlightParser.cpp

Go to the documentation of this file.

/***************************************
        Auteur : Pierre Aubert
        Mail : pierre.aubert@lapp.in2p3.fr
        Licence : CeCILL-C
****************************************/
 
#include "PHighlightParser.h"

PHighlightParser::PHighlightParser(){
        initialisationPHighlightParser();
}

PHighlightParser::~PHighlightParser(){
        clear();
}


void PHighlightParser::addToken(const PVecString & vecToken, const PString & replaceBeforePattern, const PString & replaceAfterPattern){
        PHighlightingAction* action = new PHighlightingAction;
        action->type = PHighlightType::REPLACE;
        action->replaceBeforePattern = replaceBeforePattern;
        action->replaceAfterPattern = replaceAfterPattern;
        p_vecPtrAction.push_back(action);
        for(PVecString::const_iterator it(vecToken.begin()); it != vecToken.end(); ++it){
                p_replaceTree.addKeyValue(it->toVector(), action);
        }
}


void PHighlightParser::addToken(const PString & beginPattern, const PString & endPattern, const PString & replaceBeforePattern, const PString & replaceAfterPattern){
        PHighlightingAction* action = new PHighlightingAction;
        action->type = PHighlightType::GET_UNITL_WITHOUT_PATTERN;
        action->replaceBeforePattern = replaceBeforePattern;
        action->replaceAfterPattern = replaceAfterPattern;
        action->endPattern = endPattern;
        p_vecPtrAction.push_back(action);
        p_replaceTree.addKeyValue(beginPattern.toVector(), action);
}


PString PHighlightParser::makeHighlighting(const PString & content){
        if(content.size() == 0lu || p_replaceTree.getMapChild().size() == 0lu){return content;}
        PFileParser parser;
        parser.setFileContent(content);
        PReplaceHightlightTree::iterator it(p_replaceTree.begin());
        bool isPreviousMatchingString(false);
        PString out(""), pattern(""), replacePattern("");
        PHighlightingAction* action = NULL;
        size_t beginTest(0lu), nbMatch(0lu), indexLastMatchReplace(0lu);
        while(!parser.isEndOfFile()){
                char currentChar = parser.getCurrentCh();
//              std::cerr << "PString::replace : content["<<i<<"] = '"<<currentChar<<"'" << std::endl;
                if(it.next(currentChar)){       //We found a matching character
                        if(nbMatch == 0lu){             //This is the first matched character for this sequence
                                beginTest = parser.getCurrentCharIdx();                        //So we remember the begining position
                        }
                        pattern += currentChar;
                        ++nbMatch;                              //Let's remember how much characters were OK
                        if(it->hasValue()){             //If the current node tree has a value
                                action = it->getValue();
                                replacePattern = pattern;               //We have to remember the current pattern because it will change if we have other partial matches
                                isPreviousMatchingString = true;        //And we say that we have a value
                                indexLastMatchReplace = parser.getCurrentCharIdx();
                        }
                        parser.incrementCurrentChar();
                }else{
                        if(nbMatch == 0lu){
                                it = p_replaceTree.begin();        //Let's check again from the begining of the tree
                                isPreviousMatchingString = false;
                                pattern = "";
                                out += currentChar;
                                parser.incrementCurrentChar();
                        }else{
                                if(isPreviousMatchingString){   //If we had something to replace
                                        doReplaceAction(out, parser, action, replacePattern, indexLastMatchReplace);     //Let's replace it
                                }else{
                                        out += parser.getChar(beginTest);                //no sequence matches
                                        parser.setCurrentCharIdx(beginTest);                   //so we start again one character later (we will have the ++i of the for loop for that)
                                        parser.incrementCurrentChar();
                                }
                                isPreviousMatchingString = false;
                                pattern = "";
                                action = NULL;
                                nbMatch = 0lu;
                                it = p_replaceTree.begin();        //Let's check again from the begining of the tree
                        }
                }
        }
        if(isPreviousMatchingString){   //If we had something to replace
                doReplaceAction(out, parser, action, replacePattern, indexLastMatchReplace);             //Let's replace it
        }else if(nbMatch != 0lu){
                for(size_t i(beginTest); i < parser.getNbTotalChar(); ++i){
                        out += parser.getChar(i);
                        
                }
        }
        //We are potentially at the end of the source, so no more test
        return out;
}

void PHighlightParser::clear(){
        for(std::vector<PHighlightingAction*>::iterator it(p_vecPtrAction.begin()); it != p_vecPtrAction.end(); ++it){
                delete *it;
        }
}

void PHighlightParser::initialisationPHighlightParser(){
        
}


void PHighlightParser::doReplaceAction(PString & out, PFileParser & parser, PHighlightingAction* action, const PString & replacePattern, size_t indexLastMatchReplace){
        if(action == NULL){return;}
        if(action->type == PHighlightType::REPLACE){
                out += action->replaceBeforePattern + replacePattern + action->replaceAfterPattern;      //Let's replace it
                parser.setCurrentCharIdx(indexLastMatchReplace);
                parser.incrementCurrentChar();
        }else if(action->type == PHighlightType::GET_UNITL_WITHOUT_PATTERN){
                out += action->replaceBeforePattern + replacePattern + parser.getUntilKeyWithoutPatern(action->endPattern) + action->endPattern + action->replaceAfterPattern;       //Let's replace it
        }
}