Singleton.h

#pragma once
 
#include <Foundation/Basics.h>
#include <Foundation/Containers/Map.h>
#include <Foundation/Strings/String.h>
 
#include <typeinfo>
 
 
 
class PL_FOUNDATION_DLL plSingletonRegistry
{
public:
  struct SingletonEntry
  {
    plString m_sName;
    void* m_pInstance = nullptr;
  };
 
 
  template <typename Interface>
  inline static Interface* GetSingletonInstance() // [tested]
  {
    return static_cast<Interface*>(s_Singletons.GetValueOrDefault(GetHash<Interface>(), {"", nullptr}).m_pInstance);
  }
 
  template <typename Interface>
  inline static Interface* GetRequiredSingletonInstance() // [tested]
  {
    auto value = GetSingletonInstance<Interface>();
    PL_ASSERT_ALWAYS(value, "No instance of singleton type \"{0}\" has been registered!", typeid(Interface).name());
    return value;
  }
 
  static const plMap<size_t, SingletonEntry>& GetAllRegisteredSingletons();
 
  template <typename Interface>
  inline static void Register(Interface* pSingletonInstance) // [tested]
  {
    PL_ASSERT_DEV(pSingletonInstance != nullptr, "Invalid singleton instance pointer");
    PL_ASSERT_DEV(
      s_Singletons[GetHash<Interface>()].m_pInstance == nullptr, "Singleton for type '{0}' has already been registered", typeid(Interface).name());
 
    s_Singletons[GetHash<Interface>()] = {typeid(Interface).name(), pSingletonInstance};
  }
 
  template <typename Interface>
  inline static void Unregister() // [tested]
  {
    PL_ASSERT_DEV(
      s_Singletons[GetHash<Interface>()].m_pInstance != nullptr, "Singleton for type '{0}' is currently not registered", typeid(Interface).name());
 
    s_Singletons.Remove(GetHash<Interface>());
  }
 
private:
  template <typename>
  friend class plSingletonRegistrar;
 
  template <typename Interface>
  inline static size_t GetHash()
  {
    static const size_t hash = typeid(Interface).hash_code();
    return hash;
  }
 
  static plMap<size_t, SingletonEntry> s_Singletons;
};
 
 
#define PL_DECLARE_SINGLETON(self)                 \
public:                                            \
  PL_ALWAYS_INLINE static self* GetSingleton()     \
  {                                                \
    return s_pSingleton;                           \
  }                                                \
                                                   \
private:                                           \
  PL_DISALLOW_COPY_AND_ASSIGN(self);               \
  void RegisterSingleton()                         \
  {                                                \
    s_pSingleton = this;                           \
    plSingletonRegistry::Register<self>(this);     \
  }                                                \
  static void UnregisterSingleton()                \
  {                                                \
    if (s_pSingleton)                              \
    {                                              \
      plSingletonRegistry::Unregister<self>();     \
      s_pSingleton = nullptr;                      \
    }                                              \
  }                                                \
  friend class plSingletonRegistrar<self>;         \
  plSingletonRegistrar<self> m_SingletonRegistrar; \
  static self* s_pSingleton
 
#define PL_DECLARE_SINGLETON_OF_INTERFACE(self, interface) \
public:                                                    \
  PL_ALWAYS_INLINE static self* GetSingleton()             \
  {                                                        \
    return s_pSingleton;                                   \
  }                                                        \
                                                           \
private:                                                   \
  PL_DISALLOW_COPY_AND_ASSIGN(self);                       \
  void RegisterSingleton()                                 \
  {                                                        \
    s_pSingleton = this;                                   \
    plSingletonRegistry::Register<self>(this);             \
    plSingletonRegistry::Register<interface>(this);        \
  }                                                        \
  static void UnregisterSingleton()                        \
  {                                                        \
    if (s_pSingleton)                                      \
    {                                                      \
      plSingletonRegistry::Unregister<interface>();        \
      plSingletonRegistry::Unregister<self>();             \
      s_pSingleton = nullptr;                              \
    }                                                      \
  }                                                        \
  friend class plSingletonRegistrar<self>;                 \
  plSingletonRegistrar<self> m_SingletonRegistrar;         \
  static self* s_pSingleton
 
 
#define PL_IMPLEMENT_SINGLETON(self) self* self::s_pSingleton = nullptr
 
 
 
template <class TYPE>
class plSingletonRegistrar
{
public:
  PL_ALWAYS_INLINE plSingletonRegistrar(TYPE* pType) // [tested]
  {
    pType->RegisterSingleton();
  }
 
  PL_ALWAYS_INLINE ~plSingletonRegistrar() // [tested]
  {
    TYPE::UnregisterSingleton();
  }
};