entt: struct Family bug with runtime shared library

Hello, it’s me again, I know I never bring good news but I find a case that annoys me with the family structure:

i got a static generated two times from family:

template <typename...>
    class Family
    {
        static std::atomic<std::size_t> identifier;

        template <typename...>
        static std::size_t family() ENTT_NOEXCEPT
        {
            static const std::size_t value = identifier.fetch_add(1);
            return value;
        }

    public:
        /*! @brief Unsigned integer type. */
        using family_type = std::size_t;

        /**
         * @brief Returns an unique identifier for the given type.
         * @return Statically generated unique identifier for the given type.
         */
        template <typename... Type>
        inline static family_type type() ENTT_NOEXCEPT
        {
            return family<std::decay_t<Type>...>();
        }
    };

    template<typename... Types>
    std::atomic<std::size_t> Family<Types...>::identifier{};

When you will use the dispatcher or the registry whatever that use family, it’s will use two times the family and take the wrong identifier, call the wrong callback and most of the time crash:

another approach for users who use plugins would be great, so many things in EnTT are thought for the plugins to work, unfortunately this part seems problematic

i got an approach that work through plugins and it’s suck but let me show (mixing static reflection and hashing + a vector) (bad performance etc, but it’s an approach) :

const auto fake_type = std::hash<std::string>()(Event::class_name());
        auto it = std::find_if(begin(id_memoisation ), end(id_memoisation ), [fake_type](size_t id) {return fake_type == id;});
        long type = 0;
        if (it == id_memoisation.end()) {
            id_memoisation .push_back(fake_type);
            type = std::distance(id_memoisation .begin(), std::prev(id_memoisation.end()));
        } else {
            type = std::distance(id_memoisation .begin(), it);
        }
        std::cout << Event::class_name() << ": " << type << " fake_type: " << fake_type << std::endl;

        if(!(type < wrappers.size())) {
            wrappers.resize(type + 1);
        }

        if(!wrappers[type]) {
            wrappers[type] = std::make_unique<SignalWrapper<Event>>();
        }

        return static_cast<SignalWrapper<Event> &>(*wrappers[type]);
    }

this snippet fix the problem and using the idx position of the memoisation vector, it’s suck but work’s.

honestly I do not think that with the solution to use a static currently we will manage to solve this problem.

i think we can mark it as bug.

Can we speak about some options that doesn’t ruin performance, and are acceptable for everyone ?

A solution to keep the static things would be something like: “please when you compile a shared library don’t generate the static you will have the symbol latter”.

But i’m not sure it’s possible honnestly