Option.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 "Option.h"
 
 
Option::Option(const std::string & longName, const std::string & shortName, const std::string & docString)
        :p_longName(longName), p_shortName(shortName), p_value(""), p_isRequired(false), p_docString(docString)
{
        initialisationOption();
}
 
 
Option::Option(const std::string & longName, const std::string & shortName, const OptionValue & value, const std::string & docString)
        :p_longName(longName), p_shortName(shortName), p_value(value), p_isRequired(false), p_docString(docString)
{
        initialisationOption();
}
 
 
Option::Option(const std::string & longName, const std::string & shortName, const OptionValue & value, bool isRequired, const std::string & docString)
        :p_longName(longName), p_shortName(shortName), p_value(value), p_isRequired(isRequired), p_docString(docString)
{
        initialisationOption();
}
 
 
Option::Option(const std::string & longName, const std::string & shortName, bool isRequired, const std::string & docString)
        :p_longName(longName), p_shortName(shortName), p_isRequired(isRequired), p_docString(docString)
{
        initialisationOption();
}
 
 
Option::Option(const Option & other){
        copyOption(other);
}
 
Option::~Option(){
        
}
 
 
Option & Option::operator = (const Option & other){
        copyOption(other);
        return *this;
}
 
 
bool Option::parseOption(ArgParser & parser){
        if(parsePartOption(parser, "--", p_longName)){return true;}
        else if(parsePartOption(parser, "-", p_shortName)){return true;}
        return false;
}
 
 
void printVecString(const VecValue & vecValue){
        if(vecValue.size() == 0lu){return;}
        VecValue::const_iterator it(vecValue.begin());
        std::cout << *it;
        ++it;
        while(it != vecValue.end()){
                std::cout << ", " << *it;
                ++it;
        }
}
 
 
void Option::print(const std::string & indentation) const{
        OptionType::OptionType type(p_value.getType());
        std::cout << indentation;
        if(p_longName != ""){
                std::cout << "--" << p_longName;
                if(type != OptionType::NONE){
                        std::cout << "=" << convertOptionTypeToString(type);
                }
        }
        if(p_shortName != ""){
                if(p_longName != ""){std::cout << " , ";}
                std::cout << "-" << p_shortName;
                if(type != OptionType::NONE){
                        std::cout << " " << convertOptionTypeToString(type);
                }
        }
        if(p_docString != ""){
                std::cout << " : " << p_docString;
        }
        std::cout << std::endl;
        const VecValue & vecDefaultValue = p_value.getDefaultValue();
        if(vecDefaultValue.size()){
                std::cout << indentation << "\tDefault value : '";
                printVecString(vecDefaultValue);
                std::cout << "'" << std::endl;
        }
        const VecValue & vecPossibleValue = p_value.getPossibleValue();
        if(vecPossibleValue.size()){
                std::cout << indentation << "\tPossible values : ";
                printVecString(vecPossibleValue);
                std::cout << std::endl;
        }
        if(p_isRequired){std::cout << indentation << "\tThis argument has to be set" << std::endl;}
        else{std::cout << indentation << "\tThis argument is optional" << std::endl;}
        if(p_isAllowEmpty){std::cout << indentation << "\tThis argument can have an empty value" << std::endl;}
        else{std::cout << indentation << "\tThis argument cannot have an empty value" << std::endl;}
}
 
 
void Option::setLongName(const std::string & longName){p_longName = longName;}
 
 
void Option::setShortName(const std::string & shortName){p_shortName = shortName;}
 
 
void Option::setValue(const OptionValue & value){p_value = value;}
 
 
void Option::setIsRequired(bool isRequired){p_isRequired = isRequired;}
 
 
void Option::setDocString(const std::string & docString){p_docString = docString;}
 
 
void Option::setIsParsed(bool isParsed){p_isParsed = isParsed;}
 
 
void Option::setIsAllowEmpty(bool isAllowEmpty){p_isAllowEmpty = isAllowEmpty;}
 
 
const std::string & Option::getLongName() const{return p_longName;}
 
 
std::string & Option::getLongName(){return p_longName;}
 
 
const std::string & Option::getShortName() const{return p_shortName;}
 
 
std::string & Option::getShortName(){return p_shortName;}
 
 
const OptionValue & Option::getValue() const{return p_value;}
 
 
OptionValue & Option::getValue(){return p_value;}
 
 
bool Option::isRequired() const{return p_isRequired;}
 
 
bool & Option::isRequired(){return p_isRequired;}
 
 
bool Option::isAllowEmpty() const{return p_isAllowEmpty;}
 
 
bool & Option::isAllowEmpty(){return p_isAllowEmpty;}
 
 
const std::string & Option::getDocString() const{return p_docString;}
 
 
std::string & Option::getDocString(){return p_docString;}
 
 
bool Option::isParsed() const{return p_isParsed;}
 
 
bool & Option::isParsed(){return p_isParsed;}
 
 
bool Option::checkArgument() const{
        if(p_isRequired){
                if(!p_isParsed){
                        OptionType::OptionType type(p_value.getType());
                        std::cerr << termRed() << "Missing arguement ";
                        if(p_longName != ""){
                                std::cerr << "--" << p_longName;
                                if(type != OptionType::NONE){
                                        std::cout << "=" << convertOptionTypeToString(type);
                                }
                        }
                        if(p_shortName != ""){
                                if(p_longName != ""){std::cerr << " , ";}
                                std::cerr << "-" << p_shortName;
                                if(type != OptionType::NONE){
                                        std::cout << " " << convertOptionTypeToString(type);
                                }
                        }
                        std::cerr << termDefault() << std::endl;
                }
                return p_isParsed;
        }else{return true;}
}
 
 
void Option::getPossibleOption(std::string & possibleOption, const std::string & cursorOption) const{
        if(p_isParsed){return;}
        if(p_longName != ""){
                std::string longOption("--" + p_longName);
                if(cursorOption == ""){
                        possibleOption += longOption + " ";
                }else{
                        if(isSameBegining(longOption, cursorOption)){
                                possibleOption += longOption + " ";
                        }
                }
        }
        if(p_shortName != ""){
                std::string shortOption("-" + p_shortName);
                if(cursorOption == ""){
                        possibleOption += shortOption + " ";
                }else{
                        if(isSameBegining(shortOption, cursorOption)){
                                possibleOption += shortOption + " ";
                        }
                }
        }
}
 
 
void Option::getPossibleValue(std::string & possibleValue, const std::string & cursorOption) const{
        p_value.bashCompletionValue(possibleValue, cursorOption);
}
 
 
void Option::copyOption(const Option & other){
        p_longName = other.p_longName;
        p_shortName = other.p_shortName;
        p_value = other.p_value;
        p_isRequired = other.p_isRequired;
        p_docString = other.p_docString;
        p_isParsed = other.p_isParsed;
        p_firstPartParsedOption = other.p_firstPartParsedOption;
        p_isAllowEmpty = other.p_isAllowEmpty;
}
 
void Option::initialisationOption(){
        p_isParsed = false;
        p_isRequired = false;
        p_firstPartParsedOption = "";
        p_isAllowEmpty = false;
}
 
 
bool Option::parsePartOption(ArgParser & parser, const std::string & prefix, const std::string & optionName){
        if(parser.isEndOfOption()){return true;}
        if(optionName == ""){return false;}
        std::string & currentOption = parser.getCurrentOption();
        std::string longOption(prefix + optionName);
        size_t sizeLongOption(longOption.size());
        OptionType::OptionType optionType = p_value.getType();
        if(currentOption == longOption){
                checkAlreadyParsed(longOption);
                p_isParsed = true;
                if(optionType == OptionType::NONE){     //No value expected
                        parser.getNextOption();
                        return true;                            //Option found
                }
                bool valueOk(true), isInitialised(false);
                parser.getNextOption();
                while(!parser.isEndOfOption() && valueOk){
                        std::string & currentOption = parser.getCurrentOption();
                        if(currentOption == ""){
                                if(optionType == OptionType::STRING){
                                        p_value.addValue("");
                                        parser.getNextOption();
                                        valueOk = true;
                                        isInitialised = true;
                                }else{
                                        throw std::runtime_error("Option::parsePartOption : pass empty value to option '" + longOption + "' which does not expect STRING");
                                }
                        }else{
                                if(currentOption[0] == '-'){
                                        valueOk = false;
                                }else{
                                        p_value.addValue(currentOption);
                                        parser.getNextOption();
                                        valueOk = true;
                                        isInitialised = true;
                                }
                        }
                }
                if(!isInitialised && !p_isAllowEmpty){
                        throw std::runtime_error("Option::parsePartOption : expect value after option '" + longOption + "'");
                }
                return isInitialised || p_isAllowEmpty;
        }else if(isSameBegining(currentOption, longOption)){
                if(currentOption[sizeLongOption] == '='){
                        if(optionType == OptionType::NONE){     //No value expected
                                throw std::runtime_error("Option::parsePartOption : the option '"+currentOption+"' does not have value");
                        }
                        if(currentOption.size() == sizeLongOption + 1lu){
                                p_firstPartParsedOption = longOption + "=";
                                throw std::runtime_error("Option::parsePartOption : problem with the option '"+currentOption+"' because it ends with a '=' and not a value");
                                //Ici il faut un mode qui renvoie quand même les valeurs possibles quand on a --option=...
                        }
                        checkAlreadyParsed(longOption);
                        std::string value(currentOption.substr(sizeLongOption + 1lu));
                        p_value.addValue(value);
                        p_isParsed = true;
                        parser.getNextOption();
                        return true;
                }else{
                        return false;   //It is an option with a longer name
                }
        }
        return false;
}
 
 
void Option::checkAlreadyParsed(const std::string & longOption){
        if(p_isParsed){                                                 //The option has already been parsed, there is a mistake
                throw std::runtime_error("Option::checkAlreadyParsed : option '" + longOption + "' already exists");
        }
}