TypedArgument.hpp

Go to the documentation of this file.

#pragma once

#include <type_traits>

namespace TAP {

template<typename T, bool multi = false>
class TypedArgument;

template<typename T, bool multi>
using TypedArgumentCheckFunc = std::function<void(const TypedArgument<T, multi>&, const T& value)>;

template<typename T, bool multi>
class TypedArgument: public Argument {
    static_assert(!std::is_void<T>::value, "Cannot make void arguments, use plain Argument");
    static_assert(!std::is_const<T>::value, "Cannot make const arguments");
    static_assert(!std::is_volatile<T>::value, "Cannot make volatile arguments");
    static_assert(!std::is_reference<T>::value, "Cannot make reference arguments");
    static_assert(!std::is_pointer<T>::value, "Cannot make pointer arguments");

protected:
    using ST = typename std::conditional< !multi, T, std::vector<T> >::type;

    mutable ST* m_storage;

    TypedArgumentCheckFunc<T, multi> m_typedCheckFunc = nullptr;

protected:
    TypedArgument(std::string description, ST* storage) :
        Argument(std::move(description)), m_storage(storage) {
        m_max = (multi?0:1);
    }

    TypedArgument(std::string description, char flag, ST* storage) :
        Argument(std::move(description), flag), m_storage(storage) {
        m_max = (multi?0:1);
    }

    TypedArgument(std::string description, const std::string& name, ST* storage) :
        Argument(std::move(description), name), m_storage(storage) {
        m_max = (multi?0:1);
    }

    TypedArgument(std::string description, char flag, const std::string& name, ST* storage) :
        Argument(std::move(description), flag, name), m_storage(storage) {
        m_max = (multi?0:1);
    }

public:
    void set() const override = 0;

    bool takes_value() const override = 0;

    const ST& value() const {
        return *m_storage;
    }

    virtual TypedArgument& check(TypedArgumentCheckFunc<T, multi> typedCheckFunc) {
        m_typedCheckFunc = typedCheckFunc;
        return *this;
    }

    std::unique_ptr<BaseArgument> clone() const & override = 0;

    std::unique_ptr<BaseArgument> clone() && override = 0;

protected:
    template<bool m = multi>
    typename std::enable_if<!m>::type
    check() const override {
        if (m_typedCheckFunc != nullptr) {
            m_typedCheckFunc(*this, *m_storage );
        }
    }

    template<bool m = multi>
    typename std::enable_if<m>::type
    check() const override {
        if (m_typedCheckFunc != nullptr) {
            m_typedCheckFunc(*this, (*m_storage)[m_storage->size()-1] );
        }
    }
};

template<typename T, bool multi = false>
class VariableArgument : public TypedArgument<T, multi>, public ValueAcceptor {
    static_assert(!std::is_void<T>::value, "Cannot make void arguments, use Argument");

protected:
    using ST = typename TypedArgument<T, multi>::ST;

    std::string m_valueName = std::string("value");

public:
    VariableArgument(std::string description, ST* storage) :
        TypedArgument<T, multi>(std::move(description), storage) {
    }

    VariableArgument(std::string description, char flag, ST* storage) :
        TypedArgument<T, multi>(std::move(description), flag, storage) {
    }

    VariableArgument(std::string description, const std::string& name, ST* storage) :
        TypedArgument<T, multi>(std::move(description), name, storage) {
    }

    VariableArgument(std::string description, char flag, const std::string& name, ST* storage) :
        TypedArgument<T, multi>(std::move(description), flag, name, storage) {
    }

    VariableArgument(std::string description, ST& storage) :
        TypedArgument<T, multi>(std::move(description), &storage) {
    }

    VariableArgument(std::string description, char flag, ST& storage) :
        TypedArgument<T, multi>(std::move(description), flag, &storage) {
    }

    VariableArgument(std::string description, const std::string& name, ST& storage) :
        TypedArgument<T, multi>(std::move(description), name, &storage) {
    }

    VariableArgument(std::string description, char flag, const std::string& name, ST& storage) :
        TypedArgument<T, multi>(std::move(description), flag, name, &storage) {
    }

    virtual ~VariableArgument() = default;

    VariableArgument(const VariableArgument&) = default;

    VariableArgument(VariableArgument&&) = default;

    VariableArgument& operator=(const VariableArgument&) = default;

    VariableArgument& operator=(VariableArgument&&) = default;

    std::unique_ptr<BaseArgument> clone() const & override {
        return std::unique_ptr<BaseArgument>(new VariableArgument(*this));
    }

    std::unique_ptr<BaseArgument> clone() && override {
        return std::unique_ptr<BaseArgument>(new VariableArgument(std::move(*this)));
    }

    VariableArgument& valuename(const std::string& valueName) {
        m_valueName = valueName;
        return *this;
    }

    const std::string& valuename() {
        return m_valueName;
    }

    bool takes_value() const override {
        return !std::is_same<bool, T>::value;
    }

    void set() const override;

    void set(const std::string& value) const override;

    std::string usage() const override;

    std::string ident() const override;
};

template<typename T>
using MultiVariableArgument = VariableArgument<T, true>;

template<typename T, bool multi = false>
class ValueArgument : public VariableArgument<T, multi> {
protected:
    using ST = typename VariableArgument<T, multi>::ST;

    std::shared_ptr<ST> m_ownStorage;

public:
    template<typename... U, typename = typename std::enable_if< std::is_constructible<ST, U...>::value >::type >
    ValueArgument(std::string description, U&&... params) :
        VariableArgument<T, multi>(std::move(description), new ST(std::forward<U>(params)...)),
        m_ownStorage(TypedArgument<T, multi>::m_storage)
    {
    }

    template<typename... U, typename = typename std::enable_if< std::is_constructible<ST, U...>::value >::type>
    ValueArgument(std::string description, char flag, U&&... params) :
        VariableArgument<T, multi>(std::move(description), flag, new ST(std::forward<U>(params)...)),
        m_ownStorage(TypedArgument<T, multi>::m_storage)
    {
    }

    template<typename... U, typename = typename std::enable_if< std::is_constructible<ST, U...>::value >::type >
    ValueArgument(std::string description, const std::string& name, U&&... params) :
        VariableArgument<T, multi>(std::move(description), name, new ST(std::forward<U>(params)...)),
        m_ownStorage(TypedArgument<T, multi>::m_storage)
    {
    }

    template<typename... U, typename = typename std::enable_if< std::is_constructible<ST, U...>::value >::type >
    ValueArgument(std::string description, char flag, const std::string& name, U&&... params) :
        VariableArgument<T, multi>(std::move(description), flag, name, new ST(std::forward<U>(params)...)),
        m_ownStorage(TypedArgument<T, multi>::m_storage)
    {
    }

    virtual ~ValueArgument() = default;

    ValueArgument(const ValueArgument&) = default;

    ValueArgument(ValueArgument&&) = default;

    ValueArgument& operator=(const ValueArgument&) = default;

    ValueArgument& operator=(ValueArgument&&) = default;

    std::unique_ptr<BaseArgument> clone() const & override {
        return std::unique_ptr<BaseArgument>(new ValueArgument(*this));
    }

    std::unique_ptr<BaseArgument> clone() && override {
        return std::unique_ptr<BaseArgument>(new ValueArgument(std::move(*this)));
    }
};

template<typename T>
using MultiValueArgument = ValueArgument<T, true>;

template<typename T>
class ConstArgument: public TypedArgument<T, false> {
protected:
    T m_value;

public:
#ifdef TAP_AUTOFLAG

    ConstArgument(std::string description, T& storage, const T& value) :
        TypedArgument<T, false>(std::move(description), &storage), m_value(value) {
    }
#endif

    ConstArgument(std::string description, char flag, T& storage, const T& value) :
        TypedArgument<T, false>(std::move(description), flag, &storage), m_value(value) {
    }

    ConstArgument(std::string description, const std::string& name, T& storage, const T& value) :
        TypedArgument<T, false>(std::move(description), name, &storage), m_value(value) {
    }

    ConstArgument(std::string description, char flag, const std::string& name, T& storage, const T& value) :
        TypedArgument<T, false>(std::move(description), flag, name, &storage), m_value(value) {
    }

    ConstArgument(const ConstArgument&) = default;
    ConstArgument(ConstArgument&&) = default;

    virtual ~ConstArgument() {
    }

    ConstArgument& operator=(const ConstArgument& other) = default;

    ConstArgument& operator=(ConstArgument&& other) = default;

    bool takes_value() const override {
        return false;
    }

    void set() const override {
        Argument::set();
        *TypedArgument<T, false>::m_storage = m_value;
    }

    std::unique_ptr<BaseArgument> clone() const & override {
        return std::unique_ptr<BaseArgument>(new ConstArgument(*this));
    }

    std::unique_ptr<BaseArgument> clone() && override {
        return std::unique_ptr<BaseArgument>(new ConstArgument(std::move(*this)));
    }
};

class SwitchArgument : public TypedArgument<bool, false> {
protected:
    std::shared_ptr<bool> m_ownStorage;

public:
    // Constructors for storing value externally
#ifdef TAP_AUTOFLAG

    SwitchArgument(std::string description, bool& storage) :
        TypedArgument<bool, false>(std::move(description), &storage) {
    }
#endif

    SwitchArgument(std::string description, char flag, bool& storage) :
        TypedArgument<bool, false>(std::move(description), flag, &storage) {
    }

    SwitchArgument(std::string description, const std::string& name, bool& storage) :
        TypedArgument<bool, false>(std::move(description), name, &storage) {
    }

    SwitchArgument(std::string description, char flag, const std::string& name, bool& storage) :
        TypedArgument<bool, false>(std::move(description), flag, name, &storage) {
    }

    // Constructors for storing value internally
#ifdef TAP_AUTOFLAG

    SwitchArgument(std::string description) :
        TypedArgument<bool, false>(std::move(description), new bool()) {
    }
#endif

    SwitchArgument(std::string description, char flag) :
        TypedArgument<bool, false>(std::move(description), flag, new bool()),
        m_ownStorage(TypedArgument<bool, false>::m_storage)  {
    }

    SwitchArgument(std::string description, const std::string& name) :
        TypedArgument<bool, false>(std::move(description), name, new bool()),
        m_ownStorage(TypedArgument<bool, false>::m_storage) {
    }

    SwitchArgument(std::string description, char flag, const std::string& name) :
        TypedArgument<bool, false>(std::move(description), flag, name, new bool()),
        m_ownStorage(TypedArgument<bool, false>::m_storage)  {
    }

    SwitchArgument(const SwitchArgument&) = default;

    SwitchArgument(SwitchArgument&&) = default;

    virtual ~SwitchArgument() {}

    SwitchArgument& operator=(const SwitchArgument& other) = default;

    SwitchArgument& operator=(SwitchArgument&& other) = default;

    bool takes_value() const override {
        return false;
    }

    void set() const override {
        Argument::set();
        *TypedArgument<bool, false>::m_storage = !*TypedArgument<bool, false>::m_storage;
    }

    std::unique_ptr<BaseArgument> clone() const & override {
        return std::unique_ptr<BaseArgument>(new SwitchArgument(*this));
    }

    std::unique_ptr<BaseArgument> clone() && override {
        return std::unique_ptr<BaseArgument>(new SwitchArgument(std::move(*this)));
    }
};


}