dico_replace_var.cpp

Go to the documentation of this file.

/***************************************
        Auteur : Pierre Aubert
        Mail : pierre.aubert@lapp.in2p3.fr
        Licence : CeCILL-C
****************************************/
 
#include "PFileParser.h"
#include "dico_replace_var.h"
 
typedef std::vector<std::pair<PNestedCall, DicoValue*> > PVecReplaceVar;
typedef std::map<PString, std::pair<PNestedCall, DicoValue*> > MapVarWithNestedCall;
 
 
void dico_create_nested_call(PNestedCall & call, const PString & baseStr, const PString & varBegin, const PString & varEnd){
        PFileParser parser;
        parser.setFileContent(baseStr);
        while(!parser.isEndOfFile()){
                PString prevCall(parser.getUntilKeyWithoutPatern(varBegin));
                if(prevCall != ""){
                        PNestedStr str;
                        str.setValue(prevCall);
                        str.setIsVarCall(false);
                        call.getVecNestedStr().push_back(str);
                }
                PString varNameCall(parser.getUntilKeyWithoutPatern(varEnd));
                if(varNameCall != ""){
                        PNestedStr str;
                        str.setValue(varNameCall);
                        str.setIsVarCall(true);
                        call.getVecNestedStr().push_back(str);
                }
        }
}
 
 
void dico_replace_nested_call(PString & out, const PNestedCall & call, const PMapKnownVar & mapKeyVariable, const PString & varBegin, const PString & varEnd){
        const std::vector<PNestedStr> & vecNestedStr = call.getVecNestedStr();
        for(std::vector<PNestedStr>::const_iterator it(vecNestedStr.begin()); it != vecNestedStr.end(); ++it){
                if(it->getIsVarCall()){
                        PMapKnownVar::const_iterator itCall(mapKeyVariable.find(varBegin + it->getValue() + varEnd));
                        if(itCall != mapKeyVariable.end()){
                                out += itCall->second;
                        }else{
                                out += varBegin + it->getValue() + varEnd;
                        }
                }else{
                        out += it->getValue();
                }
        }
}
 
 
PString dico_replace_var_str(const PString & baseStr, const PMapKnownVar & mapKeyVariable, const PString & varBegin, const PString & varEnd){
        if(varBegin == "" || varEnd == ""){return baseStr;}
        PNestedCall call;
        dico_create_nested_call(call, baseStr, varBegin, varEnd);
        PString out("");
        dico_replace_nested_call(out, call, mapKeyVariable, varBegin, varEnd);
        return out;
}
 
 
bool createNestedCallFromStr(PNestedCall & call, const PString & value, const PString varName, const PString & varBegin, const PString & varEnd){
        call.setName(varName);
        PFileParser parser;
        parser.setFileContent(value);
        bool hasNestedCall(false);
        while(!parser.isEndOfFile()){
                PString prevCall(parser.getUntilKeyWithoutPatern(varBegin));
                if(prevCall != ""){
                        PNestedStr str;
                        str.setValue(prevCall);
                        str.setIsVarCall(false);
                        call.getVecNestedStr().push_back(str);
                }
                PString varNameCall(parser.getUntilKeyWithoutPatern(varEnd));
                if(varNameCall != ""){
                        PNestedStr str;
                        str.setValue(varNameCall);
                        str.setIsVarCall(true);
                        call.getVecNestedStr().push_back(str);
                        hasNestedCall = true;
                }
        }
        return hasNestedCall;
}
 
 
void dico_find_all_var(PMapKnownVar & mapReadyVar, PVecReplaceVar & mapNestedVar, MapVarWithNestedCall & mapVarWithNestedCall, DicoValue & dico, const PString & varIdentifier){
        if(dico.hasMap()){
                MapDicoValue & mapDico = dico.getMapChild();
                for(MapDicoValue::iterator it(mapDico.begin()); it != mapDico.end(); ++it){
                        dico_find_all_var(mapReadyVar, mapNestedVar, mapVarWithNestedCall, it->second, varIdentifier);
                }
        }else if(dico.hasVec()){
                VecDicoValue & vecDico = dico.getVecChild();
                for(VecDicoValue::iterator it(vecDico.begin()); it != vecDico.end(); ++it){
                        dico_find_all_var(mapReadyVar, mapNestedVar, mapVarWithNestedCall, *it, varIdentifier);
                }
        }else if(dico.hasKey()){        //No map, no vector but a key, this is a string variable
                PString strValue(dico.getString()), varName(dico.getKey());
                //Let's check is the value contains nested calls
                //We will create a class to handle the split between string part and nested calls
                PNestedCall call;
                //We add the class in the proper map
                if((createNestedCallFromStr(call, strValue, varName, varIdentifier + "{", "}"))){       //There is (at least) one nested call
                        mapNestedVar.push_back(std::pair<PNestedCall, DicoValue*>(call, &dico));
                        mapVarWithNestedCall[varName] = std::pair<PNestedCall, DicoValue*>(call, &dico);
                }else{                                                          //There is no nested call
                        mapReadyVar[varName] = strValue;
                }
        }
}
 
 
 
void dico_update_all_nestedCall(PMapKnownVar & mapReadyVar, PVecReplaceVar & mapNestedVar, MapVarWithNestedCall & mapVarWithNestedCall, 
                                PNestedCall & nestedCall, DicoValue * dico, const PString & varIdentifier)
{
        //For each call, we check if it comes from the mapReadyVar, from the mapNestedVar or from nowhere
        PString outputValue("");
        std::vector<PNestedStr> & vecNestedStr = nestedCall.getVecNestedStr();
        for(std::vector<PNestedStr>::iterator it(vecNestedStr.begin()); it != vecNestedStr.end(); ++it){
                if(!it->getIsVarCall()){        //If it is not a var call, we skip it
                        outputValue += it->getValue();
                        continue;
                }
                PString varName(it->getValue());
                //If the var comes from mapNestedVar, we have to resolve this one first
                MapVarWithNestedCall::iterator itNested = mapVarWithNestedCall.find(varName);
                if(itNested != mapVarWithNestedCall.end()){
                        dico_update_all_nestedCall(mapReadyVar, mapNestedVar, mapVarWithNestedCall, itNested->second.first, itNested->second.second, varIdentifier);
                        mapVarWithNestedCall.erase(varName);    //We solve varName, so we erase it from the mapNestedVar
                        //But now, the varName entry does exist in the mapReadyVar
                }
                //If the var comes from mapReadyVar, we replace it
                PMapKnownVar::iterator itReady = mapReadyVar.find(varName);
                if(itReady != mapReadyVar.end()){
                        outputValue += itReady->second;
                }else{
                        //If we cannot find it, let's keep it unsolved (it can we a global variable)
                        outputValue += varIdentifier + "{" + varName + "}";
                }
        }
        //Finally, we can update the dico value, but we deal with the quotation
        PString firstQuote(""), prevValue(dico->getValue());
        if(prevValue.size() != 0lu){
                if(prevValue.front() == '\''){firstQuote = "'";}
                else if(prevValue.front() == '"'){firstQuote = "\"";}
        }
        dico->setValue(firstQuote + outputValue + firstQuote);
        
        //And put its value into the mapReadyVar, because we solve it
        mapReadyVar[nestedCall.getName()] = outputValue;
}
 
 
void dico_update_all_var(PMapKnownVar & mapReadyVar, PVecReplaceVar & mapNestedVar, MapVarWithNestedCall & mapVarWithNestedCall,
                        const PString & varIdentifier)
{
        //Let's try to complete the nested call
        for(PVecReplaceVar::iterator itNested(mapNestedVar.begin()); itNested != mapNestedVar.end(); ++itNested){
                PNestedCall & nestedCall = itNested->first;
                DicoValue * dico = itNested->second;
                
                dico_update_all_nestedCall(mapReadyVar, mapNestedVar, mapVarWithNestedCall, nestedCall, dico, varIdentifier);
        }
}
 
 
void dico_replace_var(DicoValue & dico, const PString & varIdentifier){
        //Let's find all the defined variables, linked to the DicoValue, string only
        PMapKnownVar mapReadyVar;
        PVecReplaceVar mapNestedVar;
        MapVarWithNestedCall mapVarWithNestedCall;
        dico_find_all_var(mapReadyVar, mapNestedVar, mapVarWithNestedCall, dico, varIdentifier);
        
        //Update variables with nested call, separate those with nested call from the other
        dico_update_all_var(mapReadyVar, mapNestedVar, mapVarWithNestedCall, varIdentifier);
}