Singleton.hpp

[詳解]

#pragma once
 
#include <cassert>
#include <mutex>
#include <functional>
 
namespace Kisaragi_Lib
{
    /// <summary>
    /// mozc�� Singleton�p�^�[��
    /// 
    /// �g�p�� :
    /// hoge& hoge = Singleton<hpge>::GetInstance();
    /// </summary>
    class SingletonFinalizer {
    public:
        //�ʖ���`
        using FinalizerFunc = std::function<void()>;
 
        /// <summary>
        /// Finalize��o�^.
        /// </summary>
        /// <param name="func">Finalize</param>
        static void addFinalizer(FinalizerFunc func);
 
        /// <summary>
        /// �o�^���ꂽFinalize�����s����.
        /// </summary>
        static void finalize();
    };
 
    template <typename T>
    class Singleton final {
    public:
        /// <summary>
        /// T�^�̃C���X�^���X���擾����.
        /// </summary>
        /// <returns>T�^�̃C���X�^���X</returns>
        static T& GetInstance() {
            std::call_once(initFlag, create);
            assert(instance);
            return *instance;
        }
 
        //TODO weak_ptr�ł���K�v���ɋ^�₪�c��
        /// <summary>
        /// T�^�̃C���X�^���Xptr���擾
        /// </summary>
        /// <returns></returns>
        static std::weak_ptr<T> GetPtr()
        {
            std::call_once(initFlag, create);
            assert(instance);
            return instance;
        }
 
    private:
        /// <summary>
        /// �C���X�^���X����.
        /// </summary>
        static void create() {
            instance = std::make_shared<T>();
            SingletonFinalizer::addFinalizer(&Singleton<T>::destroy);
        }
 
        /// <summary>
        /// �C���X�^���X�폜
        /// </summary>
        static void destroy() {
            instance.reset();
        }
 
        static std::once_flag initFlag;
        static std::shared_ptr<T> instance;
    };
 
    template <typename T> std::once_flag Singleton<T>::initFlag;
    template <typename T> std::shared_ptr<T> Singleton<T>::instance;
}