support dynamic loading on Windows

Author: jll63

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

@@ -585,7 +585,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 +654,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 +691,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 +820,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 +1530,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(registry::static_::st.dispatch_data);
 }
 
 template<class... Policies>
@@ -1771,8 +1771,8 @@ auto registry<Policies...>::finalize(Options... opts) -> void {
         }
     });
 
-    st.dispatch_data.clear();
-    st.initialized = false;
+    registry::static_::st.dispatch_data.clear();
+    registry::static_::st.initialized = false;
 }
 
 //! Release resources held by registry.

include/boost/openmethod/preamble.hpp

@@ -1037,25 +1037,26 @@ struct attributes_guide final : attributes {
 //!
 //! @see @ref policies
 template<class... Policy>
-class registry
-    : public detail::registry_base,
-      detail::static_st<
-          detail::registry_state<registry<Policy...>>,
-          typename detail::find_first_derived_of<
-              policies::attributes, mp11::mp_list<Policy...>,
-              policies::attributes_guide<registry<Policy...>>>::guide_type> {
+class registry : public detail::registry_base {
 
     template<class...>
     friend struct detail::use_class_aux;
     template<typename Name, typename ReturnType, class Registry>
     friend class method;
 
+    using static_ = detail::static_st<
+        detail::registry_state<registry<Policy...>>,
+        typename detail::find_first_derived_of<
+            policies::attributes, mp11::mp_list<Policy...>,
+            policies::attributes_guide<registry<Policy...>>>::guide_type>;
+
   public:
     //! The type of this registry.
     using registry_type = registry;
+    using declspec = typename static_::declspec;
 
     static const void* id() {
-        return static_cast<const void*>(&st);
+        return static_cast<const void*>(&static_::st);
     }
 
     template<class... Options>
@@ -1162,7 +1163,7 @@ class registry
 template<class... Policies>
 void registry<Policies...>::require_initialized() {
     if constexpr (registry::has_runtime_checks) {
-        if (!st.initialized) {
+        if (!static_::st.initialized) {
             if constexpr (registry::has_error_handler) {
                 error_handler::error(not_initialized());
             }