OptionParser.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 "OptionParser.h"
 
using namespace std;
 
 
OptionParser::OptionParser(bool enableHelpOption, const std::string & programVersion)
        :p_enableHelpOption(enableHelpOption), p_programVersion(programVersion)
{
        initialisationOptionParser();
}
 
 
OptionParser::OptionParser(const OptionParser & other){
        copyOptionParser(other);
}
 
OptionParser::~OptionParser(){
        
}
 
 
OptionParser & OptionParser::operator = (const OptionParser & other){
        copyOptionParser(other);
        return *this;
}
 
 
void OptionParser::setExampleLongOption(const std::string & example){p_exempleLongOption = example;}
 
 
void OptionParser::setExampleShortOption(const std::string & example){p_exempleShortOption = example;}
 
 
void OptionParser::addMode(const std::string & modeName){
        OptionMode mode(modeName);
        mode.setEnableHelpOption(p_enableHelpOption);
        mode.setProgramVersion(p_programVersion);
        p_vecMode.push_back(mode);
        p_currentMode = p_vecMode.size() - 1lu;
}
 
void OptionParser::closeMode(){
        p_currentMode = 0lu;
}
 
 
void OptionParser::addOption(const std::string & longOption, const std::string & shortOption, OptionType::OptionType optionType,
                                bool isRequired, const std::string & docString)
{
        OptionValue value;
        value.setType(optionType);
        Option option(longOption, shortOption, value, isRequired, docString);
        option.setIsAllowEmpty(false);
        p_vecMode[p_currentMode].addOption(option);
}
 
 
void OptionParser::addOption(const std::string & longOption, const std::string & shortOption, OptionType::OptionType optionType,
                                bool isRequired, bool isAllowEmpty, const std::string & docString)
{
        OptionValue value;
        value.setType(optionType);
        Option option(longOption, shortOption, value, isRequired, docString);
        option.setIsAllowEmpty(isAllowEmpty);
        p_vecMode[p_currentMode].addOption(option);
}
 
void OptionParser::print() const{
        if(p_exempleLongOption != "" || p_exempleShortOption != ""){
                cout << "Usage :" << endl;
                if(p_exempleLongOption != ""){cout << "\t" << p_exempleLongOption << endl;}
                if(p_exempleShortOption != ""){cout << "\t" << p_exempleShortOption << endl;}
        }
        cout << "Parameters :" << endl;
        VecMode::const_iterator it(p_vecMode.begin());
        it->print();
        ++it;
        while(it != p_vecMode.end()){
                it->print();
                ++it;
        }
}
 
 
void OptionParser::parseArgument(int argc, char** argv){
        ArgParser parser(argc, argv);
        if(parser.isBashCompletionMode()){
                parseArgumentBashCompletion(parser);
        }else{
                parseArgumentNormalUse(parser);
        }
}
 
 
const OptionMode & OptionParser::getDefaultMode() const{
        return p_vecMode[0lu];
}
 
 
OptionMode & OptionParser::getDefaultMode(){
        return p_vecMode[0lu];
}
 
 
const OptionMode & OptionParser::getMode(const std::string & name) const{
        for(VecMode::const_iterator it(p_vecMode.begin()); it != p_vecMode.end(); ++it){
                if(it->getName() == name){
                        return *it;
                }
        }
        return getDefaultMode();
}
 
 
OptionMode & OptionParser::getMode(const std::string & name){
        for(VecMode::iterator it(p_vecMode.begin()); it != p_vecMode.end(); ++it){
                if(it->getName() == name){
                        return *it;
                }
        }
        return getDefaultMode();
}
 
 
bool OptionParser::isModeExist(const std::string & name) const{
        bool isSearch(true);
        VecMode::const_iterator it(p_vecMode.begin());
        while(isSearch && it != p_vecMode.end()){
                isSearch &= it->getName() != name;
                ++it;
        }
        return !isSearch;
}
 
 
void OptionParser::copyOptionParser(const OptionParser & other){
        p_vecMode = other.p_vecMode;
        p_currentMode = other.p_currentMode;
        p_exempleShortOption = other.p_exempleShortOption;
        p_exempleLongOption = other.p_exempleLongOption;
        p_programVersion = other.p_programVersion;
        p_enableHelpOption = other.p_enableHelpOption;
}
 
void OptionParser::initialisationOptionParser(){
        p_currentMode = 0lu;
        p_currentParserMode = NULL;
        OptionMode defaultMode;
        p_vecMode.push_back(defaultMode);
}
 
 
void OptionParser::parseArgumentNormalUse(ArgParser & parser){
        p_currentParserMode = &p_vecMode.front();
        while(!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"){
                                cout << "Program version : " << p_programVersion << endl;
                                exit(0);
                        }
                }
                OptionMode & currentMode = getParserMode(parser);
                if(!currentMode.parseOption(parser)){
                        std::string modeName(currentMode.getName());
                        std::string modeError("");
                        if(modeName != ""){
                                modeError = " in mode '"+modeName+"' ";
                        }
                        throw std::runtime_error("OptionParser::parseArgument : unknown option '"+parser.getCurrentOption()+"'" + modeError);
                }
        }
        if(!checkArgument()){
                throw std::runtime_error("OptionParser::parseArgument : missing argument");
        }
}
 
 
void OptionParser::parseArgumentBashCompletion(ArgParser & parser){
        //First step, we parse normally the existing arguments
        std::string cursorOption(parser.getCursorOption());
        std::string prevCursorOption(parser.getPrevCursorOption());
        Option * partialOption = NULL;
        while(!parser.isEndOfOption()){         //We loop to find the option which has not been parsed well
                bool isSearch(true);
                VecMode::iterator itMode = p_vecMode.begin();
                while(!parser.isEndOfOption() && itMode != p_vecMode.end() && isSearch){
                        isSearch = !itMode->parseOption(parser, partialOption);
                        ++itMode;
                }
                if(isSearch){           //If no option matches, we go to the next argument
                        parser.getNextOption();
                }
        }
        //Complete the ongoing option (filename, directory, enum value, etc)
//      if(partialOption != NULL){              //The option name has no ambiguity but we expect a value
//              std::string possibleValue("");
//              partialOption->getPossibleValue(possibleValue, cursorOption);
//              cout << possibleValue << endl;
//      }else{
                //Let's get the mode which is currently parsed
                //If all the options are fine, we have to show the remaning options. That's the following
                std::string possibleValue("");
                if(completeOptionValue(possibleValue, cursorOption, prevCursorOption)){
//                      saveFileContent("listPossibleValues.txt", possibleValue);
                        std::cout << possibleValue << std::endl;
                }else{
                        //Then, get the remaning arguments (not parsed yet)
                        std::string possibleOption("");
                        getPossibleOption(possibleOption, cursorOption);
                        getPossibleOtherOption(possibleOption, cursorOption);
                        
//                      saveFileContent("listPossibleOption.txt", possibleOption);
                        std::cout << possibleOption << std::endl;
                }
//      }
        exit(0);
//      La marche a suivre est assez simple
//              On renvoie une ligne par argument possible
//              Si il y en a qu'une seule, elle sera ajouté à la fin de la ligne de commande
//      DONE : mettre en place un méchanisme pour générer le bash qui appellera le programme différemment
}
 
 
bool OptionParser::checkArgument() const{
        bool isArgOk(true);
        VecMode::const_iterator it(p_vecMode.begin());
        while(it != p_vecMode.end() && isArgOk){
                isArgOk = it->checkArgument();
                ++it;
        }
        return isArgOk;
}
 
 
OptionMode & OptionParser::getParserMode(ArgParser & parser){
        std::string currentOption(parser.getCurrentOption());
        if(isModeExist(currentOption)){
                OptionMode & mode = getMode(currentOption);
                p_currentParserMode = &mode;
                parser.getNextOption();
                return mode;
        }else{
                return *p_currentParserMode;
        }
}
 
 
const OptionMode * OptionParser::getCurrentlyParsedMode() const{
        const OptionMode * mode = NULL;
        VecMode::const_iterator it(p_vecMode.begin());
        while(it != p_vecMode.end() && mode == NULL){
                if(it->isCurrentlyParsed() && it->getName() != ""){
                        mode = &(*it);
                }
                ++it;
        }
        return mode;
}
 
 
bool OptionParser::completeOptionValue(std::string & possibleValue, const std::string & cursorOption, const std::string & prevCursorOption) const{
//      std::cerr << "OptionParser::completeOptionValue : cursorOption = '"<<cursorOption<<"', prevCursorOption = '"<<prevCursorOption<<"'" << std::endl;
        std::string valueToBeCompleted("");
        //Check is the cursor option starts with a long option (--option=value) because the value can be completed
        const Option * op = getLongOptionValue(valueToBeCompleted, cursorOption);
        if(op == NULL){         //Check is the previous option corresponds to an existing option, to complete the value given by the current option
                op = getSplitOptionValue(valueToBeCompleted, cursorOption, prevCursorOption);
        }
        if(op != NULL){
                op->getPossibleValue(possibleValue, valueToBeCompleted);
//              std::cerr << "OptionParser::completeOptionValue : possibleValue = '"<<possibleValue<<"'" << std::endl;
                return true;
        }
        return false;
}
 
 
const Option * OptionParser::getLongOptionValue(std::string & valueToBeCompleted, const std::string & cursorOption) const{
        if(cursorOption == ""){return NULL;}
        const Option * op = NULL;
        VecMode::const_iterator itMode(p_vecMode.begin());
        while(itMode != p_vecMode.end() && op == NULL){
                if(itMode->isCurrentlyParsed()){
                        const VecOption & vecOp = itMode->getVecOption();
                        VecOption::const_iterator itOp(vecOp.begin());
                        while(itOp != vecOp.end() && op == NULL){
                                std::string fullOp("--" + itOp->getLongName() + "=");
                                if(isSameBegining(cursorOption, fullOp)){
                                        op = &(*itOp);
                                        valueToBeCompleted = cursorOption.substr(fullOp.size());
                                }
                                ++itOp;
                        }
                }
                ++itMode;
        }
        return op;
}
 
 
const Option * OptionParser::getSplitOptionValue(std::string & valueToBeCompleted, const std::string & cursorOption, const std::string & prevCursorOption) const{
        if(prevCursorOption == ""){return NULL;}
        const Option * op = NULL;
        VecMode::const_iterator itMode(p_vecMode.begin());
        while(itMode != p_vecMode.end() && op == NULL){
                if(itMode->isCurrentlyParsed()){                //Search only in the mode which is currently parsed
                        const VecOption & vecOp = itMode->getVecOption();
                        VecOption::const_iterator itOp(vecOp.begin());
                        while(itOp != vecOp.end() && op == NULL){
                                std::string fullLongOp("--" + itOp->getLongName()), fullShortOption("-" + itOp->getShortName());
                                if(fullLongOp == prevCursorOption){
                                        op = &(*itOp);
                                        valueToBeCompleted = cursorOption;
                                }else if(fullShortOption == prevCursorOption){
                                        op = &(*itOp);
                                        valueToBeCompleted = cursorOption;
                                }
                                ++itOp;
                        }
                }
                ++itMode;
        }
        return op;
}
 
 
void OptionParser::getPossibleOption(std::string & possibleOption, const std::string & cursorOption) const{
        if(p_vecMode.size() == 1lu){
                p_vecMode.front().getPossibleOption(possibleOption, cursorOption);
        }else{
                const OptionMode * currentlyParsedMode = getCurrentlyParsedMode();
                if(currentlyParsedMode != NULL){
                        currentlyParsedMode->getPossibleOption(possibleOption, cursorOption);
                }else{
                        for(VecMode::const_iterator itMode = p_vecMode.begin(); itMode != p_vecMode.end(); ++itMode){
                                itMode->getPossibleMode(possibleOption, cursorOption);
                        }
                }
        }
}
 
 
void OptionParser::getPossibleOtherOption(std::string & possibleOption, const std::string & cursorOption) const{
        std::vector<std::string> vecOtherOption;
        vecOtherOption.push_back("--help");
        vecOtherOption.push_back("-h");
        vecOtherOption.push_back("--version");
        vecOtherOption.push_back("-v");
        
        for(std::vector<std::string>::iterator it(vecOtherOption.begin()); it != vecOtherOption.end(); ++it){
                std::string optionStr(*it);
                if(cursorOption == ""){
                        possibleOption += optionStr + " ";
                }else{
                        if(isSameBegining(optionStr, cursorOption)){
                                possibleOption += optionStr + " ";
                        }
                }
        }
}