option.hpp

// The MIT License (MIT)

// Copyright (c) 2012-2014 Danny Y., Rapptz

// Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in
// the Software without restriction, including without limitation the rights to
// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
// the Software, and to permit persons to whom the Software is furnished to do so,
// subject to the following conditions:

// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.

// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

#ifndef GEARS_OPTPARSE_OPTION_HPP
#define GEARS_OPTPARSE_OPTION_HPP

#include "value.hpp"
#include "../enums/operators.hpp"

using namespace gears::enums::operators;

namespace gears {
namespace optparse {
enum class trait : char {
    none     = 0,        
    required = 1 << 0,   
    hidden   = 1 << 1    
};

struct option {
private:
    using value_type = std::unique_ptr<value_base>;
    value_type ptr;
    friend struct option_parser;
public:
    std::string name;   
    std::string help;   
    trait flags;       
    char alias = '\0';  

    option(std::string name, std::string help = "", value_type value = constant(true), trait flags = trait::none):
        ptr(std::move(value)), name(std::move(name)), help(std::move(help)), flags(std::move(flags)) {}
    option(std::string name, char alias, std::string help = "", value_type value = constant(true), trait flags = trait::none):
        ptr(std::move(value)), name(std::move(name)), help(std::move(help)), flags(std::move(flags)), alias(alias) {}

    option(char alias, std::string help = "", value_type value = constant(true), trait flags = trait::none):
        ptr(std::move(value)), help(std::move(help)), flags(std::move(flags)), alias(alias) {}

    option(const option& other):
        ptr(other.ptr == nullptr ? nullptr : other.ptr->clone()),
        name(other.name), help(other.help), flags(other.flags), alias(other.alias) {}

    option& operator=(const option& other) {
        ptr = other.ptr == nullptr ? nullptr : other.ptr->clone();
        name = other.name;
        help = other.help;
        flags = other.flags;
        alias = other.alias;
        return *this;
    }

    option(option&&) = default;

    option& operator=(option&&) = default;

    ~option() = default;

    bool takes_value() const noexcept {
        return ptr != nullptr && ptr->nargs > 0;
    }

    size_t nargs() const noexcept {
        return takes_value() ? ptr->nargs : 0;
    }


    bool is(char arg) const noexcept {
        return alias == arg;
    }

    bool is(const std::string& arg) const noexcept {
        return name == arg;
    }

    template<typename T>
    const T& get() const {
        if(ptr == nullptr) {
            throw std::invalid_argument("option does not take value");
        }
        auto val = dynamic_cast<typed_value<T>*>(ptr.get());

        if(val == nullptr) {
            throw std::invalid_argument("invalid cast for option");
        }
        return val->get();
    }

    template<typename T>
    const T& get_or(const typename std::remove_reference<T>::type& def) const noexcept {
        if(ptr == nullptr) {
            return def;
        }

        auto val = dynamic_cast<typed_value<T>*>(ptr.get());
        return val == nullptr ? def : val->get_or(def);
    }

    bool is_active() const noexcept {
        return ptr != nullptr && ptr->is_active();
    }

    std::string metavar() const noexcept {
        return takes_value() ? ptr->metavar : "";
    }
};
} // optparse
} // gears

#endif // GEARS_OPTPARSE_OPTION_HPP