OptionalArgs.hxx

Go to the documentation of this file.

 
#ifndef _UTILS_OPTIONALARGS_HXX_
#define _UTILS_OPTIONALARGS_HXX_
 
template <typename DATA_TYPE, int N> class Fetcher
{
public:
    constexpr Fetcher()
    {
    }
};
 
template <typename DATA_TYPE, int N, DATA_TYPE defval> class Specifier
{
public:
    constexpr Specifier(const DATA_TYPE d)
        : d_(d)
    {
    }
 
    typedef Fetcher<DATA_TYPE, N> FetcherType;
    typedef DATA_TYPE data_type;
    static constexpr DATA_TYPE default_value()
    {
        return defval;
    }
    DATA_TYPE d_;
};
 
#define DECLARE_OPTIONALARG(SpecName, function_name, DataType, N, DEF)         \
    using SpecName = Specifier<DataType, N, (DEF)>;                            \
    using SpecName##Get = Fetcher<DataType, N>;                                \
    static constexpr int check_arguments_are_valid(const SpecName s)           \
    {                                                                          \
        return 0;                                                              \
    }
 
#define DEFINE_OPTIONALARG(SpecName, function_name, DataType)                  \
    constexpr DataType function_name() const                                   \
    {                                                                          \
        return get(SpecName##Get());                                           \
    }                                                                          \
    constexpr bool has_##function_name() const                                 \
    {                                                                          \
        return has(SpecName##Get());                                           \
    }
 
template <class Decl, typename... Args> class OptionalArg;
 
template <class Decl> class OptionalArg<Decl> : public Decl
{
public:
    template <typename... Args>
    constexpr OptionalArg(Args... args)
        : check_(check_all_args(args...))
    {
    }
 
    template <class FF> constexpr FF get(const FF f) const
    {
        return tried_to_get_unknown_argument() ? f : FF();
    }
 
    template <class FF> constexpr bool has(const FF f) const
    {
        return tried_to_get_unknown_argument();
    }
 
private:
    using Decl::check_arguments_are_valid;
    static constexpr int check_arguments_are_valid(const OptionalArg &a)
    {
        return 0;
    }
 
    template <typename A, typename... Args>
    static constexpr int check_all_args(const A a, Args... args)
    {
        return check_arguments_are_valid(a) + check_all_args(args...);
    }
 
    static constexpr int check_all_args()
    {
        return 0;
    }
 
    static bool tried_to_get_unknown_argument();
 
    const int check_;
};
 
template <typename Decl, typename Specifier, typename... TArgs>
class OptionalArg<Decl, Specifier, TArgs...>
    : public OptionalArg<Decl, TArgs...>
{
public:
    typedef Specifier specifier_type;
    typedef typename Specifier::FetcherType fetcher_type;
    typedef typename Specifier::data_type data_type;
    using Base = OptionalArg<Decl, TArgs...>;
 
    template <typename... Args>
    constexpr OptionalArg(Args... args)
        : Base(args...)
        , d_(GetFromArgs(args...))
        , has_(HasFromArgs(args...))
    {
    }
 
    constexpr OptionalArg()
        : d_(GetFromArgs())
        , has_(false)
    {
    }
 
    constexpr data_type get(const fetcher_type) const
    {
        return d_;
    }
 
    constexpr bool has(const fetcher_type) const
    {
        return has_;
    }
 
    using Base::get;
    using Base::has;
 
private:
    template <typename... Args>
    static constexpr data_type GetFromArgs(
        const specifier_type spec, Args... args)
    {
        return spec.d_;
    }
 
    template <typename... Args>
    static constexpr bool HasFromArgs(const specifier_type spec, Args... args)
    {
        return true;
    }
 
    template <typename U, typename... Args>
    static constexpr typename std::enable_if<
        std::is_convertible<typename std::add_lvalue_reference<U>::type,
            typename std::add_lvalue_reference<Base>::type>::value,
        data_type>::type
    GetFromArgs(const U me, Args... args)
    {
        return me.get(fetcher_type());
    }
    template <typename U, typename... Args>
    static constexpr typename std::enable_if<
        std::is_convertible<typename std::add_lvalue_reference<U>::type,
            typename std::add_lvalue_reference<Base>::type>::value,
        bool>::type
    HasFromArgs(const U me, Args... args)
    {
        return me.has(fetcher_type());
    }
 
    template <typename T, typename... Args>
    static constexpr typename std::enable_if<
        !std::is_convertible<typename std::add_lvalue_reference<T>::type,
            typename std::add_lvalue_reference<Base>::type>::value,
        data_type>::type
    GetFromArgs(const T t, Args... args)
    {
        return GetFromArgs(args...);
    }
    template <typename T, typename... Args>
    static constexpr typename std::enable_if<
        !std::is_convertible<typename std::add_lvalue_reference<T>::type,
            typename std::add_lvalue_reference<Base>::type>::value,
        bool>::type
    HasFromArgs(const T t, Args... args)
    {
        return HasFromArgs(args...);
    }
 
    static constexpr data_type GetFromArgs()
    {
        return specifier_type::default_value();
    }
    static constexpr bool HasFromArgs()
    {
        return false;
    }
 
    data_type d_;
    bool has_;
};
 
#endif // _UTILS_OPTIONALARGS_HXX_