options.h

#pragma once
 
#include <boost/hana/is_empty.hpp>
#include <boost/hana/tuple.hpp>
#include <boost/hana/fold.hpp>
#include <boost/hana/concat.hpp>
#include <boost/hana/map.hpp>
 
namespace ozo {
 
namespace hana = boost::hana;
 
template <typename Key>
struct option : hana::type<Key> {
    template <typename T>
    constexpr auto operator = (T&& v) const {
        return hana::make_pair(*this, std::forward<T>(v));
    }
};
 
template <typename Map, typename Key>
constexpr decltype(auto) get_option(Map&& map, ozo::option<Key> op) {
    static_assert(decltype(hana::is_a<hana::map_tag>(map))::value, "Map should be boost::hana::map");
    static_assert(decltype(hana::contains(map, op))::value, "option has not been found");
    return map[op];
}
 
template <typename Map, typename Key, typename T>
constexpr decltype(auto) get_option(Map&& map, ozo::option<Key> op, T&& default_) {
    static_assert(decltype(hana::is_a<hana::map_tag>(map))::value, "Map should be boost::hana::map");
    if constexpr (decltype(hana::contains(map, op))::value) {
        return map[op];
    } else {
        return std::forward<T>(default_);
    }
}
 
template <typename ...Options>
constexpr auto make_options(Options&& ...opts) {
    return hana::make_map(std::forward<Options>(opts)...);
}
 
template <typename RealType, typename Options>
class options_factory_base {
    Options v_;
 
    template <typename OtherOptions>
    constexpr static auto rebind(OtherOptions&& v) {
        return RealType::rebind_options(std::forward<OtherOptions>(v));
    }
 
public:
    constexpr options_factory_base(Options v) : v_(std::move(v)) {
        static_assert(decltype(hana::is_a<hana::map_tag>(v))::value, "Options should be boost::hana::map");
    }
 
#ifdef OZO_DOCUMENTATION
    template <typename Options>
    constexpr decltype(auto) set(Options&& ...options) &&;
#endif
    template <typename Key, typename T>
    constexpr decltype(auto) set(hana::pair<ozo::option<Key>, T> v) && {
        if constexpr (decltype(has(hana::first(v)))::value) {
            v_[hana::first(v)] = std::move(hana::second(std::move(v)));
            return static_cast<RealType&&>(*this);
        } else {
            return rebind(hana::insert(std::move(v_), std::move(v)));
        }
    }
 
    template <typename Key1, typename T1, typename Key2, typename T2, typename ...Ts>
    constexpr decltype(auto) set(hana::pair<ozo::option<Key1>, T1> v1, hana::pair<ozo::option<Key2>, T2> v2, Ts ...vs) && {
        return hana::fold(
            hana::make_tuple(std::move(v1), std::move(v2), std::move(vs)...),
            std::move(*this),
            [](auto self, auto v) { return std::move(self).set(v);}
        );
    }
 
    template <typename Key, typename T, typename ...Ts>
    constexpr decltype(auto) set(hana::pair<ozo::option<Key>, T> v, Ts ...vs) const & {
        auto copy = *this;
        return std::move(copy).set(std::move(v), std::move(vs)...);
    }
 
    template <typename Key, typename T>
    constexpr decltype(auto) set(ozo::option<Key> op, T&& value) && {
        return std::move(*this).set(hana::make_pair(op, std::forward<T>(value)));
    }
 
    template <typename Key, typename T>
    constexpr decltype(auto) set(ozo::option<Key> op, T&& value) const & {
        return set(hana::make_pair(op, std::forward<T>(value)));
    }
 
    template <typename Key>
    constexpr auto has(ozo::option<Key> op) const {
        return hana::contains(options(), op);
    }
 
    template <typename Key>
    constexpr decltype(auto) get(ozo::option<Key> op) const {
        return get_option(options(), op);
    }
 
    constexpr const Options& options() const & { return v_;}
    constexpr Options& options() & { return v_;}
    constexpr Options&& options() && { return std::move(v_);}
};
 
template <typename Options = decltype(hana::make_map())>
class options_factory : public ozo::options_factory_base<options_factory<Options>, Options> {
    using base = ozo::options_factory_base<options_factory<Options>, Options>;
    friend class ozo::options_factory_base<options_factory<Options>, Options>;
 
    template <typename OtherOptions>
    constexpr static auto rebind_options(OtherOptions&& options) {
        return options_factory<std::decay_t<OtherOptions>>(std::forward<OtherOptions>(options));
    }
 
public:
    constexpr options_factory(Options options = Options{}) : base(std::move(options)) {
        options_factory(decltype(hana::is_a<hana::map_tag>(options))::value, "Options should be boost::hana::map");
    }
};
 
} // namespace ozo