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<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_NAMED_MEMBER_STATIC_METHOD_CALL(TEMPLATENAME, NAME) \
    template<class...> class TEMPLATENAME; \
    \
    template<class FirstTry, class...Tries> \
    struct TEMPLATENAME<FirstTry, Tries...> { \
        template<class...> friend class TEMPLATENAME; \
        \
    private: \
        template<class...T> struct Call : public TEMPLATENAME<Tries...>::template Call<T...> { \
        }; \
        \
        template<class...T> struct Call<std::void_t<decltype(FirstTry::NAME(std::declval<T>()...))>, T...> { \
            static constexpr bool is_matched = true; \
            \
            using matched_type = FirstTry; \
            \
            static constexpr decltype(auto) call(T...args) { \
                return FirstTry::NAME(std::forward<T>(args)...); \
            } \
        }; \
        \
    public: \
            \
        template<class...T> \
        static constexpr decltype(auto) call(T&&...args) { \
                return Call<void, T...>::call(std::forward<T>(args)...); \
        } \
        \
        template<class...T> \
        decltype(auto) constexpr operator() (T&&...args) const { \
            return TEMPLATENAME::call(std::forward<T>(args)...); \
        } \
        \
        template<class F> \
        static constexpr \
        member_::fallback_caller<TEMPLATENAME, std::remove_reference_t<F>> \
        fallback(F&& functor) { \
            return std::forward<F>(functor); \
        } \
        \
        template<class...T> \
        using matched_type = typename Call<void, T...>::matched_type; \
        \
        template<class...T> \
        static constexpr bool is_matched(T&&...) { return Call<void, T...>::is_matched; } \
        \
        template<class...T> \
        static constexpr bool is_matched_v = Call<void, T...>::is_matched; \
        \
        template<class...T> \
        static matched_type<T...> declval_matched(T&&...) noexcept; \
    }; \
    \
    /* An empty type list doesn't ever match the call. */ \
    template<> class TEMPLATENAME<> { \
    template<class...> friend class TEMPLATENAME; \
    private: \
        template<class...> struct Call { \
            static constexpr bool is_matched = false; \
        }; \
        \
    public: \
        template<class...T> \
        static constexpr bool is_matched(T&&...) { return false; } \
    }
 

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