dico_replace_var.cpp File Reference

#include "PFileParser.h"
#include "dico_replace_var.h"

Include dependency graph for dico_replace_var.cpp:

Go to the source code of this file.

Typedefs
typedef std::map< PString, std::pair< PNestedCall, DicoValue * > >	MapVarWithNestedCall
	Map of the variables which uses nested call.
typedef std::vector< std::pair< PNestedCall, DicoValue * > >	PVecReplaceVar
	Map used to replace variable value in nested calls (VariableName, PNestedCall)

Functions
bool	createNestedCallFromStr (PNestedCall &call, const PString &value, const PString varName, const PString &varBegin, const PString &varEnd)
	Create the PNestedCall from the given value.
void	dico_create_nested_call (PNestedCall &call, const PString &baseStr, const PString &varBegin, const PString &varEnd)
	Create the nested calls of the input base string.
void	dico_find_all_var (PMapKnownVar &mapReadyVar, PVecReplaceVar &mapNestedVar, MapVarWithNestedCall &mapVarWithNestedCall, DicoValue &dico, const PString &varIdentifier)
	Get the variable which contains only a value and those with nested calls.
void	dico_replace_nested_call (PString &out, const PNestedCall &call, const PMapKnownVar &mapKeyVariable, const PString &varBegin, const PString &varEnd)
	Replace the nested call by the variables in map.
void	dico_replace_var (DicoValue &dico, const PString &varIdentifier)
	Replace all the variables which are string in the given DicoValue, when ${variable} apprears in the value.
PString	dico_replace_var_str (const PString &baseStr, const PMapKnownVar &mapKeyVariable, const PString &varBegin, const PString &varEnd)
	Update the suffix of the file.
void	dico_update_all_nestedCall (PMapKnownVar &mapReadyVar, PVecReplaceVar &mapNestedVar, MapVarWithNestedCall &mapVarWithNestedCall, PNestedCall &nestedCall, DicoValue *dico, const PString &varIdentifier)
	Update variables with nested calls.
void	dico_update_all_var (PMapKnownVar &mapReadyVar, PVecReplaceVar &mapNestedVar, MapVarWithNestedCall &mapVarWithNestedCall, const PString &varIdentifier)
	Update the variable which contains nested calls.

Typedef Documentation

MapVarWithNestedCall

typedef std::map<PString, std::pair<PNestedCall, DicoValue*> > MapVarWithNestedCall

Map of the variables which uses nested call.

Definition at line 13 of file dico_replace_var.cpp.

PVecReplaceVar

typedef std::vector<std::pair<PNestedCall, DicoValue*> > PVecReplaceVar

Map used to replace variable value in nested calls (VariableName, PNestedCall)

Definition at line 11 of file dico_replace_var.cpp.

Function Documentation

createNestedCallFromStr()

bool createNestedCallFromStr	(	PNestedCall &	call,
		const PString &	value,
		const PString	varName,
		const PString &	varBegin,
		const PString &	varEnd )

Create the PNestedCall from the given value.

Parameters

[out]	call	: PNestedCall
	value	: value to be used
	varName	: name of the variable to be defined
	varBegin	: characters which announce the begining of a variable (example ${)
	varEnd	: characters which announce the ending of a variable (example })

Returns

true if the value contains a nested call, false otherwise

Definition at line 89 of file dico_replace_var.cpp.

                                                                                                                                                {
        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;
}

References PFileParser::getUntilKeyWithoutPatern(), PNestedCall::getVecNestedStr(), PFileParser::isEndOfFile(), PFileParser::setFileContent(), PNestedStr::setIsVarCall(), PNestedCall::setName(), and PNestedStr::setValue().

Referenced by dico_find_all_var().

Here is the call graph for this function:

Here is the caller graph for this function:

dico_create_nested_call()

void dico_create_nested_call	(	PNestedCall &	call,
		const PString &	baseStr,
		const PString &	varBegin,
		const PString &	varEnd )

Create the nested calls of the input base string.

Parameters

[out]	call	: PNestedCall to be created
	baseStr	: basic suffix to be used
	varBegin	: characters which announce the begining of a variable (example ${)
	varEnd	: characters which announce the ending of a variable (example })

Definition at line 21 of file dico_replace_var.cpp.

                                                                                                                           {
        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);
                }
        }
}

References PFileParser::getUntilKeyWithoutPatern(), PNestedCall::getVecNestedStr(), PFileParser::isEndOfFile(), PFileParser::setFileContent(), PNestedStr::setIsVarCall(), and PNestedStr::setValue().

Referenced by dico_replace_var_str().

Here is the call graph for this function:

Here is the caller graph for this function:

dico_find_all_var()

void dico_find_all_var	(	PMapKnownVar &	mapReadyVar,
		PVecReplaceVar &	mapNestedVar,
		MapVarWithNestedCall &	mapVarWithNestedCall,
		DicoValue &	dico,
		const PString &	varIdentifier )

Get the variable which contains only a value and those with nested calls.

Parameters

[out]	mapReadyVar	: map of variables with values only
[out]	mapNestedVar	: map of variables with nested calls
[out]	mapVarWithNestedCall	: map of the variables which use nested calls
	varIdentifier	: String used to detect the variable names (example: '$' for ${varName}, § for §{varName})
	dico	: DicoValue to be used

Definition at line 121 of file dico_replace_var.cpp.

                                                                                                                                                                               {
        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;
                }
        }
}

References createNestedCallFromStr(), dico_find_all_var(), DicoValue::getKey(), DicoValue::getMapChild(), DicoValue::getString(), DicoValue::getVecChild(), DicoValue::hasKey(), DicoValue::hasMap(), and DicoValue::hasVec().

Referenced by dico_find_all_var(), and dico_replace_var().

Here is the call graph for this function:

Here is the caller graph for this function:

dico_replace_nested_call()

void dico_replace_nested_call	(	PString &	out,
		const PNestedCall &	call,
		const PMapKnownVar &	mapKeyVariable,
		const PString &	varBegin,
		const PString &	varEnd )

Replace the nested call by the variables in map.

Parameters

[out]	out	: output string with replaced variables
	call	: nested call to create the output string
	mapKeyVariable	: map of all defined variabled to be used
	varBegin	: characters which announce the begining of a variable (example ${) (in case variable is not found)
	varEnd	: characters which announce the ending of a variable (example }) (in case variable is not found)

Definition at line 49 of file dico_replace_var.cpp.

                                                                                                                                                             {
        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();
                }
        }
}

References PNestedCall::getVecNestedStr().

Referenced by dico_replace_var_str().

Here is the call graph for this function:

Here is the caller graph for this function:

dico_replace_var()

void dico_replace_var	(	DicoValue &	dico,
		const PString &	varIdentifier )

Replace all the variables which are string in the given DicoValue, when ${variable} apprears in the value.

Parameters

dico	: DicoValue to be updated
varIdentifier	: String used to detect the variable names (example: '$' for ${varName}, § for §{varName})

Definition at line 218 of file dico_replace_var.cpp.

                                                                      {
        //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);
}

References dico_find_all_var(), and dico_update_all_var().

Here is the call graph for this function:

dico_replace_var_str()

PString dico_replace_var_str	(	const PString &	baseStr,
		const PMapKnownVar &	mapKeyVariable,
		const PString &	varBegin,
		const PString &	varEnd )

Update the suffix of the file.

Parameters

baseStr	: basic suffix to be used
mapKeyVariable	: map of all defined variabled to be used
varBegin	: characters which announce the begining of a variable (example ${)
varEnd	: characters which announce the ending of a variable (example })

Returns

updated string

Definition at line 72 of file dico_replace_var.cpp.

                                                                                                                                            {
        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;
}

References dico_create_nested_call(), and dico_replace_nested_call().

Here is the call graph for this function:

dico_update_all_nestedCall()

void dico_update_all_nestedCall	(	PMapKnownVar &	mapReadyVar,
		PVecReplaceVar &	mapNestedVar,
		MapVarWithNestedCall &	mapVarWithNestedCall,
		PNestedCall &	nestedCall,
		DicoValue *	dico,
		const PString &	varIdentifier )

Update variables with nested calls.

Parameters

[out]	mapReadyVar	: map of variables with values only
[out]	mapNestedVar	: map of variables with nested calls
	nestedCall	: nested call which is the split value of the dico
	mapVarWithNestedCall	: map of the variables which use nested calls
	dico	: DicoValue to be used
	varIdentifier	: String used to detect the variable names (example: '$' for ${varName}, § for §{varName})

Definition at line 156 of file dico_replace_var.cpp.

{
        //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;
}

References dico_update_all_nestedCall(), PNestedCall::getName(), DicoValue::getValue(), PNestedCall::getVecNestedStr(), and DicoValue::setValue().

Referenced by dico_update_all_nestedCall(), and dico_update_all_var().

Here is the call graph for this function:

Here is the caller graph for this function:

dico_update_all_var()

void dico_update_all_var	(	PMapKnownVar &	mapReadyVar,
		PVecReplaceVar &	mapNestedVar,
		MapVarWithNestedCall &	mapVarWithNestedCall,
		const PString &	varIdentifier )

Update the variable which contains nested calls.

Parameters

[out]	mapReadyVar	: map of variables with values only
[out]	mapNestedVar	: map of variables with nested calls
	mapVarWithNestedCall	: map of variable with nested call
	varIdentifier	: String used to detect the variable names (example: '$' for ${varName}, § for §{varName})

Definition at line 202 of file dico_replace_var.cpp.

{
        //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);
        }
}

References dico_update_all_nestedCall().

Referenced by dico_replace_var().

Here is the call graph for this function:

Here is the caller graph for this function: