support dynamic loading on Windows

Author: jll63

CLAUDE.md

@@ -276,6 +276,24 @@ When adding static variables to policies:
 
 This pattern ensures static variables can be properly decorated with dllexport/dllimport for shared library usage.
 
+5. **Add an `id()` function** to the policy's `fn<Registry>` class returning the address of the first byte of the state:
+```cpp
+static auto id() -> const void* {
+    return &static_::variable_name;
+}
+```
+For policies with two possible state variables (e.g., `vptr_vector`), use `if constexpr` to select the active one:
+```cpp
+static auto id() -> const void* {
+    if constexpr (Registry::has_indirect_vptr) {
+        return &static_::vptr_vector_indirect_vptrs;
+    } else {
+        return &static_::vptr_vector_vptrs;
+    }
+}
+```
+For `stderr_output`, which inherits its state, use the class name: `&fn::os`.
+
 **Example from fast_perfect_hash**:
 ```cpp
 // In detail namespace

doc/modules/ROOT/examples/shared_libs/CMakeLists.txt

@@ -24,12 +24,6 @@ add_compile_definitions(BOOST_OPENMETHOD_ENABLE_RUNTIME_CHECKS)
 # ------------------------------------------------------------------------------
 # dynamic loading, direct virtual_ptrs
 
-if(UNIX)
-    message(STATUS "Boost.OpenMethod: disabling symbol exports on POSIX (hidden visibility)")
-    set(CMAKE_CXX_VISIBILITY_PRESET hidden)
-    set(CMAKE_VISIBILITY_INLINES_HIDDEN ON)
-endif()
-
 add_executable(boost_openmethod-dynamic dynamic_main.cpp)
 set_target_properties(boost_openmethod-dynamic PROPERTIES ENABLE_EXPORTS ON)
 target_link_libraries(boost_openmethod-dynamic Boost::openmethod Boost::dll)

include/boost/openmethod/core.hpp

@@ -360,7 +360,7 @@ struct use_class_aux<Registry, mp11::mp_list<Class, Bases...>>
         }
 
         // coverity[uninit] - zero-initialized static storage
-        Registry::st.classes.push_back(*this);
+        Registry::static_::st.classes.push_back(*this);
     }
 
     void resolve_type_ids() {
@@ -370,7 +370,7 @@ struct use_class_aux<Registry, mp11::mp_list<Class, Bases...>>
     }
 
     ~use_class_aux() {
-        Registry::st.classes.remove(*this);
+        Registry::static_::st.classes.remove(*this);
     }
 };
 
@@ -2420,7 +2420,7 @@ method<Id, ReturnType(Parameters...), Registry>::method() {
 
     // zero-initalized static variable
     // coverity[uninit_use]
-    Registry::st.methods.push_back(*this);
+    Registry::static_::st.methods.push_back(*this);
 }
 
 template<
@@ -2440,7 +2440,7 @@ void method<Id, ReturnType(Parameters...), Registry>::resolve_type_ids() {
 template<
     typename Id, typename... Parameters, typename ReturnType, class Registry>
 method<Id, ReturnType(Parameters...), Registry>::~method() {
-    Registry::st.methods.remove(*this);
+    Registry::static_::st.methods.remove(*this);
 }
 
 // -----------------------------------------------------------------------------

include/boost/openmethod/initialize.hpp

@@ -61,30 +61,26 @@ struct aggregate_reports<mp11::mp_list<Reports...>, mp11::mp_list<>, Void> {
 
 // 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 {};
+template<typename, class, class...>
+struct has_initialize_aux : std::false_type {};
+
+template<class T, class... Args>
+struct has_initialize_aux<
+    std::void_t<decltype(&T::template initialize<std::decay_t<Args>...>)>,
+    T, Args...> : std::true_type {};
+
+template<class T, class... Args>
+constexpr bool has_initialize = has_initialize_aux<void, T, Args...>::value;
 #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 {};
+BOOST_OPENMETHOD_DETAIL_HAS_STATIC_FN(has_initialize, initialize);
 #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) {
+    if constexpr (has_initialize<PolicyFn, const Context&, const Options&>) {
         PolicyFn::initialize(ctx, options);
     }
 }
@@ -585,7 +581,7 @@ template<class... Options>
 void registry<Policies...>::compiler<Options...>::initialize() {
     compile();
     install_global_tables();
-    registry<Policies...>::st.initialized = true;
+    registry<Policies...>::static_::st.initialized = true;
 }
 
 #ifdef _MSC_VER
@@ -654,7 +650,7 @@ void registry<Policies...>::compiler<Options...>::augment_classes() {
         // The standard does not guarantee that there is exactly one
         // type_info object per class. However, it guarantees that the
         // type_index for a class has a unique value.
-        for (auto& cr : registry::st.classes) {
+        for (auto& cr : registry::static_::st.classes) {
             if constexpr (has_deferred_static_rtti) {
                 static_cast<deferred_class_info&>(cr).resolve_type_ids();
             }
@@ -691,7 +687,7 @@ void registry<Policies...>::compiler<Options...>::augment_classes() {
     // All known classes now have exactly one associated class_* in the
     // map. Collect the bases.
 
-    for (auto& cr : registry::st.classes) {
+    for (auto& cr : registry::static_::st.classes) {
         auto rtc = class_map[rtti::type_index(cr.type)];
 
         for (auto& base : range{cr.first_base, cr.last_base}) {
@@ -820,14 +816,14 @@ void registry<Policies...>::compiler<Options...>::augment_methods() {
     using namespace policies;
     using namespace detail;
 
-    methods.resize(registry::st.methods.size());
+    methods.resize(registry::static_::st.methods.size());
 
     ++tr << "Methods:\n";
     indent _(tr);
 
     auto meth_iter = methods.begin();
 
-    for (auto& meth_info : registry::st.methods) {
+    for (auto& meth_info : registry::static_::st.methods) {
         if constexpr (has_deferred_static_rtti) {
             static_cast<deferred_method_info&>(meth_info).resolve_type_ids();
         }
@@ -1530,7 +1526,7 @@ void registry<Policies...>::compiler<Options...>::write_global_data() {
 
     detail::initialize_policies<registry>::fn(*this, options);
 
-    new_dispatch_data.swap(st.dispatch_data);
+    new_dispatch_data.swap(static_::st.dispatch_data);
 }
 
 template<class... Policies>
@@ -1749,14 +1745,7 @@ inline auto initialize(Options&&... options) {
 
 namespace detail {
 
-template<typename, class Policy, class... Options>
-struct has_finalize_aux : std::false_type {};
-
-template<class Policy, class... Options>
-struct has_finalize_aux<
-    std::void_t<decltype(Policy::finalize(
-        std::declval<std::tuple<Options...>>()))>,
-    Policy, Options...> : std::true_type {};
+BOOST_OPENMETHOD_DETAIL_HAS_STATIC_FN(has_finalize, finalize);
 
 } // namespace detail
 
@@ -1766,13 +1755,13 @@ auto registry<Policies...>::finalize(Options... opts) -> void {
     std::tuple<Options...> options(opts...); // gcc-8 doesn't like CTAD here
     mp11::mp_for_each<policy_list>([&options](auto policy) {
         using fn = typename decltype(policy)::template fn<registry>;
-        if constexpr (detail::has_finalize_aux<void, fn, Options...>::value) {
+        if constexpr (detail::has_finalize<fn, const std::tuple<Options...>&>) {
             fn::finalize(options);
         }
     });
 
-    st.dispatch_data.clear();
-    st.initialized = false;
+    static_::dispatch_data.clear();
+    static_::initialized = false;
 }
 
 //! Release resources held by registry.

include/boost/openmethod/policies/default_error_handler.hpp

@@ -114,6 +114,10 @@ struct default_error_handler : error_handler {
             return prev ? prev : default_handler;
         }
 
+        static auto id() -> const void* {
+            return &static_::handler;
+        }
+
         //! The default error handler function.
         //!
         //! @param error A variant containing the error.

include/boost/openmethod/policies/fast_perfect_hash.hpp

@@ -86,7 +86,8 @@ struct fast_perfect_hash : type_hash {
     //!
     //! @tparam Registry The registry containing this policy
     template<class Registry>
-    class fn : detail::static_hash_fn<detail::hash_fn, Registry> {
+    class fn {
+        using static_ = detail::static_hash_fn<detail::hash_fn, Registry>;
         static void check(std::size_t index, type_id type);
 
         template<class InitializeContext, class... Options>
@@ -124,7 +125,7 @@ struct fast_perfect_hash : type_hash {
         //!
         //! @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{hash_fn.min_value, hash_fn.max_value};
+            return std::pair{static_::hash_fn.min_value, static_::hash_fn.max_value};
         }
 
         //! Hash a type id
@@ -142,7 +143,7 @@ struct fast_perfect_hash : type_hash {
         //! @return The hash value
         BOOST_FORCEINLINE
         static auto hash(type_id type) -> std::size_t {
-            auto index = hash_fn(type);
+            auto index = static_::hash_fn(type);
 
             if constexpr (Registry::has_runtime_checks) {
                 check(index, type);
@@ -160,6 +161,10 @@ struct fast_perfect_hash : type_hash {
         static auto finalize(const std::tuple<Options...>&) -> void {
             detail::fast_perfect_hash_control<Registry>.clear();
         }
+
+        static auto id() -> const void* {
+            return &static_::hash_fn;
+        }
     };
 };
 
@@ -187,10 +192,10 @@ void fast_perfect_hash::fn<Registry>::initialize_aux(
     std::uniform_int_distribution<std::size_t> uniform_dist;
 
     for (std::size_t pass = 0; pass < 5; ++pass, ++M) {
-        hash_fn.shift = 8 * sizeof(type_id) - M;
+        static_::hash_fn.shift = 8 * sizeof(type_id) - M;
         auto hash_size = 1 << M;
-        hash_fn.min_value = (std::numeric_limits<std::size_t>::max)();
-        hash_fn.max_value = (std::numeric_limits<std::size_t>::min)();
+        static_::hash_fn.min_value = (std::numeric_limits<std::size_t>::max)();
+        static_::hash_fn.max_value = (std::numeric_limits<std::size_t>::min)();
 
         if constexpr (InitializeContext::template has_option<trace>) {
             ctx.tr << "  trying with M = " << M << ", " << hash_size
@@ -205,16 +210,16 @@ void fast_perfect_hash::fn<Registry>::initialize_aux(
                 buckets.begin(), buckets.end(), type_id(detail::uintptr_max));
             ++attempts;
             ++total_attempts;
-            hash_fn.mult = uniform_dist(rnd) | 1;
+            static_::hash_fn.mult = uniform_dist(rnd) | 1;
 
             for (auto iter = ctx.classes_begin(); iter != ctx.classes_end();
                  ++iter) {
                 for (auto type_iter = iter->type_id_begin();
                      type_iter != iter->type_id_end(); ++type_iter) {
                     auto type = *type_iter;
-                    auto index = hash_fn(type);
-                    hash_fn.min_value = (std::min)(hash_fn.min_value, index);
-                    hash_fn.max_value = (std::max)(hash_fn.max_value, index);
+                    auto index = static_::hash_fn(type);
+                    static_::hash_fn.min_value = (std::min)(static_::hash_fn.min_value, index);
+                    static_::hash_fn.max_value = (std::max)(static_::hash_fn.max_value, index);
 
                     if (detail::uintptr(buckets[index]) !=
                         detail::uintptr_max) {
@@ -226,9 +231,9 @@ void fast_perfect_hash::fn<Registry>::initialize_aux(
             }
 
             if constexpr (InitializeContext::template has_option<trace>) {
-                ctx.tr << "  found " << hash_fn.mult << " after "
+                ctx.tr << "  found " << static_::hash_fn.mult << " after "
                        << total_attempts << " attempts; span = ["
-                       << hash_fn.min_value << ", " << hash_fn.max_value
+                       << static_::hash_fn.min_value << ", " << static_::hash_fn.max_value
                        << "]\n";
             }
 
@@ -251,7 +256,7 @@ void fast_perfect_hash::fn<Registry>::initialize_aux(
 
 template<class Registry>
 void fast_perfect_hash::fn<Registry>::check(std::size_t index, type_id type) {
-    if (index < hash_fn.min_value || index > hash_fn.max_value ||
+    if (index < static_::hash_fn.min_value || index > static_::hash_fn.max_value ||
         detail::fast_perfect_hash_control<Registry>[index] != type) {
 
         if constexpr (Registry::has_error_handler) {

include/boost/openmethod/policies/stderr_output.hpp

@@ -28,6 +28,10 @@ struct stderr_output : output {
     struct fn : detail::static_os<detail::ostderr, Registry> {
         //! A @ref LightweightOuputStream.
         // static detail::ostderr os; // now inherited from static_os
+
+        static auto id() -> const void* {
+            return &fn::os;
+        }
     };
 };
 

include/boost/openmethod/policies/vptr_map.hpp

@@ -120,6 +120,10 @@ class vptr_map : public vptr {
         static auto finalize(const std::tuple<Options...>&) -> void {
             static_::vptrs.clear();
         }
+
+        static auto id() -> const void* {
+            return &static_::vptrs;
+        }
     };
 };
 

include/boost/openmethod/policies/vptr_vector.hpp

@@ -187,6 +187,14 @@ struct vptr_vector : vptr {
                 static_::vptr_vector_vptrs.clear();
             }
         }
+
+        static auto id() -> const void* {
+            if constexpr (Registry::has_indirect_vptr) {
+                return &static_::vptr_vector_indirect_vptrs;
+            } else {
+                return &static_::vptr_vector_vptrs;
+            }
+        }
     };
 };