vec_value_utils.cpp

Go to the documentation of this file.

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


VecValue * getLastVecValue(VecValue & vecVal, size_t depth){
        VecVecValue & vecChildren = vecVal.getVecChild();
        if(vecChildren.size() == 0lu || depth == 0lu){return &vecVal;}
        else{return getLastVecValue(vecChildren.back(), depth - 1lu);}
}


VecValue * getParentVecValue(VecValue & vecAllVal, const std::vector<size_t> & vecIndentation, size_t currentIndentation){
        if(vecIndentation.size() == 0lu){
                return getLastVecValue(vecAllVal);
        }
        size_t depth(0lu);
        std::vector<size_t>::const_iterator it(vecIndentation.begin());
        bool isCurrentLower(true);
        while(isCurrentLower && it != vecIndentation.end()){
                isCurrentLower = *it < currentIndentation;
                if(isCurrentLower){
                        ++depth;
                }
                ++it;
        }
        VecValue * out = getLastVecValue(vecAllVal, depth);
        return out;
}


void getVecParentPtr(std::vector<VecValue*> & vecParentPtr, VecValue & vecAllVal){
        vecParentPtr.push_back(&vecAllVal);
        if(vecAllVal.getVecChild().size() != 0lu){
                getVecParentPtr(vecParentPtr, vecAllVal.getVecChild().back());
        }
}


std::vector<VecValue*> getVecParentPtr(VecValue & vecAllVal){
        std::vector<VecValue*> vecParentPtr;
        getVecParentPtr(vecParentPtr, vecAllVal);
        return vecParentPtr;
}


VecValue * getParentVecValueListItem(VecValue & vecAllVal, const std::vector<size_t> & vecIndentation, size_t currentIndentation, const VecValue & child){
        if(vecIndentation.size() == 0lu){
                return getLastVecValue(vecAllVal);
        }
        size_t childIndentation(child.getIndentation());
        VecValue * out = NULL;
        std::vector<VecValue*> vecParentPtr = getVecParentPtr(vecAllVal);
        std::vector<VecValue*>::const_reverse_iterator itParent(vecParentPtr.rbegin());
        bool isCurrentGreater(true);
        while(isCurrentGreater && itParent != vecParentPtr.rend()){
                if((*itParent)->getType() == VecValueType::KEY && child.getType() == VecValueType::LIST_ITEM){
                        isCurrentGreater = (*itParent)->getIndentation() > childIndentation;
//                      if(!isCurrentGreater){
//                              std::cout << "getParentVecValueListItem : Parent("<<(*itParent)->getKey()<<").getType() : " << (*itParent)->getType() << ", ParentIndentation = "<<(*itParent)->getIndentation()<<", child.getType() = " << child.getType() << ", key = '"<<child.getKey()<<"', value = '"<<child.getValue()<<"', childIndentation = "<<childIndentation << std::endl;
//                      }
                }else{
                        if((*itParent)->getType() != VecValueType::LIST_ITEM && (*itParent)->getType() != VecValueType::VALUE &&
                                child.getType() == VecValueType::LIST_ITEM)
                        {
                                isCurrentGreater = (*itParent)->getIndentation() >= childIndentation;
                        }
                }
                //If we check with a > instead a >=, we have to check if the parent of a LIST_ITEM is a KEY
                out = *itParent;
                ++itParent;
        }
        return out;
}


VecValue * addChildToParentVecValue(VecValue & mainVecValue, const std::vector<size_t> & vecIndentation, bool isCompactMode, const VecValue & child, size_t currentIndentation){
        VecValue * parent = NULL;
        if(isCompactMode){
                parent = &mainVecValue;
        }else{
                if(currentIndentation != -1lu){
                        parent = getParentVecValue(mainVecValue, vecIndentation, currentIndentation);
                }else{
                        parent = getLastVecValue(mainVecValue);
                }
        }
        parent->getVecChild().push_back(child);
        return &(parent->getVecChild().back());
}


VecValue * addChildToParentVecValueAddListItem(VecValue & mainVecValue, const std::vector<size_t> & vecIndentation, bool isCompactMode, const VecValue & child, size_t currentIndentation){
        VecValue * parent = NULL;
        if(isCompactMode){
                parent = &mainVecValue;
        }else{
                if(currentIndentation != -1lu){
                        parent = getParentVecValueListItem(mainVecValue, vecIndentation, currentIndentation, child);
                }else{
                        parent = getLastVecValue(mainVecValue);
                }
        }
        parent->getVecChild().push_back(child);
        return &(parent->getVecChild().back());
}


void vecValueToDicoValue(DicoValue & dicoValue, const VecValue & vecVal, bool isMainValue){
        PString key(vecVal.getKey());
        const VecVecValue & vecChildren = vecVal.getVecChild();
        if(vecChildren.size() == 0lu){
                PString value(vecVal.getValue());
                if(key == ""){          //The vecVal is a value only
                        DicoValue subDico;
                        subDico.setValue(value);
                        dicoValue.getVecChild().push_back(subDico);
                }else{                  //The vecVal is a key-value
                        DicoValue subDico;
                        subDico.setKey(key);
                        subDico.setValue(value);
                        dicoValue.getMapChild()[key] = subDico;
                }
        }else{
                if(key != ""){
                        DicoValue subDico;
                        subDico.setKey(vecVal.getKey());
                        for(VecVecValue::const_iterator it(vecChildren.begin()); it != vecChildren.end(); ++it){
                                vecValueToDicoValue(subDico, *it, false);
                        }
                        dicoValue.getMapChild()[key] = subDico;
                }else{
                        if(isMainValue){
                                for(VecVecValue::const_iterator it(vecChildren.begin()); it != vecChildren.end(); ++it){
                                        vecValueToDicoValue(dicoValue, *it, false);
                                }
                        }else{
                                DicoValue dashValue;
                                for(VecVecValue::const_iterator it(vecChildren.begin()); it != vecChildren.end(); ++it){
                                        vecValueToDicoValue(dashValue, *it, false);
                                }
                                dicoValue.getVecChild().push_back(dashValue);
                        }
                }
        }
}