generalize initialization of policies

Author: jll63

include/boost/openmethod/default_registry.hpp

@@ -39,8 +39,8 @@ struct default_registry_attributes {};
 //! including those pulled from libraries.
 struct default_registry
     : registry<
-          policies::std_rtti, policies ::vptr_vector,
-          policies::fast_perfect_hash, policies::default_error_handler,
+          policies::std_rtti, policies::fast_perfect_hash,
+          policies::vptr_vector, policies::default_error_handler,
           policies::stderr_output,
           policies::attributes_guide<default_registry_attributes>
 #ifdef BOOST_OPENMETHOD_ENABLE_RUNTIME_CHECKS

include/boost/openmethod/initialize.hpp

@@ -59,6 +59,65 @@ struct aggregate_reports<mp11::mp_list<Reports...>, mp11::mp_list<>, Void> {
     struct type : Reports... {};
 };
 
+// Policy initialization helpers
+
+// Detect if a policy fn has an initialize function with the expected signature
+template<typename PolicyFn, typename Context, typename Options, typename = void>
+struct has_initialize : std::false_type {};
+
+#if defined(_MSC_VER) && _MSC_VER <= 1950
+template<typename PolicyFn, typename Context, typename Options>
+struct has_initialize<
+    PolicyFn, Context, Options,
+    std::void_t<
+        decltype(&PolicyFn::template initialize<Context, Options>)>>
+    : std::true_type {};
+#else
+template<typename PolicyFn, typename Context, typename Options>
+struct has_initialize<
+    PolicyFn, Context, Options,
+    std::void_t<decltype(PolicyFn::initialize(
+        std::declval<const Context&>(), std::declval<const Options&>()))>>
+    : std::true_type {};
+#endif
+
+// Call initialize on a single policy if it has the function
+template<typename Policy, typename Registry, typename Context, typename Options>
+void initialize_policy(const Context& ctx, const Options& options) {
+    using PolicyFn = typename Policy::template fn<Registry>;
+    if constexpr (has_initialize<PolicyFn, Context, Options>::value) {
+        PolicyFn::initialize(ctx, options);
+    }
+}
+
+template<typename Registry, typename Policies = typename Registry::policy_list>
+struct initialize_policies;
+
+template<typename Registry, typename... Policies>
+struct initialize_policies<Registry, mp11::mp_list<Policies...>> {
+    template<typename Context, typename Options>
+    static void fn(const Context& ctx, const Options& options) {
+        (initialize_policy<Policies, Registry>(ctx, options), ...);
+    }
+};
+
+// template<typename Registry, typename Policy, typename... Policies>
+// struct initialize_policies<Registry, mp11::mp_list<Policy, Policies...>> {
+//     template<typename Context, typename Options>
+//     static void fn(const Context& ctx, const Options& options) {
+//         initialize_policy<Policy, Registry>(ctx, options);
+//         initialize_policies<Registry, mp11::mp_list<Policies...>>::fn(
+//             ctx, options);
+//     }
+// };
+
+// template<typename Registry>
+// struct initialize_policies<Registry, mp11::mp_list<>> {
+//     template<typename Context, typename Options>
+//     static void fn(const Context& ctx, const Options& options) {
+//     }
+// };
+
 inline void merge_into(boost::dynamic_bitset<>& a, boost::dynamic_bitset<>& b) {
     if (b.size() < a.size()) {
         b.resize(a.size());
@@ -438,8 +497,8 @@ struct registry<Policies...>::compiler : detail::generic_compiler {
     static void select_dominant_overriders(
         std::vector<overrider*>& dominants, std::size_t& pick,
         std::size_t& remaining);
-    static auto
-    is_more_specific(const overrider* a, const overrider* b) -> bool;
+    static auto is_more_specific(const overrider* a, const overrider* b)
+        -> bool;
     static auto is_base(const overrider* a, const overrider* b) -> bool;
 
     std::tuple<Options...> options;
@@ -1420,9 +1479,7 @@ void registry<Policies...>::compiler<Options...>::write_global_data() {
 
     ++tr << rflush(4, dispatch_data_size) << " " << gv_iter << " end\n";
 
-    if constexpr (has_vptr) {
-        vptr::initialize(*this, options);
-    }
+    detail::initialize_policies<registry>::fn(*this, options);
 
     new_dispatch_data.swap(storage::st.dispatch_data);
 }

include/boost/openmethod/policies/default_error_handler.hpp

@@ -95,7 +95,9 @@ struct default_error_handler : error_handler {
         //! @param error The error object.
         template<class Error>
         static auto error(const Error& error) -> void {
-            handler_storage::handler(error_variant(error));
+            auto handler = handler_storage::handler ? handler_storage::handler
+                                                    : default_handler;
+            handler(error_variant(error));
         }
 
         //! Sets the function to be called to handle errors.
@@ -107,8 +109,9 @@ struct default_error_handler : error_handler {
         //! @return The previous function.
         // coverity[auto_causes_copy]
         static auto set(function_type new_handler) -> function_type {
-            return std::exchange(
+            auto prev = std::exchange(
                 handler_storage::handler, std::move(new_handler));
+            return prev ? prev : default_handler;
         }
 
         //! The default error handler function.

include/boost/openmethod/policies/fast_perfect_hash.hpp

@@ -10,6 +10,7 @@
 
 #include <limits>
 #include <random>
+#include <variant>
 #ifdef _MSC_VER
 #pragma warning(push)
 #pragma warning(disable : 4702) // unreachable code
@@ -92,12 +93,12 @@ struct fast_perfect_hash : type_hash {
         static void check(std::size_t index, type_id type);
 
         template<class InitializeContext, class... Options>
-        static void initialize(
+        static void initialize_aux(
             const InitializeContext& ctx, std::vector<type_id>& buckets,
             const std::tuple<Options...>& options);
 
       public:
-        //! Find the hash factors
+        //! Finds the hash factors
         //!
         //! Attempts to find suitable values for the multiplication factor `M`
         //! and the shift amount `S` to that do not result in collisions for the
@@ -111,15 +112,21 @@ struct fast_perfect_hash : type_hash {
         //! @return A pair containing the minimum and maximum hash values.
         template<class Context, class... Options>
         static auto
-        initialize(const Context& ctx, const std::tuple<Options...>& options) {
+        initialize(const Context& ctx, const std::tuple<Options...>& options)
+            -> void {
             if constexpr (Registry::has_runtime_checks) {
-                initialize(
+                initialize_aux(
                     ctx, detail::fast_perfect_hash_control<Registry>, options);
             } else {
                 std::vector<type_id> buckets;
-                initialize(ctx, buckets, options);
+                initialize_aux(ctx, buckets, options);
             }
+        }
 
+        //! Returns the hash range
+        //!
+        //! @return A pair containing the minimum and maximum hash values.
+        static auto hash_range() -> std::pair<std::size_t, std::size_t> {
             return std::pair{
                 factors_storage::hash_fn.min_value,
                 factors_storage::hash_fn.max_value};
@@ -163,7 +170,7 @@ struct fast_perfect_hash : type_hash {
 
 template<class Registry>
 template<class InitializeContext, class... Options>
-void fast_perfect_hash::fn<Registry>::initialize(
+void fast_perfect_hash::fn<Registry>::initialize_aux(
     const InitializeContext& ctx, std::vector<type_id>& buckets,
     const std::tuple<Options...>& options) {
     (void)options;

include/boost/openmethod/policies/vptr_vector.hpp

@@ -16,8 +16,7 @@ namespace boost::openmethod {
 namespace detail {
 
 BOOST_OPENMETHOD_DETAIL_MAKE_SYMBOL_WITH_ATTRIBUTES(vptr_vector_vptrs);
-BOOST_OPENMETHOD_DETAIL_MAKE_SYMBOL_WITH_ATTRIBUTES(
-    vptr_vector_indirect_vptrs);
+BOOST_OPENMETHOD_DETAIL_MAKE_SYMBOL_WITH_ATTRIBUTES(vptr_vector_indirect_vptrs);
 
 } // namespace detail
 
@@ -67,13 +66,14 @@ struct vptr_vector : vptr {
         //! @param ctx A Context object.
         //! @param options A tuple of option objects.
         template<class Context, class... Options>
-        static auto initialize(
-            const Context& ctx, const std::tuple<Options...>& options) -> void {
+        static auto
+        initialize(const Context& ctx, const std::tuple<Options...>& options)
+            -> void {
             std::size_t size;
             (void)options;
 
             if constexpr (has_type_hash) {
-                auto [_, max_value] = type_hash::initialize(ctx, options);
+                auto [_, max_value] = type_hash::hash_range();
                 size = max_value + 1;
             } else {
                 size = 0;
@@ -168,7 +168,7 @@ struct vptr_vector : vptr {
 
             if constexpr (Registry::has_indirect_vptr) {
                 return *indirect_vptrs_storage::vptr_vector_indirect_vptrs
-                            [index];
+                    [index];
             } else {
                 return vptrs_storage::vptr_vector_vptrs[index];
             }

test/test_policies.cpp

@@ -70,3 +70,13 @@ BOOST_AUTO_TEST_CASE(test_registry) {
     BOOST_TEST(&registry2::static_vptr<void> != &registry1::static_vptr<void>);
     // BOOST_TEST(&registry2::dispatch_data != &registry1::dispatch_data);
 }
+
+static_assert(has_initialize<
+              vptr_vector::fn<registry1>, registry1::compiler<std::tuple<>>,
+              std::tuple<>>::value);
+static_assert(!has_initialize<
+              std_rtti::fn<registry1>, registry1::compiler<std::tuple<>>,
+              std::tuple<>>::value);
+static_assert(has_initialize<
+              fast_perfect_hash::fn<registry1>,
+              registry1::compiler<std::tuple<>>, std::tuple<>>::value);