cppmp/include/cppmp/misc/getter.inl

#pragma once

#include <cppmp/core/modifier.h>
#include <cppmp/traits/lambda_traits.h>

#include "getter.h"

namespace cppmp
{

    namespace __impl
    {

        /* getter_builder - default */

        template<typename X, typename>
        struct getter_builder
        {
            using is_default = cppmp::true_t;

            template<typename... T_args>
            static constexpr decltype(auto) apply(T_args&&...)
                { static_assert(sizeof...(T_args) == -1, "Invalid parameters for make_getter(...)!"); }
        };

        /* getter_builder - redirect existing getter */

        template<typename T_getter>
        struct getter_builder<
            list<T_getter>,
            enable_if_t<is_getter<decay_t<T_getter>>::value
        >>
        {
            static constexpr decltype(auto) apply(T_getter&& getter)
                { return std::forward<T_getter>(getter); }
        };

        /* getter_builder - member variable */

        template<typename T_object, typename T_value>
        struct getter_builder<
            list<T_value T_object::*>,
            enable_if_t<
                !is_valid<lambda_traits<T_value T_object::*>>::value
            >
        >
        {
            struct getter_member_var
                : public tag_getter
                , public tag_getter_member_var
            {
                using object_type = T_object;
                using value_type  = T_value;
                using member_type = value_type object_type::*;

                member_type member;

                inline  getter_member_var(member_type p_member)
                    : member(p_member)
                    { }

                inline getter_member_var(getter_member_var&&) = default;
                inline getter_member_var(const getter_member_var&) = default;

                inline getter_member_var& operator = (getter_member_var&&) = default;
                inline getter_member_var& operator = (const getter_member_var&) = default;

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

            using object_type = T_object;
            using value_type  = T_value;
            using member_type = value_type object_type::*;

            static constexpr decltype(auto) apply(member_type&& getter)
                { return getter_member_var(std::forward<member_type>(getter)); }
        };

        /* getter_builder - member function */

        template<typename T_object, typename T_value, typename T_member>
        struct getter_builder_member_func
        {
            struct getter_member_func
                : public tag_getter
                , public tag_getter_member_func
            {
                using object_type = T_object;
                using value_type  = T_value;
                using member_type = T_member;

                member_type member;

                inline getter_member_func(member_type p_member)
                    : member(p_member)
                    { }

                inline getter_member_func(getter_member_func&&) = default;
                inline getter_member_func(const getter_member_func&) = default;

                inline getter_member_func& operator = (getter_member_func&&) = default;
                inline getter_member_func& operator = (const getter_member_func&) = default;

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

            using object_type = T_object;
            using value_type  = T_value;
            using member_type = T_member;

            static constexpr decltype(auto) apply(member_type&& getter)
                { return getter_member_func(std::forward<member_type>(getter)); }
        };

        template<typename T_object, typename T_value>
        struct getter_builder<
            list<T_value (T_object::*)()>,
            void>
            : public getter_builder_member_func<T_object, T_value, T_value (T_object::*)()>
            { };

        template<typename T_object, typename T_value>
        struct getter_builder<
            list<T_value (T_object::*)() const>,
            void>
            : public getter_builder_member_func<const T_object, T_value, T_value (T_object::*)() const>
            { };

        /* getter_builder - lambda/static */

        template<typename T_lambda>
        struct getter_builder<
            list<T_lambda>,
            enable_if_t<
                    is_valid<lambda_traits<decay_t<T_lambda>>>::value
                &&  lambda_traits<decay_t<T_lambda>>::argument_count_v == 1
                && !is_void<typename lambda_traits<decay_t<T_lambda>>::return_type>::value
            >
        >
        {
            struct getter_lambda
                : public tag_getter
                , public tag_getter_lambda
            {
                using lambda_type        = T_lambda;
                using lambda_traits_type = lambda_traits<lambda_type>;
                using object_type        = typename lambda_traits_type::template argument_t<0>;
                using value_type         = typename lambda_traits_type::return_type;

                lambda_type lambda;

                inline getter_lambda(lambda_type&& p_lambda)
                    : lambda(std::forward<lambda_type>(p_lambda))
                    { }

                inline getter_lambda(getter_lambda&&) = default;
                inline  getter_lambda(const getter_lambda&) = default;

                inline getter_lambda& operator = (getter_lambda&&) = default;
                inline getter_lambda& operator = (const getter_lambda&) = default;

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

            using lambda_type = T_lambda;

            static constexpr decltype(auto) apply(lambda_type&& lambda)
                { return getter_lambda(std::forward<lambda_type>(lambda)); }
        };

        /* getter_builder - chain */

        template<typename T_first, typename T_second, typename... T_rest>
        struct getter_builder<
            list<T_first, T_second, T_rest...>,
            enable_if_t<
                    is_valid<decltype(make_getter(std::declval<T_first>()))>::value
                &&  is_valid<decltype(make_getter(std::declval<T_second>(), std::declval<T_rest>()...))>::value
            >
        >
        {
            struct getter_chain
                : public tag_getter
                , public tag_getter_chain
            {
                using first_getter_type  = decltype(make_getter(std::declval<T_first>()));
                using second_getter_type = decltype(make_getter(std::declval<T_second>(), std::declval<T_rest>()...));
                using object_type        = typename first_getter_type::object_type;
                using value_type         = typename second_getter_type::value_type;;

                first_getter_type   first;
                second_getter_type  second;

                inline getter_chain(
                    first_getter_type&&     p_first,
                    second_getter_type&&    p_second)
                    : first (std::move(p_first))
                    , second(std::move(p_second))
                    { }

                inline getter_chain(getter_chain&&) = default;
                inline getter_chain(const getter_chain&) = default;

                inline getter_chain& operator = (getter_chain&&) = default;
                inline getter_chain& operator = (const getter_chain&) = default;

                template<typename X_object>
                constexpr decltype(auto) operator()(X_object&& obj) const
                    { return second(first(std::forward<X_object>(obj))); }
            };

            template<typename X_first, typename... X_rest>
            static constexpr decltype(auto) apply(X_first&& first, X_rest&&... rest)
            {
                return getter_chain(
                    make_getter(std::forward<X_first>(first)),
                    make_getter(std::forward<X_rest>(rest)...));
            }
        };

    }

    /* is_getter */

    template<typename T>
    struct is_getter
        : public is_base_of<tag_getter, T>
        { };

}