member.hpp

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: © 2025 Larry Chips <larry@larrychips.net>
 * SPDX-Licence-Identifier: MIT
 */
#ifndef UGMISC_MEMBER_HPP
#define UGMISC_MEMBER_HPP

 
#include "ugmisc/typelist.hpp"
#include <functional>
#include <utility>
 
 
 
 
#ifdef UGMISC_DOCS
#error
#endif
 
 
 

#define UGMISC_DECL_MEMBER_ACCESS(TNAME, NAME) \
class TNAME { \
    struct ugmisc_priv { \
        /* Static method call support. */ \
        \
        template<class ugmisc__T, class, class...ugmisc__A> \
        struct static_caller_as_function { \
            static constexpr bool is_callable = false; \
        }; \
        \
        template<class ugmisc__T, class...ugmisc__A> \
        struct static_caller_as_function<ugmisc__T, std::void_t<decltype(ugmisc__T::NAME(std::declval<ugmisc__A>()...))>, ugmisc__A...> { \
            static constexpr bool is_callable = true; \
            \
            static constexpr decltype(auto) call(ugmisc__A...args) { \
                return ugmisc__T::NAME(std::forward<ugmisc__A>(args)...); \
            } \
        }; \
        \
        template<class ugmisc__T, bool, class...ugmisc__A> \
        struct static_caller_as_invoke { \
            static constexpr bool is_callable = false; \
        }; \
        \
        template<class ugmisc__T, class...ugmisc__A> \
        struct static_caller_as_invoke<ugmisc__T, std::is_invocable_v<decltype((ugmisc__T::NAME)), ugmisc__A...>, ugmisc__A...> { \
            static constexpr bool is_callable = true; \
            \
            static constexpr decltype(auto) call(ugmisc__A...args) { \
                return std::invoke(ugmisc__T::NAME, std::forward<ugmisc__A>(args)...); \
            } \
        }; \
        \
        template<class ugmisc__T, class...ugmisc__A> \
        using static_caller = std::conditional_t< \
            static_caller_as_function<ugmisc__T, void, ugmisc__A...>::is_callable, \
            static_caller_as_function<ugmisc__T, void, ugmisc__A...>, \
            static_caller_as_invoke<ugmisc__T, true, ugmisc__A...> \
        >; \
        \
        /* Non static method call support. */ \
        \
        template<class ugmisc__T, class, class...ugmisc__A> \
        struct caller_as_method { \
            static constexpr bool is_callable = false; \
        }; \
        \
        template<class ugmisc__T, class...ugmisc__A> \
        struct caller_as_method<ugmisc__T, std::void_t<decltype(std::declval<ugmisc__T>().NAME(std::declval<ugmisc__A>()...))>, ugmisc__A...> { \
            static constexpr bool is_callable = true; \
            \
            static constexpr decltype(auto) call(ugmisc__T& obj, ugmisc__A...args) { \
                return std::forward<ugmisc__T>(obj).NAME(std::forward<ugmisc__A>(args)...); \
            } \
        }; \
        \
        template<class ugmisc__T, bool I, class...ugmisc__A> \
        struct caller_as_invoke { \
            static constexpr bool is_callable = false; \
        }; \
        \
        template<class ugmisc__T, class...ugmisc__A> \
        struct caller_as_invoke<ugmisc__T, \
            std::is_invocable_v<decltype(std::declval<ugmisc__T>().NAME), ugmisc__A...>, \
            ugmisc__A... \
        > \
        { \
            static constexpr bool is_callable = true; \
            static constexpr decltype(auto) call(ugmisc__T& obj, ugmisc__A...args) { \
                return std::invoke(std::forward<ugmisc__T>(obj).NAME, std::forward<ugmisc__A>(args)...); \
            } \
        }; \
        \
        template<class ugmisc__T, class...ugmisc__A> \
        using caller = std::conditional_t< \
            caller_as_method<ugmisc__T, void, ugmisc__A...>::is_callable, \
            caller_as_method<ugmisc__T, void, ugmisc__A...>, \
            caller_as_invoke<ugmisc__T, true, ugmisc__A...> \
            >; \
        /* Static data reference support. */ \
        \
        template<class ugmisc__T, class=void> \
        struct static_member { \
            static constexpr bool has_member = false; \
        }; \
        \
        template<class ugmisc__T> \
        struct static_member<ugmisc__T, std::void_t<decltype(ugmisc__T::NAME)>> { \
            static constexpr bool has_member = true; \
            \
            static constexpr auto& get() { \
                return ugmisc__T::NAME; \
            } \
        }; \
        \
        /* Non static data reference support. */ \
        \
        template<class ugmisc__T, class=void> \
        struct member { \
            static constexpr bool has_member = false; \
        }; \
        \
        template<class ugmisc__T> \
        struct member<ugmisc__T, std::void_t<decltype(std::declval<ugmisc__T>().NAME)>> { \
            static constexpr bool has_member = true; \
            \
            static constexpr auto& get(ugmisc__T& obj) { \
                return obj.NAME; \
            } \
            \
            using member_type = decltype(std::declval<std::remove_reference_t<ugmisc__T>>().NAME); \
        }; \
        /* Type support. */ \
        \
        template< class ugmisc__T, class=void > struct GetType { \
            static constexpr bool has_member_type = false; \
            using safe_type = void; \
        }; \
        \
        template< class ugmisc__T > struct GetType< ugmisc__T, std::void_t< typename ugmisc__T::NAME > > { \
            static constexpr bool has_member_type = true; \
            using safe_type = typename ugmisc__T::NAME; \
            using type = typename ugmisc__T::NAME; \
        }; \
        \
    }; \
public: \
    struct ugmisc { \
        /* Static method call. */ \
        template<class ugmisc__T, class...ugmisc__A> static constexpr bool is_static_callable = \
            ugmisc_priv::template static_caller<ugmisc__T, ugmisc__A...>::is_callable; \
        \
        template<class ugmisc__T, class...ugmisc__A> \
        static constexpr auto static_call(ugmisc__A&&...args) \
        -> decltype( \
                ugmisc_priv::template static_caller<ugmisc__T, ugmisc__A...>::call( \
                    std::forward<ugmisc__A>(args)... \
                    )) \
        { \
            return ugmisc_priv::template static_caller<ugmisc__T, ugmisc__A...>::call( \
                    std::forward<ugmisc__A>(args)... \
                    ); \
        } \
        \
        /* Non static method call. */ \
        template<class ugmisc__T, class...ugmisc__A> static constexpr bool is_callable = \
            ugmisc_priv::template caller<ugmisc__T, ugmisc__A...>::is_callable; \
        \
        template<class ugmisc__T, class...ugmisc__A> \
        static constexpr auto call(ugmisc__T& obj, ugmisc__A&&...args) \
        -> decltype( \
                ugmisc_priv::template caller<ugmisc__T, ugmisc__A...>::call( \
                    obj,  \
                    std::forward<ugmisc__A>(args)... \
                    )) \
        { \
            return ugmisc_priv::template caller<ugmisc__T, ugmisc__A...>::call( \
                    obj, \
                    std::forward<ugmisc__A>(args)... \
                    ); \
        } \
        \
        /* Static member reference. */ \
        template< class ugmisc__T > \
        static constexpr bool has_static_member \
            = ugmisc_priv::template static_member<ugmisc__T>::has_member; \
        template< class ugmisc__T> \
        static constexpr auto& static_get() { \
            return ugmisc_priv::template static_member<ugmisc__T>::get(); \
        } \
        \
        /* Non static member reference. */ \
        template< class ugmisc__T > \
        static constexpr bool has_member \
            = ugmisc_priv::template member<ugmisc__T>::has_member; \
        template< class ugmisc__T > \
        using member_type = typename ugmisc_priv::member<ugmisc__T>::member_type; \
        template< class ugmisc__T> \
        static constexpr auto& get(ugmisc__T&& obj) { \
            return ugmisc_priv::template member<ugmisc__T>::get(obj); \
        } \
        \
        /* Type. */ \
        \
        template< class ugmisc__T > using type = typename ugmisc_priv::GetType<ugmisc__T>::type; \
        template< class ugmisc__T > using safe_type = \
            typename ugmisc_priv::GetType<ugmisc__T>::safe_type; \
        template< class ugmisc__T > static constexpr bool has_member_type = \
            ugmisc_priv::template GetType<ugmisc__T>::has_member_type; \
    }; \
}
 
 
 
 
namespace ugmisc {
 
 
 

template<class T>
struct default_type {
    using type = T;
};
 
 
 

namespace member_ {
 
 
template<class V, class F, class...A>
struct can_simple_call : public std::false_type {};
 
template<class F, class...A>
struct can_simple_call< std::void_t<decltype(std::declval<F>()(std::declval<A>()...))>, F, A...> : public std::true_type {};
 
template<class F, class...A>
constexpr bool can_simple_call_v = can_simple_call<void, F, A...>::value;
 
 
/*
 * In C++17, we prefer the "direct" way to invoke a callable when it isn't a
 * pointer to member, because std::invoke is not yet constexpr.
 */
template<class F, class...A>
constexpr auto invoke(F&& func, A&&...args)
-> std::invoke_result_t<F, A...>
{
#ifdef UGMISC_CXX_20
    // C++20 std::invoke is constexpr.
    return std::invoke(std::forward<F>(func), std::forward<A>(args)...);
#else
    // Don't actually try to implement constexpr std::invoke here.
    // This isn't a replacement STL.
    if constexpr ( can_simple_call_v<F, A...> ) {
        return std::forward<F>(func)(std::forward<A>(args)...);
    } else {
        return std::invoke(std::forward<F>(func), std::forward<A>(args)...);
    }
#endif
}
 
 
template<class T>
struct get_is_default_type : public std::false_type {};
 
template<class T>
struct get_is_default_type< default_type<T> > : public std::true_type {};
 
template<class T>
struct get_is_not_default_type {
    using type = bool;
    static constexpr bool value = !get_is_default_type<T>::value;
};
 
template<class T> static inline bool is_default_type =
    get_is_default_type<T>::value;
 
 
 

template<class StaticCaller, class Functor>
class fallback_caller {
    Functor m_functor;
 
    /*
     * The use of Dummy* for the first override and Dummy for the second, makes
     * the first more specific.
     */
    template<class Dummy, class...T>
    constexpr auto forward(Dummy*, T&&...args) const
    -> decltype(invoke(m_functor, std::forward<T>(args)...))
    {
        return invoke(m_functor, std::forward<T>(args)...);
    }
 
    template<class Dummy, class...T>
    constexpr decltype(auto) forward(Dummy, T&&...args) const {
        return m_functor();
    }
 
 
public:
    constexpr fallback_caller(Functor f) : m_functor(std::forward<Functor>(f)) {}
 
    fallback_caller(fallback_caller&&) = default;
    fallback_caller(const fallback_caller&) = delete;
 
    template<class...T>
    constexpr decltype(auto) call(T&&...args) const {
        if constexpr ( StaticCaller::template is_matched_v<T...> ) {
            return StaticCaller::call(std::forward<T>(args)...);
        } else {
            auto dummy = (int*)nullptr;
            return forward(dummy, std::forward<T>(args)...);
        }
    }
 
    template<class...T>
    constexpr decltype(auto) operator()(T&&...args) const {
        return call(std::forward<T>(args)...);
    }
};
 
 
template<class Access, class T, class...A>
inline constexpr bool is_static_callable_v =
    Access::ugmisc::template is_static_callable<T, A...>;
 
 
template<class Access, class T, class...A>
constexpr bool is_static_callable(A&&...) {
    return is_static_callable_v<Access, T, A...>;
}
 
 
} /* member_ (::ugmisc::member_) */
 
 

template<class Access, class...T>
struct static_member_caller {
private:
    template<class V, class List, class...Args>
    struct caller
    : public caller<V, type_list_remove_prefix<1, List>, Args...> {
    };
 
    template<class...Args> struct caller<void, type_list<>, Args...> {
        static constexpr bool is_callable = false;
        using safe_type = void;
    };
 
    template<class List, class...Args>
    struct caller<
        std::enable_if_t< member_::is_static_callable_v<Access, type_list_member<0, List>, Args...>>,
        List,
        Args...
        >
    {
        static constexpr bool is_callable = true;
        using type = type_list_member<0, List>;
        using safe_type = void;
    };
 
    using types_list = flatten_t<T...>;
 
public:
    template<class...Args>
    static constexpr bool is_matched_v =
        caller<void, types_list, Args...>::is_callable;

    template<class...Args>
    static constexpr bool is_matched(Args&&...) {
        return is_matched_v<Args...>;
    }

    template<class...Args>
    using matched_type = typename caller<void, types_list, Args...>::type;

    template<class...Args>
    using safe_matched_type =
        typename caller<void, types_list, Args...>::safe_type;

    template<class...Args>
    static constexpr decltype(auto) call(Args&&...args) {
        using type = matched_type<Args...>;
        static_assert(
                is_matched_v<Args...>,
                "None of the types is callable with these argument types."
                );
        return Access::ugmisc::template static_call<type>(std::forward<Args>(args)...);
    }

    template<class...Args>
    constexpr decltype(auto) operator()(Args&&...args) const {
        return call(std::forward<Args>(args)...);
    }

    template<class F>
    static constexpr
    member_::fallback_caller<static_member_caller, F>
    fallback(F&& functor) {
        return functor;
    }

    template<class...Args>
    static matched_type<Args...> declval_matched(Args&&...) noexcept;

    template<class...Args>
    static matched_type<Args...> declval_matched() noexcept;

    template<class...Args>
    static safe_matched_type<Args...> safe_declval_matched(Args&&...) noexcept;

    template<class...Args>
    static safe_matched_type<Args...> safe_declval_matched() noexcept;
};
 
 
 

template<class Access>
struct member_caller {
private:
    /*
     * A wrapped objects instance contains references to objects.
     * It only exists briefly.  It is instantiated explicitly, because we want
     * to know which objects were originally lvalues (those will be passed as
     * reference types).
     * However we always store references to the objects.
     */
    template<class...T>
    struct wrapped_objects_base {
    protected:
        static_assert(
            sizeof...(T) == 0,
            "A specialisation should have been used instead of this template."
            );
 
        template<class...A> static constexpr bool is_matched_v = false;
        template<class...A> static constexpr bool is_matched(A&&...) {
            return false;
        }
 
        wrapped_objects_base() = default;
        wrapped_objects_base(const wrapped_objects_base&) = default;
 
        template<class...A>
        constexpr void call(A&&...) const {
            static_assert(false, "There are no more objects to call.");
        }
 
        static constexpr bool safe_refs = true;
 
        template<class...A>
        static constexpr bool matched_here = false;
    };
 
    template<class T1, class...T>
    struct wrapped_objects_base<T1, T...> : public wrapped_objects_base<T...>
    {
    private:
        T1& obj_ref;
 
    protected:
        static constexpr bool safe_refs =
            std::is_lvalue_reference_v<T1> &&
            wrapped_objects_base<T...>::safe_refs;
            ;
 
        template<class...A>
        static constexpr bool matched_here =
            Access::ugmisc::template is_callable<T1, A...>;
 
        template<class...A>
        constexpr decltype(auto) call(A&&...args) const {
            if constexpr ( matched_here<A...> ) {
                return Access::ugmisc::template call(
                        obj_ref,
                        std::forward<A>(args)...
                        );
            } else {
                return this->wrapped_objects_base<T...>::call(std::forward<A>(args)...);
            }
        }
 
    public:
        constexpr wrapped_objects_base(T1& obj, T&...t)
            : wrapped_objects_base<T...>(t...), obj_ref(obj)
        {}
 
        wrapped_objects_base(wrapped_objects_base&&) = default;
 
        constexpr wrapped_objects_base(const wrapped_objects_base& other)
            : wrapped_objects_base<T...>((wrapped_objects_base<T...>)other),
            obj_ref(other.obj_ref)
        {
            static_assert(
                safe_refs,
                "Can't copy a member_caller::wrapped_objects if the "
                "referenced objects aren't all lvalues."
                );
        }
 
        template<class...A>
        static constexpr bool is_matched_v =
            matched_here<A...> ||
            wrapped_objects_base<T...>::template matched_here<A...>;
 
        template<class...A>
        static constexpr bool is_matched(A&&...) {
            return is_matched_v<A...>;
        }
    };
 
    /*
     * wrapped_objects with a functor is like wrapped_objects without one, but
     * it will default to calling the functor.
     */
    template<class F, class...T>
    class wrapped_objects : public wrapped_objects<void, T...> {
        F functor;
        using wrapped_objects<void, T...>::wrapped_objects;
 
        template<class, class...A> struct forwarder {
            static constexpr decltype(auto) call(F& f, A&...args) {
                return f();
            }
        };
 
        template<class...A>
        struct forwarder<
            std::void_t< decltype(member_::invoke(std::declval<F&>(), std::declval<A>()...)) >,
            A...
            >
        {
            static constexpr decltype(auto) call(F& f, A&...args) {
                return member_::invoke(f, std::forward<A>(args)...);
            }
        };
 
        template<class...A>
        constexpr decltype(auto) call_default(A&&...args) {
            return forwarder<void, A...>::call(functor, args...);
        }
 
    public:
        constexpr wrapped_objects(F f, T...t)
            : wrapped_objects<void, T...>(t...),
            functor(std::forward<F>(f))
        {}
 
        template<class...A>
        constexpr decltype(auto) operator()(A&&...args) {
            if constexpr ( wrapped_objects::template is_matched_v<A...> ) {
                return this->call( std::forward<A>(args)... );
            } else {
                return call_default(std::forward<A>(args)...);
            }
        }
    };
 
    template<class...T>
    class wrapped_objects<void, T...> : public wrapped_objects_base<T...> {
    public:
        using wrapped_objects_base<T...>::wrapped_objects_base;
 
        template<class...A>
        constexpr decltype(auto) operator() (A&&...args) const {
            return
            this->call(std::forward<A>(args)...);
        }
    };
 
    /*
     * This only has the job of creating a wrapped_objects.
     * It is intended to be a short lived object.  Where possible it is
     * instanciated with a reference type, so the member functor is declared as
     * a reference.
     */
    template<class F>
    class default_function {
        F functor;
    public:
        constexpr default_function(F f) : functor(std::forward<F>(f)) {}
        default_function(default_function&&) = default;
        default_function(const default_function&) = delete;
 
        template<class...T>
        constexpr wrapped_objects<F, T...> operator() (T&&...objs) const {
            return {functor, objs...};
        }
    };
 
public:
    /*
     * The public methods are static because member_caller itself holds all its
     * defining characteristics in its type.
     */

    template<class F>
    static constexpr default_function<F> fallback(F&& f) { return f; }

    template<class...T>
    static constexpr wrapped_objects<void, T...> with(T&&...objs) {
        return {objs...};
    }
 
    template<class...T>
    constexpr auto operator() (T&&...objs) const { return with<T...>(objs...); }
};
 
 
 

enum member_value_copy {
    MEMBER_COPY_AUTO, 
    MEMBER_COPY_NEVER, 
    MEMBER_COPY_ALWAYS 
};
 
 
 

template<class Access, member_value_copy CopyValue = MEMBER_COPY_AUTO>
struct member_value {
    static_assert(
            (CopyValue == MEMBER_COPY_AUTO) ||
            (CopyValue == MEMBER_COPY_ALWAYS) ||
            (CopyValue == MEMBER_COPY_NEVER)
            );
private:
    struct empty {
 
        template<class F, class...A>
        constexpr decltype(auto) get(F&& func, A&&...args) const {
            /*
             * We could get away with directly using std::invoke here but it
             * already works and I don't want to touch it.
             */
            return member_::invoke(
                    std::forward<F>(func), std::forward<A>(args)...
                    );
        }
 
        static constexpr bool has_member = false;
 
        constexpr void get() const {
            static_assert(
                    false,
                    "Can't get member that was not found in any object."
                    );
        }
 
        template<class...T>
        constexpr decltype(auto) operator() (T&&...args) const {
            return get(std::forward<T>(args)...);
        }
    };
 
    template<class T>
    class wrapped_object_member {
        using object_type = T;
 
        // The actual type of the member, as declared in T's definition.
        using member_type = typename Access::ugmisc::template member_type<T>;
 
        using effective_member_type =
            decltype(Access::ugmisc::get(std::declval<T&>()));
 
        using deref_effective_member_type =
            std::remove_reference_t<effective_member_type>;
 
        static constexpr bool rvalue_object =
            !std::is_lvalue_reference_v<object_type>;
 
        static constexpr bool const_object =
            std::is_const_v<object_type>;
 
        static constexpr bool volatile_object =
            std::is_volatile_v<object_type>;
 
        static constexpr bool member_is_reference =
            std::is_lvalue_reference_v<member_type>;
 
        static constexpr bool volatile_member =
            std::is_volatile_v<deref_effective_member_type>;
 
        static constexpr bool const_member =
            std::is_const_v<deref_effective_member_type>;
 
        static constexpr bool rvalue_member =
            (! member_is_reference) && rvalue_object;
 
        /*
         * copy_member == true: the member value is copied into the wrapper,
         * and returned by copy from get().
         */
        static constexpr bool copy_member =
            (CopyValue == MEMBER_COPY_ALWAYS)
            || (
                (CopyValue != MEMBER_COPY_NEVER)
                && (!volatile_member)
                && (const_member || rvalue_member)
                && std::is_trivially_copyable_v< member_type >
                );
 
        /*
         * return rvalue_member == true: a reference to the member is stored,
         * and an rvalue reference is returned from get().
         */
        static constexpr bool return_rvalue_member =
            (!copy_member) && rvalue_member;
 
        static constexpr bool return_lvalue_member =
            (!return_rvalue_member || copy_member);
 
        using member_store_type = std::conditional_t<
            copy_member,
            const std::remove_volatile_t<deref_effective_member_type>,
            effective_member_type
            >;
 
        using member_return_type = std::conditional_t<
            copy_member,
            std::remove_const_t<member_store_type>,
            std::conditional_t<
                return_rvalue_member,
                deref_effective_member_type&&,
                deref_effective_member_type&
                >
            >;
 
        // This may be a copy of the member's value where that is safe to do.
        // Otherwise it is a reference to the member.
        member_store_type member;
    public:
        static constexpr bool has_member = true;
 
        constexpr wrapped_object_member( object_type& obj )
            : member( Access::ugmisc::get(obj) )
        {}
 
        wrapped_object_member(const wrapped_object_member&) = default;
        wrapped_object_member(wrapped_object_member&&) = default;
 
        template<class...A>
        constexpr member_return_type get(A&&...args) const { return member; }
 
        template<class...A>
        constexpr member_return_type operator()(A&&...args) const { return member; }
    };
 
    static constexpr empty find_ref() { return {}; }
 
    template<class T1, class...T>
    static constexpr auto find_ref(T1&& obj, T&&...objs) {
        if constexpr ( Access::ugmisc::template has_member<T1> ) {
            return wrapped_object_member<T1>{ obj };
        } else {
            return find_ref(std::forward<T>(objs)...);
        }
    }
 
public:
    /*
     * The public methods are static because member_value itself holds all its
     * defining characteristics in its type.
     */

    template<class...T>
    static constexpr auto with(T&&...objs) {
        return find_ref(std::forward<T>(objs)...);
    }
 
    template<class...T>
    constexpr auto operator() (T&&...objs) const { return with<T...>(objs...); }

    static constexpr member_value<Access, MEMBER_COPY_AUTO> copy_auto{};

    static constexpr member_value<Access, MEMBER_COPY_ALWAYS> copy_always{};

    static constexpr member_value<Access, MEMBER_COPY_NEVER> copy_never{};
};
 
 
 

namespace member_ {
template< class Access, class TypeList > class member_type_access_traits {
    using all_types = TypeList;
    using normal_types =
        filter_type_list<member_::get_is_default_type, all_types, invert_test>;
    using default_types =
        filter_type_list<member_::get_is_default_type, all_types>;
 
    static_assert( default_types::size <= 1 );
    static_assert( default_types::size + normal_types::size == all_types::size );
 
    using access = Access;
 
    template<bool Found, class U> struct result {
        static constexpr bool found = Found;
        using type = U;
    };
 
    /*
     * This allows us to avoid instantiating type_list_member<0, seq> where seq
     * is empty.
     */
    template< class seq = normal_types >
    static constexpr auto find_type_pair() {
 
        if constexpr ( seq::size == 0 ) {
            return result<false, void>{};
        } else {
            using first_type = type_list_member<0, seq>;
            if constexpr ( access::ugmisc::template has_member_type<first_type> ) {
                return result<
                    true,
                    typename access::ugmisc::template type<first_type>
                    >{};
            } else {
                return find_type_pair< type_list_remove_prefix<1, seq> >();
            }
        }
    }
 
    using result_t = decltype(find_type_pair());
 
    /*
     * This allows us to avoid instantiating type_list_member<default_types>
     * when default_types is empty.
     */
    static constexpr auto find_default_type_pair() {
        if constexpr ( default_types::size ) {
            return result<true, type_list_member<0, default_types>>{};
        } else {
            return result<false, void>{};
        }
    }
 
    using default_t = decltype(find_default_type_pair());
 
 
public:
    static constexpr bool has_member = result_t::found;
    static constexpr bool has_default = default_t::found;
    static constexpr bool has_type = has_member || has_default;
    using type = std::conditional_t<
        has_member,
        typename result_t::type,
        typename default_t::type
        >;
};
 
 
 

template<
    class Access,
    class TypeList,
    bool HasType = member_type_access_traits<Access, TypeList>::has_type
    >
struct member_type_access {
    static_assert( ! HasType, "There is a missing specialisation." );
    static constexpr bool has_member  = false;
    static constexpr bool has_default = false;
    static constexpr bool has_type    = false;
    // Don't declare type!
    using safe_type = void;
};
 
 
template<class Access, class TypeList>
struct member_type_access<Access, TypeList, true> {
    static constexpr bool has_member
        = member_type_access_traits<Access, TypeList>::has_member;
 
    static constexpr bool has_default
        = member_type_access_traits<Access, TypeList>::has_default;
 
    static constexpr bool has_type = true;
 
    using type
        = typename member_type_access_traits<Access, TypeList>::type;
 
    using safe_type = type;
};
 
 
 
 
template<class Access, class...T>
class static_member_value_base {
    template<class U> struct access {
        using type = U;
        static constexpr bool has_member = Access::ugmisc::template has_static_member<U>;
        static constexpr auto& get() { return Access::ugmisc::template static_get<U>(); }
    };
 
    struct void_wrapper {
        using type = void;
    };
 
    template<bool Found, class Type=void_wrapper>
    struct result {
        using type                  = Type;
        static constexpr bool found = Found;
    };
 
    using accessor_types = flatten_apply_each_class<access, T...>;
 
    template<class accessors = accessor_types>
    static constexpr auto find_matching_type() {
        if constexpr ( accessors::size == 0 ) {
            return result<false>{};
        } else {
            using first_type = type_list_member<0, accessors>;
            if constexpr ( first_type::has_member ) {
                return result<true, first_type>{};
            } else {
                return find_matching_type<type_list_remove_prefix<1, accessors>>();
            }
        }
    }
 
    using result_type = decltype(find_matching_type());
    using getter_type = typename result_type::type;
 
public:
    static constexpr bool has_member = result_type::found;
 
    template<class F, class...A>
    static constexpr decltype(auto) get(F&& default_get, A&&...args) {
        if constexpr ( has_member ) {
            return getter_type::get();
        } else {
            return default_get(std::forward<A>(args)...);
        }
    }
 
    static constexpr auto& get() { return getter_type::get(); }
 
    using safe_matched_type = typename getter_type::type;
};
 
 
template<bool WithType, class Access, class...T>
struct static_member_value;
 
template<class Access, class...T>
struct static_member_value<true, Access, T...>
: public static_member_value_base<Access, T...>
{
    using matched_type =
        typename static_member_value_base<Access, T...>::safe_matched_type;
};
 
template<class Access, class...T>
struct static_member_value<false, Access, T...>
: public static_member_value_base<Access, T...>
{ };
 
 
template<class Access, class...T>
using static_member_value_t =
    static_member_value<
        static_member_value_base<Access, T...>::has_member,
        Access, T...
        >;
 
 
} /* member_ (::ugmisc::member_) */
 
 
 
#ifndef UGMISC_DOCS
template< class Access, class...T > class member_type_access
: public member_::member_type_access<Access, flatten_t<T...>>
{
};
#else

template< class Access, class...T > struct member_type_access {
    static constexpr bool has_member = ???;

    static constexpr bool has_default = ???;

    static constexpr bool has_type = has_member || has_default;

    using type = ???;

    using safe_type = ???;
};
#endif
 
 
 

template<class Access, class...T>
struct static_member_value : public member_::static_member_value_t<Access, T...>
{
#ifdef UGMISC_DOCS
    static constexpr bool has_member = ???;

    template<class F, class...A>
    static constexpr decltype(auto) get(F&& default_get, A&&...args);

    static constexpr auto& get() { return getter_type::get(); }

    using safe_matched_type = ???;

    using matched_type = ???;
#endif
};
 
 
 
 
} 
#endif /* UGMISC_MEMBER_HPP */