ptimtable_load.cpp

Go to the documentation of this file.

/***************************************
        Auteur : Pierre Aubert
        Mail : pierre.aubert@lapp.in2p3.fr
        Licence : CeCILL-C
****************************************/
 
#include "platexobj_parse.h"
#include "ptimtable_load.h"
 
 
PString ptimetable_loadString(const DicoValue & dico, const PString & attributeName){
        return phoenix_load_value_from_config<PString>(dico, attributeName, "").eraseFirstLastChar("\"'\t\n ");
}
 
 
bool ptimetable_parseLatexAttribute(PLatexObj & obj, const DicoValue & value, const PString & attributeName){
        PString valueStr(ptimetable_loadString(value, attributeName));
        if(valueStr == ""){
                return false;
        }
        if(!platexobj_parseStr(obj, valueStr)){
                std::cerr << "ptimetable_parseLatexAttribute : cannot parse value of attribute '"<<attributeName<<"'" << std::endl;
                return false;
        }
        return true;
}
 
 
bool ptimetable_loadSpeaker(std::vector<PLatexSpeaker> & vecOutputSpeaker, const DicoValue & dico){
        const DicoValue * mapSpeaker = dico.getMap("speaker");
        if(mapSpeaker == NULL){return true;}    //If there is no speaker, this is not a problem
        const VecDicoValue & vecSpeaker = mapSpeaker->getVecChild();
        for(VecDicoValue::const_iterator it(vecSpeaker.begin()); it != vecSpeaker.end(); ++it){
                PLatexSpeaker speaker;
                PString name(ptimetable_loadString(*it, "name"));
                if(!ptimetable_parseLatexAttribute(speaker.getName(), *it, "name")){
                        std::cerr << "ptimetable_loadSpeaker : missing 'name'" << std::endl;
                }
                ptimetable_parseLatexAttribute(speaker.getTitle(), *it, "title");
                if(!ptimetable_parseLatexAttribute(speaker.getJob(), *it, "function")){
                        std::cerr << "ptimetable_loadSpeaker : missing 'function' in speaker '"<<name<<"'" << std::endl;
                }
                if(!ptimetable_parseLatexAttribute(speaker.getAffiliation(), *it, "affiliation")){
                        std::cerr << "ptimetable_loadSpeaker : missing 'affiliation' in speaker '"<<name<<"'" << std::endl;
                }
                if(!ptimetable_parseLatexAttribute(speaker.getDescription(), *it, "description")){
                        std::cerr << "ptimetable_loadSpeaker : missing 'description' in speaker '"<<name<<"'" << std::endl;
                }
                speaker.setLabel(ptimetable_loadString(*it, "label"));
                //TODO : find a way to bark if the label is empty
                vecOutputSpeaker.push_back(speaker);
        }
        return true;
}
 
 
PLatexDate ptimetable_parsePLatexDate(const PString & str){
        PVecString vecValue(str.split('/'));
        PLatexDate date;
        if(vecValue.size() >= 1lu){
                date.setDay(atol(vecValue[0lu].c_str()));
        }
        if(vecValue.size() >= 2lu){
                date.setMonth(atol(vecValue[1lu].c_str()));
        }
        if(vecValue.size() >= 3lu){
                date.setYear(atol(vecValue[2lu].c_str()));
        }
        return date;
}
 
 
PLatexTime ptimetable_parsePLatexTime(const PString & str){
        PVecString vecValue(str.split(':'));
        PLatexTime duration;
        if(vecValue.size() == 1lu){
                duration.setMinute(atol(vecValue[0lu].c_str()));
        }else if(vecValue.size() == 2lu){
                duration.setHour(atol(vecValue[0lu].c_str()));
                duration.setMinute(atol(vecValue[1lu].c_str()));
        }
        return duration;
}
 
 
bool ptimetable_loadBlock(PTimeTable & timetable, const DicoValue & dico){
        const DicoValue * mapBlock = dico.getMap("block");
        if(mapBlock == NULL){return true;}
        const VecDicoValue & vecBlock = mapBlock->getVecChild();
        for(VecDicoValue::const_iterator it(vecBlock.begin()); it != vecBlock.end(); ++it){
                PTimeTableBlock block;
                if(!ptimetable_parseLatexAttribute(block.getTitle(), *it, "title")){}
                if(!ptimetable_parseLatexAttribute(block.getWeekTitle(), *it, "week_title")){}
                if(!ptimetable_parseLatexAttribute(block.getDescription(), *it, "description")){}
                
                block.setVecSpeaker(eraseFirstLastChar(phoenix_load_vecValue_from_config<PString>(*it, "speakers"), "\"' \n\t"));
                block.setInvitation(ptimetable_loadString(*it, "invitation"));
                block.setStyle(ptimetable_loadString(*it, "style"));
                block.setDuration(ptimetable_parsePLatexTime(ptimetable_loadString(*it, "duration")));
                block.setQuestionTime(ptimetable_parsePLatexTime(ptimetable_loadString(*it, "question")));
                
                block.setDate(ptimetable_parsePLatexDate(ptimetable_loadString(*it, "date")));
                block.setBeginTime(ptimetable_parsePLatexTime(ptimetable_loadString(*it, "begin")));
                block.setMainUrl(ptimetable_loadString(*it, "main_url"));
                ptimetable_parseLatexAttribute(block.getLocation(), *it, "location");
                timetable.getVecBlock().push_back(block);
        }
        return true;
}
 
 
bool ptimetable_loadSpeaker(std::vector<PLatexSpeaker> & vecSpeaker, const PPath & configFile){
        DicoValue dico;
        if(!parser_toml(dico, configFile)){
                std::cerr << "ptimetable_loadSpeaker : cannot load toml file '"<<configFile<<"'" << std::endl;
                return false;
        }
        if(!ptimetable_loadSpeaker(vecSpeaker, dico)){
                std::cerr << "ptimetable_loadSpeaker : cannot load speakers from file '"<<configFile<<"'" << std::endl;
                return false;
        }
        return true;
}
 
 
bool ptimetable_load(PTimeTable & timetable, const PPath & configFile){
        DicoValue dico;
        if(!parser_toml(dico, configFile)){
                std::cerr << "ptimetable_load : cannot load toml file '"<<configFile<<"'" << std::endl;
                return false;
        }
        if(!ptimetable_loadSpeaker(timetable.getVecSpeaker(), dico)){
                std::cerr << "ptimetable_load : cannot load speakers from file '"<<configFile<<"'" << std::endl;
                return false;
        }
        
        DicoValue * dicoTimetable = dico.getMap("timetable");
        if(dicoTimetable != NULL){
                if(!ptimetable_parseLatexAttribute(timetable.getName(), *dicoTimetable, "name")){
                        std::cerr << "ptimetable_load : missing 'name' of the event" << std::endl;
                }
                if(!ptimetable_parseLatexAttribute(timetable.getLocation(), *dicoTimetable, "location")){
                        std::cerr << "ptimetable_load : missing 'location' of the event" << std::endl;
                }
                timetable.setInvitation(ptimetable_loadString(*dicoTimetable, "invitation"));
                timetable.setBeginDate(ptimetable_parsePLatexDate(ptimetable_loadString(*dicoTimetable, "begin_date")));
                timetable.setEndDate(ptimetable_parsePLatexDate(ptimetable_loadString(*dicoTimetable, "end_date")));
                timetable.setMainUrl(ptimetable_loadString(*dicoTimetable, "main_url"));
        }
        if(!ptimetable_loadBlock(timetable, dico)){
                std::cerr << "ptimetable_load : cannot load blocks from file '"<<configFile<<"'" << std::endl;
                return false;
        }
        return true;
}