|| || || || || || || ||

---

CmdOptions.h

Go to the documentation of this file.

#ifndef Impala_Basis_CmdOptions_h
#define Impala_Basis_CmdOptions_h

#include <vector>
#include <iterator>

#include "Basis/FileName.h"
#include "Basis/FileReadString.h"
#include "Basis/FileExists.h"
#include "Basis/LogSystem.h"
#include "Basis/ILog.h"

namespace Impala
{

class CmdOptions
{
public:

    static CmdOptions&
    GetInstance()
    {
        static CmdOptions theCmdOptions;
        return theCmdOptions;
    }

    void
    Initialise(bool stdVideoOptions = false, bool stdGaussOptions = false,
               bool stdDatabaseOptions = false)
    {
        if (stdVideoOptions)
        {
            AddOption(0, "wndWidth",  "size",    "-1");
            AddOption(0, "wndHeight", "size",    "-1");
            AddOption(0, "viewScale", "scale",   "1.0");
            AddOption('s', "src",     "type",    "",
              "dx|avi|mpeg2|mpeg2es|lavc|lavcnoidx|lavcwithidx|lavcwriteidx");
            AddOption(0, "srcWindow", "type",    "",
              "size;3;copyreal|size;5;rgb2ooo|size;5;gauss;0.75;0;0;3.0");
            AddOption(0, "step",      "",        "0");
            AddOption(0, "loop",      "",        "0");
            AddOption(0, "startFrame","nr",      "0");
            AddOption(0, "stepSize",  "nr",      "1");
            AddOption(0, "numberFrames", "nr",   "-1");
            AddOption(0, "delay",     "nrFrames","0");
            AddOption(0, "jmp","type","pos","pos|pts");
            AddOption(0, "fixIdx", "Fix Broken indexes for LAVC", "1");
        }
        if (stdGaussOptions)
        {
            AddOption(0, "sigma",     "val",     "1.0");
            AddOption(0, "precision", "val",     "3.0");
            AddOption(0, "recGauss",  "",        "0");
            AddOption(0, "disp",      "mode",    "LogMagnitude");
            AddOption(0, "logScale",  "val",     "32.0");
        }
        if (stdDatabaseOptions)
        {
            AddOption(0, "data",          "path", ".", 0, true);
            AddOption(0, "dataServer",    "machine:port", "", 0, true);
            AddOption(0, "mapi",          "machine:port[:db]", "", 0, true);
            AddOption(0, "passwordFile",  "filename", ".passwords", 0, true);
            AddOption(0, "videoSet",      "filename", "", 0, true);
#ifndef REPOSITORY_USED // Here comes the deprecated stuff
            AddOption(0, "videoSetRepository", "filename", "../videosets.txt",
                      0, true);
#endif // REPOSITORY_USED
            AddOption(0, "videoSetsRepository", "filename", "videosets.txt",
                      0, true);
            AddOption(0, "imageSet",      "filename", "", 0, true);
#ifndef REPOSITORY_USED // Here comes the deprecated stuff
            AddOption(0, "imageSetRepository", "filename", "../imagesets.txt",
                      0, true);
#endif // REPOSITORY_USED
            AddOption(0, "imageSetsRepository", "filename", "imagesets.txt",
                      0, true);
            AddOption(0, "override",      "",     "0");
        }
        AddOption(0, "tmpPath",           "folder",     "");
#ifdef CUDA
        AddOption(0, "cudaDevice",        "index", "0");
#endif
    }

    void
    AddOption(char optNameS, const char* optNameL, const char* parName,
              const char* defVal, const char* alternatives = 0,
              bool defaultFromEnv = false)
    {
        mOptNameS.push_back(optNameS);
        mOptNameL.push_back(String(optNameL));
        mOptParName.push_back(parName);
        String stringDef(defVal);
        if (defaultFromEnv)
        {
            char* str;
            str = getenv(optNameL);
            if (str != 0)
                stringDef = str;
        }
        mOptDefVal.push_back(stringDef);
        mOptVal.push_back(stringDef);
        if (alternatives)
            mOptAlt.push_back(alternatives);
        else
            mOptAlt.push_back("");
        mOptHideUsage.push_back(false);
    }

    void
    SetDefault(char* optNameL, char* defVal)
    {
        int i = GetOptIdx(String(optNameL));
        if (i < 0)
            return;
        mOptVal[i] = String(defVal);
    }

    bool
    ParseArgs(int argc, char* argv[], String usageStr, int nrReqArgs = 0)
    {
        if ((argc > 1) && (String(argv[1]) == "--version"))
        {
            std::cout << "Impala version " << IMPALA_VERSION_STR
                      << ", svnversion " << SVN_VERSION_STR
                      << ", build on " << __DATE__ << " at " << __TIME__
                      << std::endl;
            return false;
        }

        String parseError = DoParseArgs(argc, argv, usageStr, nrReqArgs);
        ConfigureLogSystem(); // we assume this will not fail
        if (parseError.empty())
            return true;

        ILOG_ERROR(parseError);
        ShowUsage(argv[0], usageStr);
        return false;
    }

    int
    GetNrArg()
    {
        return mArg.size();
    }

    String
    GetArg(int i)
    {
        if ((i<0) || (i>=mArg.size()))
        {
            std::cout << "CmdOptions: no argument " << i << std::endl;
            return String("");
        }
        return mArg[i];
    }

    String
    GetString(String optL, String defVal = "")
    {
        int i = GetOptIdx(optL);
        if (i < 0)
            return defVal;// String("");
        return mOptVal[i];
    }

    int
    GetInt(String optL, int defVal = -1)
    {
        int i = GetOptIdx(optL);
        if (i < 0)
            return defVal;
        String s = mOptVal[i];
        return atoi(s);
    }

    double
    GetDouble(String optL, double defVal = -1)
    {
        int i = GetOptIdx(optL);
        if (i < 0)
            return defVal;
        String s = mOptVal[i];
        return atof(s);
    }

    bool
    GetBool(String optL, bool defVal = false)
    {
        int i = GetOptIdx(optL);
        if (i < 0)
            return defVal;
        String s = mOptVal[i];
        if (atoi(s) != 0)
            return true;
        if (s == "yes"  ||  s == "true")
            return true;
        return false;
    }

    void
    PrintArgs(std::ostream& os)
    {
        for (int i = 0 ; i < mOptNameL.size() ; ++i)
            os << mOptNameL[i] << " => " << mOptVal[i] << "\n";
        os << std::endl;
    }

    void
    HideUsageFor(String parameter)
    {
        int idx = GetOptIdx(parameter);
        if (idx < 0) 
            return;
        mOptHideUsage[idx] = true;
    }

private:

    CmdOptions()
    {
        AddOption('v', "verb", "level", "0");
        AddOption(0, "debug", "", "0");
        AddOption(0, "debugCat", "categories separated with ';' or ':'", "");
        AddOption(0, "logProperties", "fileName", "./log4cpp.properties");
        AddOption(0, "logFile", "fileName", "");
        AddOption(0, "logLayout", "layoutPattern",
                  "%d{%a%d %H:%M:%S,%l} %-5p [%c %x] %m%n");
        AddOption(0, "noErrorLog", "", "0");
        AddOption(0, "jobErrorLog", "fileName", "");
        AddOption(0, "exitOnErrorLogged", "", "0");
        AddOption(0, "logFlushOutput", "flag", "0");
        AddOption(0, "showProgress", "flag", "1");
        AddOption(0, "ini", "filename", "");
    }

    CmdOptions(const CmdOptions&)
    {
    }

    CmdOptions&
    operator=(const CmdOptions&)
    {
    }

    virtual
    ~CmdOptions()
    {
    }

    int
    NrOpt()
    {
        return mOptNameL.size();
    }

    int
    GetOptIdx(String s)
    {
        for (int i=0 ; i<NrOpt() ; i++)
        {
            if ((s.size() == 1) && (s[0] == mOptNameS[i]))
                return i;
            if (s.compare(mOptNameL[i]) == 0)
                return i;
        }
        return -1;
    }

    bool
    IsOpt(String s)
    {
        return (s[0] == '-');
    }

    bool
    IsOptS(String s)
    {
        return ((s[0] == '-') && (s[1] != '-'));
    }

    bool
    IsOptL(String s)
    {
        return ((s[0] == '-') && (s[1] == '-'));
    }

    void
    CheckDynamicOption(String s)
    {
        if (StringStartsWith(s, "data::"))
        {
            AddOption(0, s.c_str(), "prefixPath", "");
        }
        if (StringStartsWith(s, "dataServer::"))
        {
            AddOption(0, s.c_str(), "otherServer", "");
        }
    }

    String
    DoParseArgs(int argc, char* argv[], String usageStr, int nrReqArgs)
    {
        if (argc < nrReqArgs + 1)
        {
            for(int i=0 ; i<argc ; i++)
                std::cout << argv[i] << std::endl;
            return "Need more arguments: " + MakeString(argc-1) + " found, "
                + MakeString(nrReqArgs) + " expected";
        }
        
        // search for ini file name in the arguments
        String fileName(argv[0]);
        bool sawIniOption = false;
        fileName = FileNameBase(fileName) + ".ini";
        int i = 1;
        while (i < argc)
        {
            String s = String(argv[i]);
            if (s == "--ini")
            {
                if (i+1 >= argc)
                    return "Missing value for --ini";

                if (argv[i+1][0] == '-')
                    return "Missing value for --ini";

                sawIniOption = true;
                fileName = String(argv[i+1]);
                break;
            }
            i++;
        }
        if (sawIniOption && !FileExists(fileName))
            return "Couldn't open ini file " + fileName;

        ReadIniFile(fileName);

        i = 1;
        while (i < argc)
        {
            String s = String(argv[i]);
            if ((s == "-h") || (s == "--help"))
                return "help";

            if (IsOpt(s))
            {
                s = s.substr(s.rfind('-',2)+1); // remove --
                CheckDynamicOption(s); // add data::something like options
                int idx = GetOptIdx(s);
                if (idx < 0)
                {
                    if (s != "ini")
                        return "Unknown option --" + s;

                }
                else if (mOptParName[idx] != "")
                {
                    if (i+1 >= argc)
                        return "Missing value for --" + s;

                    if (argv[i+1][0] == '-')
                        return "Missing value for --" + s;

                    String tmp(argv[i+1]);
                    if (tmp[0] == '"')
                    {   // follow embedding quotes
                        while (tmp[tmp.size()-1] != '"')
                        {
                            i++;
                            if (i + 1 >= argc)
                                return "Quoted string not terminated";

                            tmp = tmp + " " + String(argv[i+1]);
                        }
                        tmp = tmp.substr(1, tmp.size()-2);
                        if (tmp[0] == '"') // mpi programs still get these
                            tmp = tmp.substr(1, tmp.size()-2);
                    }
                    mOptVal[idx] = tmp;
                    i++;
                }
                else
                {
                    mOptVal[idx] = "1";
                }
            }
            else
            {
                if (s[0] == '"') // mpi programs still get these
                    s = s.substr(1, s.size()-2);
                mArg.push_back(s);
            }
            i++;
        }

        if (mArg.size() < nrReqArgs)
            return "Need more arguments";

        return String();
    }

    void
    ShowUsage(char* progName, String usageStr)
    {
        std::cout << std::endl;
        std::cout << "Usage : " << progName << " " << usageStr << std::endl;
        std::cout << std::endl;
        std::cout << "  Options:" << std::endl;
        std::cout << "    -h  --help" << std::endl;
        std::cout << "        --version" << std::endl;
        for (int i=0 ; i<NrOpt() ; i++)
        {
            if (mOptParName[i] == "read from ini file")
                continue;
            if (mOptHideUsage[i])
                continue;
            if (mOptNameS[i])
                std::cout << "    -" << mOptNameS[i];
            else
                std::cout << "      ";
            std::cout << "  --" << mOptNameL[i] << " " << mOptParName[i];
            if (! mOptDefVal[i].empty())
                std::cout << " [default: " << mOptDefVal[i] <<"]";
            if (! mOptAlt[i].empty())
                std::cout << " [" << mOptParName[i] << " in " << mOptAlt[i]
                          << "]";
            std::cout << std::endl;
        }
    }
    
    void
    ReadIniFile(String fileName)
    {
        std::vector<String> lines;
        std::back_insert_iterator<std::vector<String> > bi(lines);
        FileReadString(bi, fileName, true, false);
        for (int i=0 ; i<lines.size() ; i++)
        {
            String& s = lines[i];
            if (s[0] == '#')
                continue;
            String::size_type pos = 0;
            while (s[pos] == ' ')
                pos++;
            String::size_type end = s.find(' ', pos);
            String name = s.substr(pos, end - pos);
            if (end == String::npos)
                continue;

            pos = end;
            while (s[pos] == ' ')
                pos++;
            char delim = (s[pos] == '"') ? '"' : ' ';
            if (delim == '"')
                pos++;
            end = s.find(delim, pos);
            String value = s.substr(pos, end - pos);

            int index = GetOptIdx(name);
            if (index == -1)
                AddOption(0, name.c_str(), "read from ini file", value.c_str());
            else
                mOptVal[index] = value;
        }
    }

    void
    ConfigureLogSystem()
    {
        LogSystem::LogSystemConfig logConfig;
        logConfig.mLogProperties = GetString("logProperties");
        logConfig.mLogLayout = GetString("logLayout");
        logConfig.mLogFile = GetString("logFile");
        logConfig.mLogFlushOutput = GetBool("logFlushOutput");
        logConfig.mLogLevel = GetInt("logLevel");
        logConfig.mDebug = GetBool("debug");
        logConfig.mDebugCat = StringReplaceAll(GetString("debugCat"), ":", ";", false);
        logConfig.mNoErrorLog = GetBool("noErrorLog");
        logConfig.mJobErrorLog = GetString("jobErrorLog");
        logConfig.mExitOnError = GetBool("exitOnErrorLogged");
        LogSystem::GetInstance().Configure(logConfig);
    }

    std::vector<char>   mOptNameS;
    std::vector<String> mOptNameL;
    std::vector<String> mOptDefVal;
    /* note that the default value is only stored in order to display it, it is
       already stored in the value upon creation of the option. see AddOption()*/
    std::vector<String> mOptVal;
    std::vector<String> mOptParName;
    std::vector<String> mOptAlt;
    std::vector<bool>   mOptHideUsage;
    std::vector<String> mArg;

    ILOG_VAR_DECL;
};

ILOG_VAR_INIT(CmdOptions, Impala);

} // namespace Impala

#endif

---