mn_atomic_singleton.hpp

Go to the documentation of this file.

 
#ifndef __MINLIB_ATOMIC_SINGLETON_H__
#define __MINLIB_ATOMIC_SINGLETON_H__
 
#include "mn_config.hpp"
 
#include "mn_atomic.hpp"
#include "mn_autolock.hpp"
#include "mn_copyable.hpp"
 
 
namespace mn {
 
    template < typename T>
    class basic_atomic_singleton {
        friend class T;
    public:
        using value_type = T;
        using reference = value_type&;
        using pointer = T*;
        using self_type = basic_atomic_singleton<T>;
 
        basic_atomic_singleton(self_type&& other) = delete;
        basic_atomic_singleton(const self_type&) = delete;
 
        static reference instance() {
            pointer _tmp = m_pInstance.load (memory_order::Consume);
            if(!_tmp) {
                automutx_t lock(m_tLock);
 
                _tmp = m_pInstance.load (memory_order::Consume);
                if( !_tmp ) {
                    _tmp = new T();
                    m_pInstance.store (_tmp, memory_order::Release);
                }
            }
            return tmp;
        }
    private:
        static mn::_atomic<pointer> m_pInstance;
        static mn::mutex_t  m_tLock;
    };
 
    template < typename T >
    mn::_atomic<T*> basic_atomic_singleton<T>::m_pInstance;
 
    template < typename T >
    mn::mutex_t basic_atomic_singleton<T>::m_tLock;
 
    template <typename T>
    using atomic_singleton = basic_atomic_singleton<T>;
}
 
 
#endif