CmdArguments.h

Go to the documentation of this file.

#ifndef __CMD_ARGUMENTS__
#define __CMD_ARGUMENTS__

#include <map>
#include <string>
#include <iostream>
#include <sstream>
#include <set>

#include "boost/smart_ptr.hpp"
#include "boost/algorithm/string.hpp"
#include "boost/utility/value_init.hpp"

#include "Util/OptPilotException.h"

class CmdArguments {

public:

    CmdArguments(int argc, char **argv) {
        addArguments(argc, argv);
    }

    CmdArguments()
    {}

    ~CmdArguments()
    {}

    template<class T>
    T getArg(const std::string name, bool isFatal = false) {
        boost::value_initialized<T> value;
        return getArg<T>(name, value, isFatal);
    }

    template<class T>
    T getArg(const std::string name, T default_value, bool isFatal = false) {
        T value = default_value;
        try {
            value = this->arg<T>(name);
        } catch(OptPilotException &e) {
            if(isFatal) {
                std::ostringstream exe;
                exe << "Fatal: argument \"";
                exe << name;
                exe << "\" not found!";
                throw OptPilotException("CmdArguments::getArg", exe.str());
            } else {
                if(warned_.count(name) == 0) {
                    std::ostringstream warn;
                    warn << "\033[01;35m";
                    warn << "Warning: argument \"";
                    warn << name;
                    warn << "\" not found! Using default value (";
                    warn << default_value;
                    warn << ").";
                    warn << "\e[0m" << std::endl;
                    std::cout << warn.str() << std::flush;
                    warned_.insert(name);
                }
            }
        }

        return value;
    }

    template <class T>
    void addArgument(const std::string &name, const T &value) {
        std::ostringstream oss;
        oss << value;

        if (arguments_.find(name) != arguments_.end()) {
            throw OptPilotException("CmdArguments::addArgument",
                                    "Argument '" + name + "' exists");
        }

        arguments_.insert(std::make_pair(name, oss.str()));
    }

    template <class T>
    void replaceArgument(const std::string &name, const T &value) {
        std::ostringstream oss;
        oss << value;

        if (arguments_.find(name) == arguments_.end()) {
            arguments_.insert(std::make_pair(name, oss.str()));
            return;
        }

        arguments_.at(name) = oss.str();
    }

    char** getArguments() const;
    unsigned int getNumArguments() const {
        return arguments_.size();
    }
    //template<>
    //size_t getArg<size_t>(const std::string name, bool isFatal = false) {
        //return getArg<size_t>(name, 0, isFatal);
    //}

    //template<>
    //int getArg<int>(const std::string name, bool isFatal = false) {
        //return getArg<int>(name, 0, isFatal);
    //}

    //template<>
    //unsigned int getArg<unsigned int>(const std::string name, bool isFatal = false) {
        //return getArg<unsigned int>(name, 0, isFatal);
    //}

    //template<>
    //std::string getArg<std::string>(const std::string name, bool isFatal = false) {
        //return getArg<std::string>(name, "", isFatal);
    //}

private:

    std::map<std::string, std::string> arguments_;

    std::set<std::string> warned_;

    void addArguments(int argc, char **argv);

    void split(std::string &name, std::string &value, std::string arg);

    template<class T>
    T arg(const std::string name) {
        T t;
        std::map<std::string, std::string>::iterator it = arguments_.find(name);
        if(it != arguments_.end()) {
            std::istringstream iss(arguments_[name]);
            iss >> t;
            return t;
        } else {
            throw OptPilotException("CmdArguments::getArg", "argument not found!");
        }
    }
};

typedef boost::shared_ptr<CmdArguments> CmdArguments_t;

#endif