CmdArgs.hpp

#pragma once
#include "creativity/cmdargs/Validation.hpp"
#include "creativity/cmdargs/strings.hpp"
#include <boost/program_options/options_description.hpp>
#include <boost/program_options/positional_options.hpp>
#include <boost/program_options/value_semantic.hpp>
#include <string>
#include <limits>
#include <type_traits>
#include <vector>

namespace boost { namespace program_options { class variables_map; } }

namespace creativity {
namespace cmdargs {

template <typename T> constexpr T inf_or_max() { return std::numeric_limits<T>::has_infinity ? std::numeric_limits<T>::infinity() : std::numeric_limits<T>::max(); }
template <typename T> constexpr T neginf_or_lowest() { return std::numeric_limits<T>::has_infinity ? -std::numeric_limits<T>::infinity() : std::numeric_limits<T>::lowest(); }

class CmdArgs {

    protected:
        CmdArgs() = default;

    public:
        void parse(int argc, char const* const* argv);

        template <typename T>
        static typename std::enable_if<not std::is_unsigned<T>::value and not std::is_same<T, bool>::value,
                                       boost::program_options::typed_value<T>*
                                      >::type
        value(T& store) {
            return boost::program_options::value<T>(&store)->default_value(store)->value_name(type_string<T>());
        }

        template <typename T>
        static typename std::enable_if<std::is_unsigned<T>::value and not std::is_same<T, bool>::value,
                        boost::program_options::typed_value<Validation<T>>*>::type
        value(T &storage) {
            return value<Validation<T>>(storage);
        }

        static boost::program_options::typed_value<bool>* value(bool& store) {
            return boost::program_options::bool_switch(&store)->default_value(store);
        }

        template <typename V>
        static boost::program_options::typed_value<V>*
        value(typename V::value_type &store) {
            return boost::program_options::value<V>()->default_value(store)->value_name(V::validationString())
                ->notifier([&store](const V &v) { store = v; /* NB: implicit conversion */ });
        }

        template <typename V, typename A>
        static boost::program_options::typed_value<std::vector<V>>*
        value(std::vector<typename V::value_type, A> &store) {
            return boost::program_options::value<std::vector<V>>()->value_name(
                    V::validationString() + " [" + V::validationString() + " ...]")
                ->notifier([&store](const std::vector<V> &v) {
                        store.clear();
                        store.reserve(v.size());
                        for (const auto &val : v) store.push_back((const typename V::value_type) val);
                    });
        }

        template <typename T, typename A>
        typename std::enable_if<not std::is_unsigned<T>::value, boost::program_options::typed_value<std::vector<T, A>>*>::type
        value(std::vector<T, A> &store) {
            return boost::program_options::value<std::vector<T, A>>(&store)->value_name(
                    type_string<T>() + " [" + type_string<T>() + " ...]");
        }

        template <typename T, typename A>
        typename std::enable_if<std::is_unsigned<T>::value, boost::program_options::typed_value<std::vector<Validation<T>>>*>::type
        value(std::vector<T, A> &store) {
            return value<Validation<T>>(store);
        }

        template <long minimum, long denom = 1, typename T>
        static inline boost::program_options::typed_value<Min<T, minimum, denom>>* min(T &store) { return value<Min<T, minimum, denom>>(store); }

        template <long maximum, long denom = 1, typename T>
        static boost::program_options::typed_value<Max<T, maximum, denom>>* max(T &store) { return value<Max<T, maximum, denom>>(store); }

        template <long min, long max, long denom = 1, typename T>
        static boost::program_options::typed_value<Range<T, min, max, denom>>* range(T &store) { return value<Range<T, min, max, denom>>(store); }

        template <long lower, long denom = 1, typename T>
        static boost::program_options::typed_value<Above<T, lower, denom>>* above(T &store) { return value<Above<T, lower, denom>>(store); }

        template <long upper, long denom = 1, typename T>
        static boost::program_options::typed_value<Below<T, upper, denom>>* below(T &store) { return value<Below<T, upper, denom>>(store); }

        virtual std::string version() const;

        virtual std::string versionSuffix() const;

        virtual std::string usage() const;

        virtual std::string help() const;

    protected:
        virtual void addOptions();

        std::string prog_name_;

        boost::program_options::options_description options_;

        boost::program_options::options_description invisible_;

        boost::program_options::positional_options_description positional_;

        virtual void postParse(boost::program_options::variables_map &vars);
};





}}