value.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_VALUE_HPP
#define GEARS_OPTPARSE_VALUE_HPP

#include "actions.hpp"
#include "../utility/helpers.hpp"

namespace gears {
namespace optparse {
struct value_base {
    std::string metavar;     
    size_t nargs = 1;        

    virtual ~value_base() = default;
    virtual void parse(const std::string&, const std::string&) = 0;
    virtual bool is_active() const noexcept = 0;
    virtual std::unique_ptr<value_base> clone() const = 0;
};

template<typename T>
struct typed_value : public value_base {
private:
    T* reference = nullptr;
    std::unique_ptr<T> value;
    std::function<T(const std::string&, const std::string&)> action_;
    bool active = false;

    void parse(const std::string& key, const std::string& val) override {
        auto&& result = action_(key, val);
        active = true;
        if(reference != nullptr) {
            *reference = std::move(result);
        }
        else {
            value.reset(new T(std::move(result)));
        }
    }

    std::unique_ptr<value_base> clone() const override {
        auto&& ptr = utility::make_unique<typed_value<T>>(action_);
        ptr->reference = reference;
        ptr->active = active;
        ptr->nargs = nargs;
        ptr->metavar = metavar;
        return std::unique_ptr<value_base>{std::move(ptr)};
    }
public:
    template<typename Action>
    typed_value(Action action): action_(std::move(action)) {}

    typed_value(T& object): reference(&object) {}


    bool is_active() const noexcept override {
        return active;
    }

    template<typename Action>
    typed_value& action(Action&& action) {
        action_ = std::forward<Action>(action);
        return *this;
    }

    const T& get() const {
        if(!active) {
            throw std::runtime_error("value has not been parsed");
        }

        if(reference != nullptr) {
            return *reference;
        }
        return *value;
    }

    const T& get_or(const T& def) const noexcept {
        if(is_active()) {
            if(reference != nullptr) {
                return *reference;
            }
            return *value;
        }
        return def;
    }
};

template<typename Container, typename Action = store<typename Container::value_type>>
inline std::unique_ptr<value_base> compose(std::string metavar = "", Action action = Action{}) {
    auto&& ptr = utility::make_unique<typed_value<Container>>(append<Container>{action});
    ptr->metavar = std::move(metavar);
    return std::unique_ptr<value_base>{std::move(ptr)};
}

template<typename T, typename Action = store<T>>
inline std::unique_ptr<value_base> bind_to(T& t, std::string metavar = "", Action action = Action{}) {
    auto&& ptr = utility::make_unique<typed_value<T>>(t);
    ptr->action(std::move(action));
    ptr->metavar = std::move(metavar);
    return std::unique_ptr<value_base>{std::move(ptr)};
}

template<typename T>
inline std::unique_ptr<value_base> constant(const T& t) {
    auto&& ptr = utility::make_unique<typed_value<T>>(store_const<T>{t});
    ptr->nargs = 0;
    return std::unique_ptr<value_base>{std::move(ptr)};
}

template<typename T, typename Action = store<T>>
inline std::unique_ptr<value_base> value(std::string metavar = "", Action action = Action{}) {
    auto&& ptr = utility::make_unique<typed_value<T>>(action);
    ptr->metavar = std::move(metavar);
    return std::unique_ptr<value_base>{std::move(ptr)};
}

template<typename T, typename Action>
inline std::unique_ptr<value_base> custom(Action action, std::string metavar = "") {
    auto&& ptr = utility::make_unique<typed_value<T>>(action);
    ptr->metavar = std::move(metavar);
    return std::unique_ptr<value_base>{std::move(ptr)};
}

template<typename Container, typename Action = store<typename Container::value_type>>
inline std::unique_ptr<value_base> list(size_t arguments, std::string metavar = "", Action action = Action{}) {
    static_assert(std::is_convertible<decltype(action("", "")), typename Container::value_type>::value,
                  "The action must return a type convertible to the container's value type");
    auto&& ptr = utility::make_unique<typed_value<Container>>(store_list<Container, Action>{action});
    ptr->nargs = arguments;
    ptr->metavar = std::move(metavar);
    return std::unique_ptr<value_base>{std::move(ptr)};
}
} // optparse
} // gears

#endif // GEARS_OPTPARSE_VALUE_HPP