Singleton.hpp

Go to the documentation of this file.

#pragma once
 
#include <cassert>
#include <exception>
#include <functional>
 
namespace smgl
{
 
namespace policy
{
using AtExitFunc = void (*)();
 
template <typename T>
struct CreateUsingNew {
    static T* Create() { return new T; }
    static void Destroy(T* obj) { delete obj; }
};
 
template <typename T>
struct CreateStatic {
    static T* Create()
    {
        // Create aligned static buffer
        alignas(alignof(T)) static char buf[sizeof(T)];
        return new (&buf) T;
    }
    static void Destroy(T* obj) { obj->~T(); }
};
 
template <typename T>
struct DefaultLifetime {
    static void ScheduleDestruction(AtExitFunc destructionFn)
    {
        std::atexit(destructionFn);
    }
    static void OnDeadReference()
    {
        throw std::logic_error{"Dead reference detected"};
    }
};
 
template <typename T>
class PhoenixLifetime
{
public:
    static void ScheduleDestruction(AtExitFunc destructionFn)
    {
        if (not destroyed_) {
            std::atexit(destructionFn);
        }
    }
 
    static void OnDeadReference() { destroyed_ = true; }
 
private:
    static bool destroyed_;
};
 
template <typename T>
bool PhoenixLifetime<T>::destroyed_ = false;
 
template <typename T>
struct SingleThreaded {
    using VolatileType = T;
    struct Lock {
        Lock() = default;
        explicit Lock(T& /* unused */) {}
    };
};
}  // namespace policy
 
namespace detail
{
// clang-format off
template <
    class T,
    template <class> class CreationPolicy = policy::CreateStatic,
    template <class> class LifetimePolicy = policy::DefaultLifetime,
    template <class> class ThreadingModel = policy::SingleThreaded
>
// clang-format on
class SingletonHolder
{
public:
    using InstanceType = typename ThreadingModel<T>::VolatileType;
 
    SingletonHolder() = delete;
 
    static T& Instance();
 
private:
    static void DestroySingleton();
    static InstanceType* instance_;
    static bool destroyed_;
};
 
}  // namespace detail
}  // namespace smgl
 
#include "smgl/SingletonImpl.hpp"