Validation.hpp

#pragma once
#include "creativity/cmdargs/strings.hpp"
#include <boost/program_options/errors.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 <regex>

namespace creativity { namespace cmdargs {

class ValidationTag {};

template <typename T>
class Validation : public ValidationTag {
    public:
        Validation(T v) : val_(v) {}
        operator const T& () const { return val_; }
        using value_type = T;
        static std::string validationString() {
            if (std::is_unsigned<T>::value) { return type_string<T>() + u8"⩾0"; }
            return type_string<T>();
        }
        virtual ~Validation() = default;

    protected:
        T val_;
};

template <typename T, long min, long denom = 1>
class Min : public virtual Validation<T> {
    public:
        Min(T v) : Validation<T>(v) {
            if (*this < min / (double) denom)
                throw boost::program_options::validation_error(boost::program_options::validation_error::invalid_option_value);
        }

        static std::string validationString() { return type_string<T>() + u8"⩾" + (denom == 1 ? output_string(min) : output_string(min / (double) denom)); }
};

template<typename T, long max, long denom = 1>
class Max : public virtual Validation<T> {
    public:
        Max(T v) : Validation<T>(v) {
            if (*this > max / (double) denom)
                throw boost::program_options::validation_error(boost::program_options::validation_error::invalid_option_value);
        }

        static std::string validationString() { return type_string<T>() + u8"⩽" + (denom == 1 ? output_string(max) : output_string(max / (double) denom)); }
};

template<typename T, long min, long max, long denom = 1>
class Range : public Min<T, min>, public Max<T, max> {
    public:
        Range(T v) : Validation<T>(v), Min<T, min, denom>(v), Max<T, max, denom>(v) {}

        static std::string validationString() { return (denom == 1 ? output_string(min) : output_string(min / (double) denom)) + u8"⩽" + type_string<T>() + u8"⩽" + (denom == 1 ? output_string(max) : output_string(max / (double) denom)); }
};

template <typename T, long lower, long denom = 1>
class Above : public virtual Validation<T> {
    public:
        Above(T v) : Validation<T>(v) {
            if (*this <= lower / (double) denom)
                throw boost::program_options::validation_error(boost::program_options::validation_error::invalid_option_value);
        }

        static std::string validationString() { return type_string<T>() + u8">" + (denom == 1 ? output_string(lower) : output_string(lower / (double) denom)); }
};

template <typename T, long upper, long denom = 1>
class Below : public virtual Validation<T> {
    public:
        Below(T v) : Validation<T>(v) {
            if (*this >= upper / (double) denom)
                throw boost::program_options::validation_error(boost::program_options::validation_error::invalid_option_value);
        }

        static std::string validationString() { return type_string<T>() + u8"<" + (denom == 1 ? output_string(upper) : output_string(upper / (double) denom)); }
};

template <class V, typename = typename std::enable_if<std::is_base_of<ValidationTag, V>::value>::type>
void validate(boost::any &v, const std::vector<std::string> &values, V*, int) {
    using namespace boost::program_options;

    // Check that this value hasn't already been assigned:
    validators::check_first_occurrence(v);
    // Check that only a single value was given, and get it:
    std::string s(validators::get_single_string(values));

    if (std::is_unsigned<typename V::value_type>::value and std::regex_search(s, std::regex("^\\s*-")))
        throw invalid_option_value(s);

    try {
        // First convert to the appropriate type (this will throw if that can't be done):
        auto val = boost::lexical_cast<typename V::value_type>(s);

        // The constructor here will throw if validation fails:
        v = boost::any(V(val));
    }
    catch (...) {
        throw invalid_option_value(s);
    }
}


}}