cpphibernate/include/cpphibernate/schema/getter.h

#pragma once

#include <cpphibernate/config.h>
#include <cpphibernate/misc/general.h>

beg_namespace_cpphibernate_schema
{

    namespace __impl
    {

        /* getter_t */

        template<typename T_dataset, typename T_value>
        struct getter_t
        {
            using dataset_type  = T_dataset;
            using value_type    = T_value;
        };

        /* getter_member_var_t */

        template<typename T_dataset, typename T_value, typename T_member>
        struct getter_member_var_t
            : public getter_t<T_dataset, T_value>
        {
            using base_type     = getter_t<T_dataset, T_value>;
            using dataset_type  = typename base_type::dataset_type;
            using value_type    = typename base_type::value_type;
            using member_type   = T_member;

            member_type member;

            template<typename X_member>
            constexpr getter_member_var_t(X_member&& p_member)
                : member(std::forward<X_member>(p_member))
                { }

            cpphibernate_copyable(getter_member_var_t, delete);
            cpphibernate_moveable(getter_member_var_t, default);

            template<typename X_dataset>
            constexpr decltype(auto) operator()(X_dataset&& data) const
                { return std::forward<X_dataset>(data).*member; }
        };

        /* getter_member_func_t */

        template<typename T_dataset, typename T_value, typename T_member>
        struct getter_member_func_t
            : public getter_t<T_dataset, T_value>
        {
            using base_type     = getter_t<T_dataset, T_value>;
            using dataset_type  = typename base_type::dataset_type;
            using value_type    = typename base_type::value_type;
            using member_type   = T_member;

            member_type member;

            template<typename X_member>
            constexpr getter_member_func_t(X_member&& p_member)
                : member(std::forward<X_member>(p_member))
                { };

            cpphibernate_copyable(getter_member_func_t, delete);
            cpphibernate_moveable(getter_member_func_t, default);

            template<typename X_dataset>
            constexpr decltype(auto) operator()(X_dataset&& data) const
                { return (std::forward<X_dataset>(data).*member)(); }
        };

        /* getter_lambda_t */

        template<typename T_lambda, typename T_dataset, typename T_value>
        struct getter_lambda_t
            : public getter_t<T_dataset, T_value>
        {
            using base_type     = getter_t<T_dataset, T_value>;
            using dataset_type  = typename base_type::dataset_type;
            using value_type    = typename base_type::value_type;
            using lambda_type   = T_lambda;

            lambda_type lambda;

            template<typename X_lambda>
            constexpr getter_lambda_t(X_lambda&& p_lambda)
                : lambda(std::forward<X_lambda>(p_lambda))
                { }

            cpphibernate_copyable(getter_lambda_t, delete);
            cpphibernate_moveable(getter_lambda_t, default);

            template<typename X_dataset>
            constexpr decltype(auto) operator()(X_dataset&& data) const
                { return lambda(std::forward<X_dataset>(data)); }
        };

        /* is_getter_impl */

        template<typename T, typename = void>
        struct is_getter_impl
            : public mp::c_false_t
            { };

        template<typename T>
        struct is_getter_impl<T, mp::enable_if<
                mp::is_base_of<getter_t<typename T::dataset_type, typename T::value_type>, T>>>
            : public mp::c_true_t
            { };

    }

    /* meta */

    template<typename T>
    struct is_getter :
        public __impl::is_getter_impl<T>
        { };

    /* make */

    template<typename T_dataset, typename T_value>
    constexpr decltype(auto) make_getter_member_var(T_value T_dataset::* member)
    {
        using getter_type = __impl::getter_member_var_t<T_dataset, T_value, T_value T_dataset::*>;
        return getter_type(member);
    }

    template<typename T_dataset, typename T_value>
    constexpr decltype(auto) make_getter_member_func(T_value (T_dataset::*member)())
    {
        using getter_type = __impl::getter_member_func_t<T_dataset, T_value, T_value (T_dataset::*)()>;
        return getter_type(member);
    }

    template<typename T_dataset, typename T_value>
    constexpr decltype(auto) make_getter_member_func(T_value (T_dataset::*member)() const)
    {
        using getter_type = __impl::getter_member_func_t<const T_dataset, T_value, T_value (T_dataset::*)() const>;
        return getter_type(member);
    }

    template<typename T_lambda, typename T_wrapped_dataset, typename T_wrapped_value>
    constexpr decltype(auto) make_getter_lambda(T_lambda&& lambda, T_wrapped_dataset&&, T_wrapped_value&&)
    {
        using getter_type = __impl::getter_lambda_t<T_lambda, misc::decay_unwrap_t<T_wrapped_dataset>, misc::decay_unwrap_t<T_wrapped_value>>;
        return getter_type(std::forward<T_lambda>(lambda));
    }

    /* operations */

    namespace __impl
    {

        /* getter_make_impl */

        struct getter_make_impl
        {
            template<typename T_dataset, typename T_value>
            constexpr decltype(auto) operator()(T_value T_dataset::*member) const
                { return make_getter_member_var(member); }

            template<typename T_dataset, typename T_value>
            constexpr decltype(auto) operator()(T_value (T_dataset::*member)(void)) const
                { return make_getter_member_func(member); }

            template<typename T_dataset, typename T_value>
            constexpr decltype(auto) operator()(T_value (T_dataset::*member)(void) const) const
                { return make_getter_member_func(member); }

            template<typename T_func, typename T_dataset, typename T_value>
            constexpr decltype(auto) operator()(T_func&& func, hana::type<T_dataset>&& wrapped_dataset, hana::type<T_value>&& wrapped_value) const
                { return make_getter_lambda(std::forward<T_func>(func), std::forward<hana::type<T_dataset>>(wrapped_dataset), std::forward<hana::type<T_value>>(wrapped_value)); }

            template<typename T_getter>
            constexpr auto operator()(T_getter&& getter) const
                -> mp::enable_if<is_getter<T_getter>, T_getter>
                { return std::forward<T_getter>(getter); }
        };

    }

    namespace getter
    {

        constexpr decltype(auto) make = __impl::getter_make_impl { };

    }

}
end_namespace_cpphibernate_schema