wip

Author: jll63

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

@@ -24,6 +24,12 @@ 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)

doc/modules/ROOT/examples/shared_libs/animals.hpp

@@ -13,6 +13,14 @@
 
 #include <boost/openmethod/preamble.hpp>
 
+#ifdef BOOST_CLANG
+#pragma clang diagnostic ignored "-Wundefined-var-template"
+#endif
+
+#ifdef BOOST_GCC
+//#pragma GCC diagnostic ignored "-Wundefined-var-template"
+#endif
+
 #ifdef LIBRARY_NAME
 #define ANIMALS_API boost::openmethod::declspec::dllexport
 #else

doc/modules/ROOT/examples/shared_libs/dynamic_main.cpp

@@ -8,6 +8,7 @@
 #define LIBRARY_NAME "boost_openmethod-shared.dll"
 #else
 #define LIBRARY_NAME "libboost_openmethod-shared.so"
+
 #endif
 #endif
 

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::storage::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::storage::st.classes.remove(*this);
     }
 };
 
@@ -2416,7 +2416,7 @@ method<Id, ReturnType(Parameters...), Registry>::method() {
 
     // zero-initalized static variable
     // coverity[uninit_use]
-    Registry::st.methods.push_back(*this);
+    Registry::storage::st.methods.push_back(*this);
 }
 
 template<
@@ -2436,7 +2436,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::storage::st.methods.remove(*this);
 }
 
 // -----------------------------------------------------------------------------

include/boost/openmethod/initialize.hpp

@@ -486,7 +486,7 @@ template<class... Options>
 void registry<Policies...>::compiler<Options...>::initialize() {
     compile();
     install_global_tables();
-    registry<Policies...>::st.initialized = true;
+    registry<Policies...>::storage::st.initialized = true;
 }
 
 #ifdef _MSC_VER
@@ -555,7 +555,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::storage::st.classes) {
             if constexpr (has_deferred_static_rtti) {
                 static_cast<deferred_class_info&>(cr).resolve_type_ids();
             }
@@ -585,7 +585,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::storage::st.classes) {
         auto rtc = class_map[rtti::type_index(cr.type)];
 
         for (auto& base : range{cr.first_base, cr.last_base}) {
@@ -714,14 +714,14 @@ void registry<Policies...>::compiler<Options...>::augment_methods() {
     using namespace policies;
     using namespace detail;
 
-    methods.resize(registry::st.methods.size());
+    methods.resize(registry::storage::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::storage::st.methods) {
         if constexpr (has_deferred_static_rtti) {
             static_cast<deferred_method_info&>(meth_info).resolve_type_ids();
         }
@@ -1424,7 +1424,7 @@ void registry<Policies...>::compiler<Options...>::write_global_data() {
         vptr::initialize(*this, options);
     }
 
-    new_dispatch_data.swap(st.dispatch_data);
+    new_dispatch_data.swap(storage::st.dispatch_data);
 }
 
 template<class... Policies>
@@ -1665,8 +1665,8 @@ auto registry<Policies...>::finalize(Options... opts) -> void {
         }
     });
 
-    dispatch_data.clear();
-    st.initialized = false;
+    storage::st.dispatch_data.clear();
+    storage::st.initialized = false;
 }
 
 //! Release resources held by registry.

include/boost/openmethod/macros.hpp

@@ -30,16 +30,16 @@ struct va_args<ReturnType, Other> {
     using return_type = ReturnType;
     using registry =
         std::conditional_t<is_registry<Other>, Other, macro_default_registry>;
-    using attributes =
-        std::conditional_t<std::is_base_of_v<attributes, Other>, Other, void>;
+    using attributes = std::conditional_t<
+        std::is_base_of_v<attributes_base, Other>, Other, void>;
 };
 
 template<class ReturnType, class T, class U>
 struct va_args<ReturnType, T, U> {
     using return_type = ReturnType;
     using registry = std::conditional_t<is_registry<T>, T, U>;
     using attributes =
-        std::conditional_t<std::is_base_of_v<attributes, T>, T, U>;
+        std::conditional_t<std::is_base_of_v<attributes_base, T>, T, U>;
 };
 
 template<class ReturnType>
@@ -74,8 +74,8 @@ struct va_args<ReturnType> {
         ::boost::openmethod::detail::va_args<__VA_ARGS__>::registry>
 
 #define BOOST_OPENMETHOD_DETAIL_STORAGE_CLASS(NAME, ARGS, ...)                 \
-    auto boost_openmethod_attributes(                                         \
-        BOOST_OPENMETHOD_TYPE(NAME, ARGS, __VA_ARGS__) &)                      \
+    auto boost_openmethod_attributes(                                          \
+        BOOST_OPENMETHOD_TYPE(NAME, ARGS, __VA_ARGS__)&)                       \
         -> ::boost::openmethod::detail::va_args<__VA_ARGS__>::attributes;
 
 #define BOOST_OPENMETHOD(NAME, ARGS, ...)                                      \

include/boost/openmethod/policies/default_error_handler.hpp

@@ -85,7 +85,8 @@ struct default_error_handler : error_handler {
         //! The type of the error handler function object.
         using function_type = std::function<void(const error_variant& error)>;
 
-        using handler_storage = detail::global_state_handler<function_type, Registry>;
+        using handler_storage =
+            detail::global_state_handler<function_type, Registry>;
 
         //! Calls a function with the error object, wrapped in an @ref
         //! error_variant.
@@ -106,7 +107,8 @@ 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(handler_storage::handler, std::move(new_handler));
+            return std::exchange(
+                handler_storage::handler, std::move(new_handler));
         }
 
         //! The default error handler function.
@@ -125,7 +127,6 @@ struct default_error_handler : error_handler {
                 Registry::output::os << "\n";
             }
         }
-
     };
 };
 

include/boost/openmethod/preamble.hpp

@@ -3,6 +3,7 @@
 
 #include <boost/openmethod/detail/static_list.hpp>
 
+#include <boost/config.hpp>
 #include <boost/mp11/algorithm.hpp>
 #include <boost/mp11/bind.hpp>
 #include <boost/preprocessor/cat.hpp>
@@ -738,8 +739,8 @@ struct TypeHashFn {
     //! blueprint.
     //! @return A pair containing the minimum and maximum hash values.
     template<class Context>
-    static auto initialize(const Context& ctx)
-        -> std::pair<std::size_t, std::size_t>;
+    static auto
+    initialize(const Context& ctx) -> std::pair<std::size_t, std::size_t>;
 
     //! Hash a `type_id`.
     //!
@@ -924,36 +925,34 @@ struct initialize_aux;
 // -----------------------------------------------------------------------------
 // attributes
 
-struct attributes {};
-struct no_attributes : attributes {};
+struct attributes_base {};
+
+struct no_attributes : attributes_base {};
+
 struct declspec {
-    struct dllexport : attributes {};
-    struct dllimport : attributes {};
+    struct dllexport : attributes_base {};
+    struct dllimport : attributes_base {};
 };
 
-struct visibility {
-    struct hidden : attributes {};
-    struct default_ : attributes {};
-};
 namespace detail {
 
-#define BOOST_OPENMETHOD_DETAIL_MAKE_SYMBOL_WITH_ATTRIBUTES(ID)                \
+#define BOOST_OPENMETHOD_DETAIL_MAKE_SYMBOL_WITH_ATTRIBUTES(ID, ...)           \
     template<class Type, class Guide = Type&, typename = void>                 \
     struct BOOST_PP_CAT(global_state_, ID) {                                   \
         using attributes = no_attributes;                                      \
         static Type ID;                                                        \
     };                                                                         \
                                                                                \
     template<class Type, class Guide, typename Enable>                         \
-    Type BOOST_PP_CAT(global_state_, ID)<Type, Guide, Enable>::ID;             \
+    Type BOOST_PP_CAT(global_state_, ID)<Type, Guide, Enable>::ID __VA_ARGS__; \
                                                                                \
     template<class Type, class Guide>                                          \
     struct BOOST_PP_CAT(global_state_, ID)<                                    \
         Type, Guide,                                                           \
         std::enable_if_t<                                                      \
             std::is_same_v<get_attributes<Guide>, declspec::dllexport>>> {     \
         using attributes = declspec::dllexport;                                \
-        static __declspec(dllexport) Type ID;                                  \
+        static BOOST_SYMBOL_EXPORT Type ID __VA_ARGS__;                        \
     };                                                                         \
                                                                                \
     template<class Type, class Guide>                                          \
@@ -968,7 +967,7 @@ namespace detail {
         std::enable_if_t<                                                      \
             std::is_same_v<get_attributes<Guide>, declspec::dllimport>>> {     \
         using attributes = declspec::dllimport;                                \
-        static __declspec(dllimport) Type ID;                                  \
+        static BOOST_SYMBOL_IMPORT Type ID;                                    \
     }
 
 template<typename Type>
@@ -1045,13 +1044,12 @@ struct attributes_guide final : attributes {
 //!
 //! @see @ref policies
 template<class... Policy>
-class registry
-    : public detail::registry_base,
-      public detail::global_state_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 {
+    using storage = detail::global_state_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>;
 
     template<class...>
     friend struct detail::use_class_aux;
@@ -1061,6 +1059,11 @@ class registry
   public:
     //! The type of this registry.
     using registry_type = registry;
+    using attributes = typename storage::attributes;
+
+    static const void* id() {
+        return static_cast<const void*>(&storage::st);
+    }
 
     template<class... Options>
     struct compiler;
@@ -1170,7 +1173,7 @@ vptr_type registry<Policies...>::static_vptr;
 template<class... Policies>
 void registry<Policies...>::require_initialized() {
     if constexpr (registry::has_runtime_checks) {
-        if (!st.initialized) {
+        if (!storage::st.initialized) {
             if constexpr (registry::has_error_handler) {
                 error_handler::error(not_initialized());
             }

test/test_class_registration.cpp

@@ -26,7 +26,7 @@ BOOST_AUTO_TEST_CASE(registry_own_state) {
     using r1 = test_registry_<__COUNTER__>;
     using r2 = test_registry_<__COUNTER__>;
     static_assert(!std::is_same_v<r1::registry_type, r2::registry_type>);
-    BOOST_CHECK_NE((void*)&r1::st, (void*)&r2::st);
+    BOOST_CHECK_NE(r1::id(), r2::id());
 }
 
 namespace TEST_NS {

test/test_dispatch.cpp

@@ -335,17 +335,6 @@ BOOST_AUTO_TEST_CASE(simple) {
         BOOST_TEST(
             times(diag, 2) == string_pair(DIAGONAL_SCALAR, MATRIX_SCALAR));
     }
-
-    if constexpr (std::is_same_v<test_registry::vptr, policies::vptr_vector>) {
-        BOOST_TEST(
-            !detail::vptr_vector_vptrs<test_registry::registry_type>.empty());
-        finalize<test_registry>();
-        static_assert(detail::has_finalize_aux<
-                      void, test_registry::policy<policies::vptr>,
-                      std::tuple<>>::value);
-        BOOST_TEST(
-            detail::vptr_vector_vptrs<test_registry::registry_type>.empty());
-    }
 }
 
 } // namespace TEST_NS