Class SingletonShared

src/fl/stl/singleton.h:79–119

//
// LSAN COMPATIBILITY: Uses __lsan::ScopedDisabler to prevent false positives.
template <typename T, int N = 0> class SingletonShared {
  public:
    static T &instance() FL_NOEXCEPT {
        // Check the process-wide registry first (handles cross-DLL sharing).
        // FL_PRETTY_FUNCTION produces a unique string per template instantiation
        // (includes template parameters in the signature).
        void* existing = detail::singleton_registry_get(FL_PRETTY_FUNCTION);
        if (existing) {
            return *static_cast<T*>(existing);
        }
        // First time for this type — create and register
        T* ptr = instanceInner();
        detail::singleton_registry_set(FL_PRETTY_FUNCTION, ptr);
        return *ptr;
    }

    static T *instanceRef() FL_NOEXCEPT { return &instance(); }

    SingletonShared(const SingletonShared &) FL_NOEXCEPT = delete;
    SingletonShared &operator=(const SingletonShared &) FL_NOEXCEPT = delete;

  private:
    SingletonShared() FL_NOEXCEPT = default;
    ~SingletonShared() FL_NOEXCEPT = default;

    static T* instanceInner() FL_NOEXCEPT {
        // Aligned char buffer storage — never destroyed
        struct FL_ALIGN_AS_T(alignof(T)) AlignedStorage {
            char data[sizeof(T)];
        };

        static AlignedStorage storage;

#if FL_HAS_SANITIZER_LSAN
        __lsan::ScopedDisabler disabler;  // Ignore all allocations in this scope
#endif

        T* ptr = new (&storage.data) T();
        return ptr;
    }
};

// Thread-local singleton — combines Singleton and ThreadLocal patterns.
// Each thread gets its own T instance, but the ThreadLocal<T> container itself