member.hpp

Go to the documentation of this file.

/*
 * SPDX-Licence-Identifier: MIT
 *
 * Copyright 2025 Larry Chips
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the “Software”), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */
#pragma once

 
#include "ugmisc/typelist.hpp"
#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 T, class, class...A> \
        struct static_caller { \
            static constexpr bool is_callable = false; \
        }; \
        \
        template<class T, class...A> \
        struct static_caller<T, std::void_t<decltype(T::NAME(std::declval<A>()...))>, A...> { \
            static constexpr bool is_callable = true; \
            \
            static constexpr decltype(auto) call(A...args) { \
                return T::NAME(std::forward<A>(args)...); \
            } \
        }; \
        \
        /* Non static method call support. */ \
        \
        template<class T, class, class...A> \
        struct caller { \
            static constexpr bool is_callable = false; \
        }; \
        \
        template<class T, class...A> \
        struct caller<T, std::void_t<decltype(std::declval<T>().NAME(std::declval<A>()...))>, A...> { \
            static constexpr bool is_callable = true; \
            \
            static constexpr decltype(auto) call(T& obj, A...args) { \
                return std::forward<T>(obj).NAME(std::forward<A>(args)...); \
            } \
        }; \
        \
        /* Static data reference support. */ \
        \
        template<class T, class=void> \
        struct static_member { \
            static constexpr bool has_member = false; \
        }; \
        \
        template<class T> \
        struct static_member<T, std::void_t<decltype(T::NAME)>> { \
            static constexpr bool has_member = true; \
            \
            static constexpr auto& get() { \
                return T::NAME; \
            } \
        }; \
        \
        /* Non static data reference support. */ \
        \
        template<class T, class=void> \
        struct member { \
            static constexpr bool has_member = false; \
        }; \
        \
        template<class T> \
        struct member<T, std::void_t<decltype(std::declval<T>().NAME)>> { \
            static constexpr bool has_member = true; \
            \
            static constexpr auto& get(T& obj) { \
                return obj.NAME; \
            } \
            \
            using member_type = decltype(std::declval<std::remove_reference_t<T>>().NAME); \
        }; \
        /* Type support. */ \
        \
        template< class T, class=void > struct GetType { \
            static constexpr bool has_member_type = false; \
            using safe_type = void; \
        }; \
        \
        template< class T > struct GetType< T, std::void_t< typename T::NAME > > { \
            static constexpr bool has_member_type = true; \
            using safe_type = typename T::NAME; \
            using type = typename T::NAME; \
        }; \
        \
    }; \
public: \
    struct ugmisc { \
        /* Static method call. */ \
        template<class T, class...A> static constexpr bool is_static_callable = \
            ugmisc_priv::static_caller<T, void, A...>::is_callable; \
        \
        template<class T, class...A> \
        static constexpr auto static_call(A&&...args) \
        -> decltype( \
                ugmisc_priv::static_caller<T, void, A...>::call( \
                    std::forward<A>(args)... \
                    )) \
        { \
            return ugmisc_priv::static_caller<T, void, A...>::call( \
                    std::forward<A>(args)... \
                    ); \
        } \
        \
        /* Non static method call. */ \
        template<class T, class...A> static constexpr bool is_callable = \
            ugmisc_priv::caller<T, void, A...>::is_callable; \
        \
        template<class T, class...A> \
        static constexpr auto call(T& obj, A&&...args) \
        -> decltype( \
                ugmisc_priv::caller<T, void, A...>::call( \
                    obj,  \
                    std::forward<A>(args)... \
                    )) \
        { \
            return ugmisc_priv::caller<T, void, A...>::call( \
                    obj, \
                    std::forward<A>(args)... \
                    ); \
        } \
        \
        /* Static member reference. */ \
        template< class T > \
        static constexpr bool has_static_member \
            = ugmisc_priv::static_member<T>::has_member; \
        template< class T> \
        static constexpr auto& static_get() { \
            return ugmisc_priv::static_member<T>::get(); \
        } \
        \
        /* Non static member reference. */ \
        template< class T > \
        static constexpr bool has_member \
            = ugmisc_priv::member<T>::has_member; \
        template< class T > \
        using member_type = typename ugmisc_priv::member<T>::member_type; \
        template< class T> \
        static constexpr auto& get(T&& obj) { \
            return ugmisc_priv::member<T>::get(obj); \
        } \
        \
        /* Type. */ \
        \
        template< class T > using type = typename ugmisc_priv::GetType<T>::type; \
        template< class T > using safe_type = \
            typename ugmisc_priv::GetType<T>::safe_type; \
        template< class T > static constexpr bool has_member_type = \
            ugmisc_priv::GetType<T>::has_member_type; \
    }; \
}
 
 
 

#define UGMISC_DECL_STATIC_MEMBER_CALLER(TNAME, NAME) \
    UGMISC_DECL_MEMBER_ACCESS(TNAME, NAME)
 
 
 

#define UGMISC_DECL_MEMBER_TYPE_ALIAS(TNAME, NAME) \
     UGMISC_DECL_MEMBER_ACCESS(TNAME, NAME)
 
 
 

#define UGMISC_DECL_STATIC_MEMBER_ACCESSOR(TNAME, NAME) \
     UGMISC_DECL_MEMBER_ACCESS(TNAME, NAME)
 
 
 
 
namespace ugmisc {
 
 
 

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

namespace member_ {
 
 
 
 
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(m_functor(std::forward<T>(args)...))
    {
        return 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(const Functor& f) : m_functor(f) {}
    constexpr fallback_caller(Functor&& f) : m_functor(std::move(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)...);
    }
};
 
 
 
 
 
} /* member_ (::ugmisc::member_) */
 

 
} /* ::ugmisc */
 
 
 

#define UGMISC_NAMED_MEMBER_TYPE_TEST(TEMPLATENAME, ALIASNAME, HASMEMBERNAME, NAME) \
    UGMISC__DECL_MEMBER_TYPEDEF_TYPE(TEMPLATENAME, NAME); \
    \
    template<class T, class D = void> struct TEMPLATENAME : \
        public ::ugmisc::member_type_access<UGMISC__MEMBER_TYPEDEF_TYPE_NAME(TEMPLATENAME), T, ::ugmisc::default_type<D>> \
    { \
    }; \
    \
    template<class T, class D = void> using ALIASNAME = \
        typename TEMPLATENAME<T, D>::type; \
    template<class...T> static constexpr bool HASMEMBERNAME = \
        TEMPLATENAME<::ugmisc::type_list<T...>>::has_member
 
 

#define UGMISC_MEMBER_TYPE_TEST(NAME) \
    UGMISC_NAMED_MEMBER_TYPE_TEST(member_type_test_##NAME, member_type_##NAME, has_member_type_##NAME, NAME)
 
 

 
#define UGMISC__MEMBER_CALLER_TYPE_NAME(TNAME) _ugmisc_caller_##TNAME

#define UGMISC__DECL_MEMBER_CALLER_TYPE(TNAME, NAME) \
UGMISC_DECL_STATIC_MEMBER_CALLER(UGMISC__MEMBER_CALLER_TYPE_NAME(TNAME), NAME)

#define UGMISC__MEMBER_TYPEDEF_TYPE_NAME(TNAME) _ugmisc_typedef_##TNAME

#define UGMISC__DECL_MEMBER_TYPEDEF_TYPE(TNAME, NAME) \
UGMISC_DECL_MEMBER_TYPE_ALIAS(UGMISC__MEMBER_TYPEDEF_TYPE_NAME(TNAME), NAME)
 
 
 
 
namespace ugmisc {
namespace member_ {
 
 
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, std::remove_reference_t<F>>
    fallback(F&& functor) {
        return std::forward<F>(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(std::declval<F>()(std::declval<A>()...)) >,
            A...
            >
        {
            static constexpr decltype(auto) call(F& f, A&...args) {
                return f(std::forward<A>(args)...);
            }
        };
 
        template<class...A>
        constexpr decltype(auto) call_default(A&&...args) const {
            return forwarder<void, A...>::call(functor, args...);
        }
 
    public:
        constexpr wrapped_objects(F& f, T...t)
            : wrapped_objects<void, T...>(t...), functor(f)
        {}
 
        template<class...A>
        constexpr decltype(auto) operator()(A&&...args) const {
            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.
     */
    template<class F>
    class default_function {
        F& functor_ref;
    public:
        constexpr default_function(F& f) : functor_ref(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_ref, 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 {
            return 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>
    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; }
    };
 
    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
};
 
 
 

 
 
 
 
} 
 
 
 

#define UGMISC_NAMED_MEMBER_STATIC_METHOD_CALL(TEMPLATENAME, NAME) \
    UGMISC__DECL_MEMBER_CALLER_TYPE(TEMPLATENAME, NAME); \
    template<class...T> class TEMPLATENAME \
    : public ::ugmisc::static_member_caller< \
        UGMISC__MEMBER_CALLER_TYPE_NAME(TEMPLATENAME), \
        T... \
    > \
    { \
        static constexpr const char *template_name = #TEMPLATENAME; \
        static constexpr const char *function_name = #NAME; \
    }
 

#define UGMISC_MEMBER_STATIC_METHOD_CALL(NAME) \
    UGMISC_NAMED_MEMBER_STATIC_METHOD_CALL(member_call_##NAME, NAME)