rework overriders

Author: jll63

include/yorel/yomm2/core.hpp

@@ -715,26 +715,65 @@ class method<Name, Return(Parameters...), Options...>
                 detail::types<OverriderParameters...>>>;
     };
 
-    template<class Container, bool has_next>
-    struct override_;
+    template<auto Function>
+    struct override_fn_impl {
+        explicit override_fn_impl(Next* next = nullptr) {
+            static detail::definition_info info;
 
-    friend class generator;
+            if (info.method) {
+                BOOST_ASSERT(info.method == &fn);
+                return;
+            }
 
-  public:
-    template<auto Function>
-    struct override_fn;
+            info.method = &fn;
+            info.type = Policy::template static_type<decltype(Function)>();
+            info.next = reinterpret_cast<void**>(next);
+            using Thunk = thunk<Function, decltype(Function)>;
+            info.pf = (void*)Thunk::fn;
+            info.vp_begin = Thunk::OverriderParameterTypeIds::begin;
+            info.vp_end = Thunk::OverriderParameterTypeIds::end;
+            fn.specs.push_back(info);
+        }
+    };
+
+    template<auto Function, typename FunctionType>
+    struct override_fn_aux;
+
+    template<auto Function, typename FnReturnType, typename... FnParameters>
+    struct override_fn_aux<Function, FnReturnType (*)(FnParameters...)>
+        : override_fn_impl<Function> {
+        using override_fn_impl<Function>::override_fn_impl;
+    };
+
+    template<
+        auto Function, class FnClass, typename FnReturnType,
+        typename... FnParameters>
+    struct override_fn_aux<
+        Function, FnReturnType (FnClass::*)(FnParameters...)> {
+        static auto fn(FnClass* this_, FnParameters&&... args) -> FnReturnType {
+            return (this_->*Function)(std::forward<FnParameters>(args)...);
+        }
+
+        override_fn_impl<fn> impl;
+    };
+
+    template<class Container, bool HasNext>
+    struct override_aux;
 
-  private:
     template<class Container>
-    struct override_<Container, false> {
-        override_fn<Container::fn> override_{nullptr};
+    struct override_aux<Container, false> : override_fn<Container::fn> {
+        override_aux() : override_fn<Container::fn>(nullptr) {
+        }
     };
 
     template<class Container>
-    struct override_<Container, true> {
-        override_fn<Container::fn> add{&Container::next};
+    struct override_aux<Container, true> : override_fn<Container::fn> {
+        override_aux() : override_fn<Container::fn>(&Container::next) {
+        }
     };
 
+    friend class generator;
+
   public:
     // Public aliases.
     using return_type = Return;
@@ -754,38 +793,20 @@ class method<Name, Return(Parameters...), Options...>
     using next = detail::next_aux<method, Container>;
 
     template<auto Function>
-    struct override_fn {
-        explicit override_fn(Next* next = nullptr) {
-            static detail::definition_info info;
-
-            if (info.method) {
-                BOOST_ASSERT(info.method == &fn);
-                return;
-            }
+    struct override_fn : override_fn_aux<Function, decltype(Function)> {
+        using override_fn_aux<Function, decltype(Function)>::override_fn_aux;
+    };
 
-            info.method = &fn;
-            info.type = Policy::template static_type<decltype(Function)>();
-            info.next = reinterpret_cast<void**>(next);
-            using Thunk = thunk<Function, decltype(Function)>;
-            info.pf = (void*)Thunk::fn;
-            info.vp_begin = Thunk::OverriderParameterTypeIds::begin;
-            info.vp_end = Thunk::OverriderParameterTypeIds::end;
-            fn.specs.push_back(info);
-        }
+    template<auto... F>
+    struct override_fns {
+        std::tuple<override_fn<F>...> fns;
     };
 
     template<class Container>
     struct override
-        : override_<Container, detail::has_next<Container>::value> {
+        : override_aux<Container, detail::has_next<Container>::value> {
         using type = override; // make it a meta-function
     };
-
-    template<auto F>
-    struct add_member_function
-        : override_fn<detail::member_function_thunk<F, decltype(F)>::fn> {};
-
-    template<auto... F>
-    struct add_member_functions : std::tuple<add_member_function<F>...> {};
 };
 
 template<

tests/test_member_method.cpp

@@ -44,7 +44,7 @@ struct Payroll {
     }
 
   public:
-    using pay_functions = Payroll::pay_method::add_member_functions<
+    using pay_functions = Payroll::pay_method::override_fns<
         &Payroll::pay_employee, &Payroll::pay_manager>;
 };