DicoValue.cpp

Go to the documentation of this file.

/***************************************
        Auteur : Pierre Aubert
        Mail : pierre.aubert@lapp.in2p3.fr
        Licence : CeCILL-C
****************************************/
 
#include <fstream>
#include "DicoValue.h"
 
DicoValue::DicoValue(){
        
}
 
 
DicoValue::DicoValue(const DicoValue & other){
        copyDicoValue(other);
}
 
DicoValue::~DicoValue(){
        
}
 
 
DicoValue & DicoValue::operator = (const DicoValue & other){
        copyDicoValue(other);
        return *this;
}
 
 
bool DicoValue::load(const PPath & fileName){
        PFileParser parser;
        if(!parser.open(fileName)){return false;}
        return loadParser(parser);
}
 
 
bool DicoValue::save(const PPath & fileName, const PString & valueDecorator, PString baseIndentation, PString baseNewLine) const{
        PString out(toString(valueDecorator, baseIndentation, baseNewLine));
        return fileName.saveFileContent(out);
}
 
 
bool DicoValue::fromString(const PString & content){
        PFileParser parser;
        parser.setFileContent(content);
        return loadParser(parser);
}
 
 
PString DicoValue::toString(const PString & valueDecorator, PString baseIndentation, PString baseNewLine) const{
        PString out(baseNewLine+"{");
        out += saveRecurse(baseIndentation, valueDecorator, baseIndentation, baseNewLine);
        out += baseNewLine+"}"+baseNewLine;
        return out;
}
 
void DicoValue::print() const{
        std::cout << "{" << std::endl;
        std::cout << saveRecurse("\t", "\"", "\t", "\n") << std::endl;
        std::cout << "{" << std::endl;
}
 
 
bool DicoValue::hasKey() const{return p_key != "";}
 
 
bool DicoValue::hasMap() const{return p_mapChild.size() != 0lu;}
 
 
bool DicoValue::hasVec() const{return p_vecChild.size() != 0lu;}
 
 
bool DicoValue::isKeyExist(const PString & key) const{
        std::map<PString, DicoValue>::const_iterator it(p_mapChild.find(key));
        return it != p_mapChild.end();
}
 
 
const DicoValue * DicoValue::getMap(const PString & key) const{
        std::map<PString, DicoValue>::const_iterator it(p_mapChild.find(key));
        if(it != p_mapChild.end()){
                return &(it->second);
        }else{
                return NULL;
        }
}
 
 
DicoValue * DicoValue::getMap(const PString & key){
        std::map<PString, DicoValue>::const_iterator it(p_mapChild.find(key));
        if(it != p_mapChild.end()){
                return (DicoValue *)&(it->second);
        }else{
                return NULL;
        }
}
 
 
void DicoValue::setValue(const PString & value){
        p_value = value;
}
 
 
void DicoValue::setKey(const PString & key){
        p_key = key;
}
 
 
void DicoValue::setVecChild(const std::vector<DicoValue> & vecChild){
        p_vecChild = vecChild;
}
 
 
void DicoValue::setMapChild(const std::map<PString, DicoValue> & mapChild){
        p_mapChild = mapChild;
}
 
 
const PString & DicoValue::getValue() const{
        return p_value;
}
 
 
PString & DicoValue::getValue(){
        return p_value;
}
 
 
PString DicoValue::getString() const{
        return p_value.eraseFirstLastChar("\"\'");
}
 
 
const PString & DicoValue::getKey() const{
        return p_key;
}
 
 
PString & DicoValue::getKey(){
        return p_key;
}
 
 
const std::vector<DicoValue> & DicoValue::getVecChild() const{
        return p_vecChild;
}
 
 
std::vector<DicoValue> & DicoValue::getVecChild(){
        return p_vecChild;
}
 
 
const std::map<PString, DicoValue> & DicoValue::getMapChild() const{
        return p_mapChild;
}
 
 
std::map<PString, DicoValue> & DicoValue::getMapChild(){
        return p_mapChild;
}
 
 
void DicoValue::copyDicoValue(const DicoValue & other){
        p_value = other.p_value;
        p_key = other.p_key;
        p_vecChild = other.p_vecChild;
        p_mapChild = other.p_mapChild;
}
 
 
bool DicoValue::loadParser(PFileParser & parser){
        parser.setEscapeChar('\\');
        parser.setWhiteSpace(" \t\n");
        parser.setSeparator(",:{}\"");
        bool isRunning(true);
        while(!parser.isEndOfFile() && isRunning){
                if(parseDicoValue(parser, isRunning)){
                        parser.skipWhiteSpace();
                }else{
                        errorAt(parser, isRunning, "Cannot parse dico value");
                }
        }
        return isRunning;
}
 
 
bool DicoValue::parseDicoValue(PFileParser & parser, bool & isRunning){
        if(parseListOrMap(parser, isRunning)){return true;}
        else{
                PString nextKeyOrValue(parseString(parser));
                if(nextKeyOrValue == ""){
                        nextKeyOrValue = parser.getStrComposedOf("abcdefghijklmnopqsrtuvwxyzABCDEFGHIJKLMNOPQSRTUVWXYZ0123456789._-+");
                        if(nextKeyOrValue == ""){
                                return errorAt(parser, isRunning,
                                        "Expecting a string or a keywork composed of letters, number, underscore, slash or minus");
                        }
                }
                if(parser.isMatch(":")){        //It was a key for a dictionnary
//                      std::cerr << "DicoValue::parseDicoValue : find key '"<<nextKeyOrValue<<"'" << std::endl;
                        p_key = nextKeyOrValue;
                        if(!parseDicoValue(parser, isRunning)){
                                return errorAt(parser, isRunning, "Cannot parse value");
                        }
                }else{                  //It was a value
                        p_value = nextKeyOrValue;
                }
                parser.skipWhiteSpace();
        }
        return true;
}
 
 
bool DicoValue::parseListOrMap(PFileParser & parser, bool & isRunning){
        if(!parser.isMatch("{")){return false;} //If this is not a {, then it is not a list or a map
        
        while(!parser.isEndOfFile() && !parser.isMatch("}") && isRunning){
                DicoValue dv;
                if(dv.parseDicoValue(parser, isRunning)){
                        if(dv.p_key != ""){     //It is a dico entry
//                              std::cerr << "DicoValue::parseListOrMap : loadParser add DicoValue with key '"<<dv.p_key<<"'" << std::endl;
                                p_mapChild[dv.p_key] = dv;
                        }else{  //It is a value
                                p_vecChild.push_back(dv);
                        }
                }else{
                        errorAt(parser, isRunning, "Cannot parse dico value");
                }
                if(parser.isMatch(",")){}
                else if(parser.isMatchRewind("}")){}
                else{
                        return errorAt(parser, isRunning, "Expect ',' or '}' after value");
                }
        }
        
        return true;
}
 
 
PString DicoValue::parseString(PFileParser & parser){
        if(parser.isMatch("\"")){
                return parser.getUntilKeyWithoutPatern("\"");
        }else if(parser.isMatch("'")){
                return parser.getUntilKeyWithoutPatern("'");
        }
        return "";
}
 
 
bool DicoValue::errorAt(PFileParser & parser, bool & isRunning, const PString & errorMsg){
        isRunning = false;
        std::cerr << "DicoValue::errorAt : " << parser.getLocation() << std::endl;
        std::cerr << "\t" << errorMsg << std::endl;
        return true;
}
 
 
PString DicoValue::saveRecurse(const PString & indentation, const PString & valueDecorator, PString baseIndentation, PString baseNewLine) const{
        PString out(""), newIndentation(indentation);
        if(p_key != ""){
                newIndentation = indentation + baseIndentation;
        }
        if(p_mapChild.size() != 0lu){
                if(p_key != ""){out += baseNewLine + indentation +valueDecorator + p_key + valueDecorator + ": {";}
                PString comma("");
                for(MapDicoValue::const_iterator it(p_mapChild.begin()); it != p_mapChild.end(); ++it){
                        out += comma;
                        out += it->second.saveRecurse(newIndentation, valueDecorator, baseIndentation, baseNewLine);
                        comma = ",";
                }
                if(p_key != ""){out += baseNewLine+indentation+"}";}
        }else if(p_vecChild.size() != 0lu){
                if(p_key != ""){out += baseNewLine + indentation + valueDecorator + p_key + valueDecorator + ": {";}
                PString comma("");
                for(VecDicoValue::const_iterator it(p_vecChild.begin()); it != p_vecChild.end(); ++it){
                        out += comma;
                        out += it->saveRecurse(newIndentation, valueDecorator, baseIndentation, baseNewLine);
                        comma = ", ";
                }
                if(p_key != ""){out += "}";}
        }else{
                PString valueToSave(p_value);
                if(valueDecorator != ""){
                        valueToSave = valueDecorator + p_value + valueDecorator;
                }else if(p_value.find(" \t\n':/")){
                        valueToSave = "\"" + p_value + "\"";
                }
                if(p_key != ""){out += baseNewLine + indentation + valueDecorator + p_key + valueDecorator + ": "+valueToSave;}
                else{out += valueToSave;}
        }
        return out;
}