option.h

#ifndef __COMMAND_OPTION_H
#define __COMMAND_OPTION_H
 
#include <string>
#include <sstream>
#include <stdexcept>
 
#include "parameter.h"
#include "exception/missingOptionValue.h"
#include "exception/optionFailedConversion.h"
#include "exception/optionValueNotSpecified.h"
 
namespace command {
    template<typename ParameterType>
    class Option
        : public Parameter, public Callable<ParameterType>  {
    public:
        typedef std::string OptionName;
    protected:
        const OptionName name;
 
        ParameterType value;
 
    public:
        Option(const std::string & name, const std::string & description, std::function<void(ParameterType)> function)
            : Parameter(description), Callable<ParameterType>(function), name(name) {
        }
 
        virtual ~Option() { }
 
        virtual void handle() {
            this->call(value);
            used = true;
        }
 
        virtual bool understand(const std::string & argv) {
            if (this->hasName(argv)) {
                std::size_t pos = this->valuePosition(argv);
 
                if (pos != name.size()) {
                    throw MissingOptionValue("Option: " + name + " requires value but no one has been provided");
                }
 
                std::stringstream ss;
                ss << std::fixed << argv.substr(pos + 1);
                ss >> value;
 
                if (ss.fail()) {
                    throw OptionFailedConversion("Option: " + name + " failed value conversion to the required type");
                }
 
                return true;
            }
            return false;
        }
 
        virtual unsigned int valuePosition(const std::string & value) {
            std::size_t pos = value.find("=");
 
            if ((this->hasName(value)) && (pos == std::string::npos)) {
                throw OptionValueNotSpecified("Option: " + name + " requires value to be specified after equal sign, but no equal sign was found");
            }
 
            return pos;
        }
 
    protected:
        bool hasName(const std::string & argv) {
            return argv.find(name) == 0;
        }
    };
 
    template<>
    class Option<void>
        : public Parameter, public Callable<void>  {
    public:
        typedef std::string OptionName;
    protected:
        const OptionName name;
    public:
        Option(const std::string & name, const std::string & description, std::function<void(void)> function)
            : Parameter(description), Callable<void>(function), name(name) {
        }
 
        virtual void handle() {
            this->call();
            used = true;
        }
 
        virtual bool understand(const std::string & argv) {
            if (argv == name) {
                return true;
            }
            return false;
        }
 
        virtual unsigned int valuePosition(const std::string & ) {
            throw new std::invalid_argument(this->describe() + " is void Option, so it does not have value part");
        }
    };
}
 
#endif /* __COMMAND_OPTION_H */