OptionMode.cpp

Go to the documentation of this file.

/***************************************
        Auteur : Pierre Aubert
        Mail : pierre.aubert@lapp.in2p3.fr
        Licence : CeCILL-C
****************************************/
 
#include "string_utils.h"
#include "OptionMode.h"
 
using namespace std;
 
 
OptionMode::OptionMode(const std::string & name)
        :p_name(name)
{
        initialisationOptionMode();
}
 
 
OptionMode::OptionMode(const OptionMode & other){
        copyOptionMode(other);
}
 
OptionMode::~OptionMode(){
        
}
 
 
OptionMode & OptionMode::operator = (const OptionMode & other){
        copyOptionMode(other);
        return *this;
}
 
 
bool OptionMode::parseOption(ArgParser & parser){
        if(parser.isEndOfOption()){return true;}
        
        p_isParsed = true;
        p_isCurrentlyParsed = true;
        bool isSearch(true);
        VecOption::iterator it(p_vecOption.begin());
        while(isSearch && it != p_vecOption.end() && !parser.isEndOfOption()){
                if(p_enableHelpOption){
                        if(parser.getCurrentOption() == "--help" || parser.getCurrentOption() == "-h"){
                                print();
                                exit(0);
                        }
                }
                if(p_programVersion != ""){
                        if(parser.getCurrentOption() == "--version" || parser.getCurrentOption() == "-v"){
                                std::cout << "Program version : " << p_programVersion << std::endl;
                                exit(0);
                        }
                }
                isSearch = !it->parseOption(parser);
                ++it;
        }
        p_isParsed |= !isSearch;
        return !isSearch;
}
 
 
bool OptionMode::parseOption(ArgParser & parser, Option *& partialOption){
        if(parser.isEndOfOption()){return true;}
        if(p_name != ""){       //If the mode has no name, it is the default mode
                if(p_name != parser.getCurrentOption()){return false;}
                p_isParsed = true;
                parser.getNextOption();
        }
        p_isCurrentlyParsed = true;
        partialOption = NULL;
        bool isSearch(true);
        VecOption::iterator it(p_vecOption.begin());
        while(isSearch && it != p_vecOption.end() && !parser.isEndOfOption()){
                try{
                        isSearch = !it->parseOption(parser);
                }catch(const std::runtime_error & e){
                        partialOption = &(*it);
                        isSearch = false;
                }
                ++it;
        }
        p_isParsed |= !isSearch;
        return !isSearch;
}
 
void OptionMode::print() const{
        std::string indentation("\t");
        if(p_name != ""){
                cout << "\tMode '" << p_name << "' :" << endl;
                indentation += "\t";
        }
        for(VecOption::const_iterator it(p_vecOption.begin()); it != p_vecOption.end(); ++it){
                it->print(indentation);
        }
}
 
 
void OptionMode::setName(const std::string & name){p_name = name;}
 
 
void OptionMode::setVecOption(const VecOption & vecOption){p_vecOption = vecOption;}
 
 
void OptionMode::addOption(const Option & option){p_vecOption.push_back(option);}
 
void OptionMode::clearOption(){p_vecOption.clear();}
 
 
void OptionMode::setEnableHelpOption(bool b){p_enableHelpOption = b;}
 
 
void OptionMode::setProgramVersion(const std::string & programVersion){p_programVersion = programVersion;}
 
 
const std::string & OptionMode::getName() const{return p_name;}
 
 
std::string & OptionMode::getName(){return p_name;}
 
 
const VecOption & OptionMode::getVecOption() const{return p_vecOption;}
 
 
VecOption & OptionMode::getVecOption(){return p_vecOption;}
 
 
bool OptionMode::checkArgument() const{
        if(!p_isParsed){return true;}
        bool isArgOk(true);
        VecOption::const_iterator it(p_vecOption.begin());
        while(it != p_vecOption.end() && isArgOk){
                isArgOk = it->checkArgument();
                ++it;
        }
        return isArgOk;
}
 
 
bool OptionMode::isCurrentlyParsed() const{
        return p_isCurrentlyParsed;
}
 
 
bool OptionMode::isParsed() const{
        return p_isParsed;
}
 
 
bool OptionMode::isOptionExist(const std::string & optionName) const{
        VecOption::const_iterator it(p_vecOption.begin());
        while(it != p_vecOption.end()){
                if(it->getLongName() == optionName || it->getShortName() == optionName){
                        return it->isParsed();
                }
                ++it;
        }
        return false;
}
 
 
void OptionMode::getPossibleOption(std::string & possibleOption, const std::string & cursorOption) const{
        if(p_name != ""){
                if(!p_isCurrentlyParsed){
                        if(isSameBegining(p_name, cursorOption)){
                                possibleOption += p_name + " ";
                        }
                }
        }
        iterGetPossibleOption(possibleOption, cursorOption);
}
 
 
void OptionMode::getPossibleMode(std::string & possibleOption, const std::string & cursorOption) const{
        if(p_name != ""){
                if(isSameBegining(p_name, cursorOption)){
                        possibleOption += p_name + " ";
                }
        }
}
 
 
void OptionMode::copyOptionMode(const OptionMode & other){
        p_name = other.p_name;
        p_vecOption = other.p_vecOption;
        p_isCurrentlyParsed = other.p_isCurrentlyParsed;
        p_isParsed = other.p_isParsed;
        p_enableHelpOption = other.p_enableHelpOption;
        p_programVersion = other.p_programVersion;
}
 
void OptionMode::initialisationOptionMode(){
        p_isCurrentlyParsed = false;
        p_isParsed = false;
        p_enableHelpOption = false;
}
 
 
bool OptionMode::getOption(Option & option, const std::string & optionName) const{
        VecOption::const_iterator it(p_vecOption.begin());
        while(it != p_vecOption.end()){
                if(it->getLongName() == optionName || it->getShortName() == optionName){
                        option = *it;
                        return true;
                }
                ++it;
        }
        return false;
}
 
 
void OptionMode::iterGetPossibleOption(std::string & possibleOption, const std::string & cursorOption) const{
        for(VecOption::const_iterator it(p_vecOption.begin()); it != p_vecOption.end(); ++it){
                it->getPossibleOption(possibleOption, cursorOption);
        }
}