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
 
 
 
 
namespace ugmisc {
 
 
 
 
#ifdef UGMISC_DOCS

template<class...T>
struct call_foo_method {
    template<class...U>
    static constexpr decltype(auto) call(U&&...args);
 

    template<class...U>
    constexpr decltype(auto) operator() (U&&...) const;
 

    template<class F>
    static constexpr auto fallback(
            F&& functor 
            );
 

    template<class...U>
    using matched_type = ???;

    template<class...U>
    static constexpr bool is_matched_v = ???;
 

    template<class...U>
    static constexpr bool is_matched(U&&...);
 

    template<class...U>
    static matched_type<U...> declval_matched(U&&...) noexcept;
};
 
#endif /* UGMISC_DOCS */
 

namespace member_ {
 
 
 

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) template<class TYPE, class DEFAULTTYPE = void> \
    class TEMPLATENAME { \
            template<class...> struct get_defined_type; \
        \
            template<class V, class T, class...Ts> struct get_defined_type<V, T, Ts...> { \
                static constexpr bool has_member = get_defined_type<void, Ts...>::has_member; \
                using type = typename get_defined_type<void, Ts...>::type; \
            }; \
        \
            template<class T, class...Ts> struct get_defined_type<std::void_t<typename T::NAME>, T, Ts...> { \
                static constexpr bool has_member = true; \
                using type = typename T::NAME; \
            }; \
        \
            template<class V> struct get_defined_type<V> { \
                static constexpr bool has_member = false; \
                using type = DEFAULTTYPE; \
            }; \
        \
            using tlist = ::ugmisc::flatten_t<void, TYPE>; \
            using dt = typename tlist::template apply<get_defined_type>; \
        \
        public: \
            using type = typename dt::type; \
            static constexpr bool has_member = dt::has_member; \
        }; \
        \
        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) \
struct UGMISC__MEMBER_CALLER_TYPE_NAME(TNAME) { \
    \
    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(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)...); \
        } \
    }; \
}
 
namespace ugmisc {
namespace member_ {
 
 
template<class Caller, class T, class...A>
inline constexpr bool is_callable_v =
    Caller::template caller<T, void, A...>::is_callable;
 
 
template<class Caller, class T, class...A>
constexpr bool is_callable(A&&...) {
    return is_callable_v<Caller, T, A...>;
}
 
 
 

template<class Caller, class...T>
class chain_caller {
    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;
    };
 
    template<class List, class...Args>
    struct caller<
        std::enable_if_t< is_callable_v<Caller, type_list_member<0, List>, Args...>>,
        List,
        Args...
        >
    {
        static constexpr bool is_callable = true;
        using type = type_list_member<0, List>;
    };
 
    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>
    static constexpr decltype(auto) call(Args&&...args) {
        static_assert(
                is_matched_v<Args...>,
                "None of the types is callable with these argument types."
                );
        return Caller::template caller<matched_type<Args...>, void, Args...>
            ::call(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
    fallback_caller<chain_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;
};
 
 
} } 
 

 
 
 

#define UGMISC_NAMED_MEMBER_STATIC_METHOD_CALL(TEMPLATENAME, NAME) \
    UGMISC__DECL_MEMBER_CALLER_TYPE(TEMPLATENAME, NAME); \
    template<class...T> class TEMPLATENAME \
    : public ::ugmisc::member_::chain_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)