PTL::Singleton< Type, PointerT > Class Template Reference

Singleton object that allows a deleter class to be specified. More...

#include <Singleton.hh>

Data Structures
struct	persistent_data

Public Types
using	auto_lock_t = std::unique_lock< mutex_t >
using	deleter_t = std::function< void(PointerT &)>
template<bool B, typename T = int>
using	enable_if_t = typename std::enable_if< B, T >::type
using	list_t = std::set< pointer >
using	mutex_t = std::recursive_mutex
using	pointer = Type *
using	smart_pointer = PointerT
using	this_type = Singleton< Type, PointerT >
using	thread_id_t = std::thread::id

Public Member Functions
void	Destroy ()
void	Initialize ()
void	Initialize (pointer)
void	operator delete (void *ptr)
void *	operator new (size_t)
Singleton &	operator= (const Singleton &)=delete
Singleton &	operator= (Singleton &&)=delete
void	Reset ()
void	Reset (pointer)
	Singleton ()
	Singleton (const Singleton &)=delete
	Singleton (pointer)
	Singleton (Singleton &&)=delete
	~Singleton ()

Static Public Member Functions
static list_t	Children ()
static pointer	GetInstance ()
static pointer	GetMasterInstance ()
static thread_id_t	GetMasterThreadID ()
static mutex_t &	GetMutex ()
static void	Insert (pointer)
static bool	IsMaster (pointer ptr)
static bool	IsMasterThread ()
static void	Remove (pointer)

Protected Member Functions
pointer	GetRawInstance ()
smart_pointer &	GetSmartInstance ()

Static Protected Member Functions
static pointer	GetRawMasterInstance ()
static smart_pointer &	GetSmartMasterInstance ()

Private Member Functions
template<typename Tp = Type, typename PtrT = PointerT, enable_if_t<(std::is_same< PtrT, std::shared_ptr< Tp > >::value)> = 0>
deleter_t &	GetDeleter ()
template<typename Tp = Type, typename PtrT = PointerT, enable_if_t<!(std::is_same< PtrT, std::shared_ptr< Tp > >::value)> = 0>
deleter_t &	GetDeleter ()
void	operator delete[] (void *) noexcept
void *	operator new[] (std::size_t) noexcept

Static Private Member Functions
static smart_pointer &	_local_instance ()
static smart_pointer &	_master_instance ()
static list_t &	f_children ()
static pointer &	f_master_instance ()
static thread_id_t &	f_master_thread ()
static mutex_t &	f_mutex ()
static persistent_data &	f_persistent_data ()

Private Attributes
bool	m_IsMaster = false

Friends
class	Type

Detailed Description

template<typename Type, typename PointerT = std::unique_ptr<Type, std::default_delete<Type>>>
class PTL::Singleton< Type, PointerT >

Singleton object that allows a deleter class to be specified.

Definition at line 42 of file Singleton.hh.

Member Typedef Documentation

auto_lock_t

template<typename Type , typename PointerT = std::unique_ptr<Type, std::default_delete<Type>>>

using PTL::Singleton< Type, PointerT >::auto_lock_t = std::unique_lock<mutex_t>

Definition at line 48 of file Singleton.hh.

deleter_t

template<typename Type , typename PointerT = std::unique_ptr<Type, std::default_delete<Type>>>

using PTL::Singleton< Type, PointerT >::deleter_t = std::function<void(PointerT&)>

Definition at line 52 of file Singleton.hh.

enable_if_t

template<typename Type , typename PointerT = std::unique_ptr<Type, std::default_delete<Type>>>

template<bool B, typename T = int>

using PTL::Singleton< Type, PointerT >::enable_if_t = typename std::enable_if<B, T>::type

Definition at line 55 of file Singleton.hh.

list_t

template<typename Type , typename PointerT = std::unique_ptr<Type, std::default_delete<Type>>>

using PTL::Singleton< Type, PointerT >::list_t = std::set<pointer>

Definition at line 50 of file Singleton.hh.

mutex_t

template<typename Type , typename PointerT = std::unique_ptr<Type, std::default_delete<Type>>>

using PTL::Singleton< Type, PointerT >::mutex_t = std::recursive_mutex

Definition at line 47 of file Singleton.hh.

pointer

template<typename Type , typename PointerT = std::unique_ptr<Type, std::default_delete<Type>>>

using PTL::Singleton< Type, PointerT >::pointer = Type*

Definition at line 49 of file Singleton.hh.

smart_pointer

template<typename Type , typename PointerT = std::unique_ptr<Type, std::default_delete<Type>>>

using PTL::Singleton< Type, PointerT >::smart_pointer = PointerT

Definition at line 51 of file Singleton.hh.

this_type

template<typename Type , typename PointerT = std::unique_ptr<Type, std::default_delete<Type>>>

using PTL::Singleton< Type, PointerT >::this_type = Singleton<Type, PointerT>

Definition at line 45 of file Singleton.hh.

thread_id_t

template<typename Type , typename PointerT = std::unique_ptr<Type, std::default_delete<Type>>>

using PTL::Singleton< Type, PointerT >::thread_id_t = std::thread::id

Definition at line 46 of file Singleton.hh.

Constructor & Destructor Documentation

Singleton() [1/4]

template<typename Type , typename PointerT >

PTL::Singleton< Type, PointerT >::Singleton

Definition at line 236 of file Singleton.hh.

{
    Initialize();
}

Singleton() [2/4]

template<typename Type , typename PointerT >

PTL::Singleton< Type, PointerT >::Singleton

(

pointer

ptr

)

Definition at line 244 of file Singleton.hh.

{
    Initialize(ptr);
}

~Singleton()

template<typename Type , typename PointerT >

PTL::Singleton< Type, PointerT >::~Singleton

Definition at line 252 of file Singleton.hh.

{
    auto& del = GetDeleter();
    del(_master_instance());
}

Singleton() [3/4]

template<typename Type , typename PointerT = std::unique_ptr<Type, std::default_delete<Type>>>

PTL::Singleton< Type, PointerT >::Singleton ( const Singleton< Type, PointerT > &  )

delete

Singleton() [4/4]

template<typename Type , typename PointerT = std::unique_ptr<Type, std::default_delete<Type>>>

PTL::Singleton< Type, PointerT >::Singleton ( Singleton< Type, PointerT > &&  )

delete

Member Function Documentation

_local_instance()

template<typename Type , typename PointerT = std::unique_ptr<Type, std::default_delete<Type>>>

static smart_pointer & PTL::Singleton< Type, PointerT >::_local_instance ( )

inlinestaticprivate

Definition at line 121 of file Singleton.hh.

    {
        static thread_local smart_pointer _instance = smart_pointer();
        return _instance;
    }

Referenced by PTL::Singleton< Type, PointerT >::GetRawInstance(), and PTL::Singleton< Type, PointerT >::GetSmartInstance().

_master_instance()

template<typename Type , typename PointerT = std::unique_ptr<Type, std::default_delete<Type>>>

static smart_pointer & PTL::Singleton< Type, PointerT >::_master_instance ( )

inlinestaticprivate

Definition at line 127 of file Singleton.hh.

    {
        static smart_pointer _instance = smart_pointer();
        return _instance;
    }

Referenced by PTL::Singleton< Type, PointerT >::GetSmartMasterInstance().

Children()

template<typename Type , typename PointerT = std::unique_ptr<Type, std::default_delete<Type>>>

static list_t PTL::Singleton< Type, PointerT >::Children ( )

inlinestatic

Definition at line 73 of file Singleton.hh.

{ return f_children(); }

References PTL::Singleton< Type, PointerT >::f_children().

Destroy()

template<typename Type , typename PointerT >

void PTL::Singleton< Type, PointerT >::Destroy

Definition at line 288 of file Singleton.hh.

{
    if(std::this_thread::get_id() == f_master_thread() && f_master_instance())
    {
        delete f_master_instance();
        f_master_instance() = nullptr;
    }
    else
    {
        remove(_local_instance().get());
    }
}

References PTL::get().

f_children()

template<typename Type , typename PointerT >

Singleton< Type, PointerT >::list_t & PTL::Singleton< Type, PointerT >::f_children

staticprivate

Definition at line 228 of file Singleton.hh.

{
    return f_persistent_data().m_children;
}

Referenced by PTL::Singleton< Type, PointerT >::Children().

f_master_instance()

template<typename Type , typename PointerT >

Singleton< Type, PointerT >::pointer & PTL::Singleton< Type, PointerT >::f_master_instance

staticprivate

Definition at line 210 of file Singleton.hh.

{
    return f_persistent_data().m_master_instance;
}

Referenced by PTL::Singleton< Type, PointerT >::GetRawInstance(), PTL::Singleton< Type, PointerT >::GetRawMasterInstance(), and PTL::Singleton< Type, PointerT >::operator delete().

f_master_thread()

template<typename Type , typename PointerT >

Singleton< Type, PointerT >::thread_id_t & PTL::Singleton< Type, PointerT >::f_master_thread

staticprivate

Definition at line 201 of file Singleton.hh.

{
    return f_persistent_data().m_master_thread;
}

Referenced by PTL::Singleton< Type, PointerT >::GetMasterThreadID(), and PTL::Singleton< Type, PointerT >::operator delete().

f_mutex()

template<typename Type , typename PointerT >

Singleton< Type, PointerT >::mutex_t & PTL::Singleton< Type, PointerT >::f_mutex

staticprivate

Definition at line 219 of file Singleton.hh.

{
    return f_persistent_data().m_mutex;
}

Referenced by PTL::Singleton< Type, PointerT >::GetMutex().

f_persistent_data()

template<typename Type , typename PointerT = std::unique_ptr<Type, std::default_delete<Type>>>

static persistent_data & PTL::Singleton< Type, PointerT >::f_persistent_data ( )

inlinestaticprivate

Definition at line 190 of file Singleton.hh.

    {
        static persistent_data _instance;
        return _instance;
    }

GetDeleter() [1/2]

template<typename Type , typename PointerT = std::unique_ptr<Type, std::default_delete<Type>>>

template<typename Tp = Type, typename PtrT = PointerT, enable_if_t<(std::is_same< PtrT, std::shared_ptr< Tp > >::value)> = 0>

deleter_t & PTL::Singleton< Type, PointerT >::GetDeleter ( )

inlineprivate

Definition at line 138 of file Singleton.hh.

    {
        static deleter_t _instance = [](PointerT&) {};
        return _instance;
    }

GetDeleter() [2/2]

template<typename Type , typename PointerT = std::unique_ptr<Type, std::default_delete<Type>>>

template<typename Tp = Type, typename PtrT = PointerT, enable_if_t<!(std::is_same< PtrT, std::shared_ptr< Tp > >::value)> = 0>

deleter_t & PTL::Singleton< Type, PointerT >::GetDeleter ( )

inlineprivate

Definition at line 146 of file Singleton.hh.

    {
        static deleter_t _instance = [](PointerT& _master) {
            auto& del = _master.get_deleter();
            del(_master.get());
            _master.reset(nullptr);
        };
        return _instance;
    }

GetInstance()

template<typename Type , typename PointerT >

Singleton< Type, PointerT >::pointer PTL::Singleton< Type, PointerT >::GetInstance

static

Definition at line 305 of file Singleton.hh.

{
    if(std::this_thread::get_id() == f_master_thread())
        return GetMasterInstance();
    else if(!_local_instance().get())
    {
        _local_instance().reset(new Type());
        Insert(_local_instance().get());
    }
    return _local_instance().get();
}

References PTL::get().

GetMasterInstance()

template<typename Type , typename PointerT >

Singleton< Type, PointerT >::pointer PTL::Singleton< Type, PointerT >::GetMasterInstance

static

Definition at line 321 of file Singleton.hh.

{
    if(!f_master_instance())
    {
        f_master_thread()   = std::this_thread::get_id();
        f_master_instance() = new Type();
    }
    return f_master_instance();
}

GetMasterThreadID()

template<typename Type , typename PointerT = std::unique_ptr<Type, std::default_delete<Type>>>

static thread_id_t PTL::Singleton< Type, PointerT >::GetMasterThreadID ( )

inlinestatic

Definition at line 72 of file Singleton.hh.

{ return f_master_thread(); }

References PTL::Singleton< Type, PointerT >::f_master_thread().

GetMutex()

template<typename Type , typename PointerT = std::unique_ptr<Type, std::default_delete<Type>>>

static mutex_t & PTL::Singleton< Type, PointerT >::GetMutex ( )

inlinestatic

Definition at line 78 of file Singleton.hh.

{ return f_mutex(); }

References PTL::Singleton< Type, PointerT >::f_mutex().

GetRawInstance()

template<typename Type , typename PointerT = std::unique_ptr<Type, std::default_delete<Type>>>

pointer PTL::Singleton< Type, PointerT >::GetRawInstance ( )

inlineprotected

Definition at line 113 of file Singleton.hh.

    {
        return IsMasterThread() ? f_master_instance() : _local_instance().get();
    }

References PTL::Singleton< Type, PointerT >::_local_instance(), PTL::Singleton< Type, PointerT >::f_master_instance(), and PTL::Singleton< Type, PointerT >::IsMasterThread().

GetRawMasterInstance()

template<typename Type , typename PointerT = std::unique_ptr<Type, std::default_delete<Type>>>

static pointer PTL::Singleton< Type, PointerT >::GetRawMasterInstance ( )

inlinestaticprotected

Definition at line 117 of file Singleton.hh.

{ return f_master_instance(); }

References PTL::Singleton< Type, PointerT >::f_master_instance().

Referenced by PTL::Singleton< Type, PointerT >::IsMaster().

GetSmartInstance()

template<typename Type , typename PointerT = std::unique_ptr<Type, std::default_delete<Type>>>

smart_pointer & PTL::Singleton< Type, PointerT >::GetSmartInstance ( )

inlineprotected

Definition at line 109 of file Singleton.hh.

{ return _local_instance(); }

References PTL::Singleton< Type, PointerT >::_local_instance().

GetSmartMasterInstance()

template<typename Type , typename PointerT = std::unique_ptr<Type, std::default_delete<Type>>>

static smart_pointer & PTL::Singleton< Type, PointerT >::GetSmartMasterInstance ( )

inlinestaticprotected

Definition at line 110 of file Singleton.hh.

{ return _master_instance(); }

References PTL::Singleton< Type, PointerT >::_master_instance().

Initialize() [1/2]

template<typename Type , typename PointerT >

void PTL::Singleton< Type, PointerT >::Initialize

Definition at line 262 of file Singleton.hh.

{
    if(!f_master_instance())
    {
        f_master_thread()   = std::this_thread::get_id();
        f_master_instance() = new Type();
    }
}

Initialize() [2/2]

template<typename Type , typename PointerT >

void PTL::Singleton< Type, PointerT >::Initialize

(

pointer

ptr

)

Definition at line 275 of file Singleton.hh.

{
    if(!f_master_instance())
    {
        f_master_thread()   = std::this_thread::get_id();
        f_master_instance() = ptr;
    }
}

Insert()

template<typename Type , typename PointerT >

void PTL::Singleton< Type, PointerT >::Insert ( pointer  itr )

static

Definition at line 380 of file Singleton.hh.

{
    auto_lock_t l(f_mutex());
    f_children().insert(itr);
}

IsMaster()

template<typename Type , typename PointerT = std::unique_ptr<Type, std::default_delete<Type>>>

static bool PTL::Singleton< Type, PointerT >::IsMaster ( pointer  ptr )

inlinestatic

Definition at line 74 of file Singleton.hh.

{ return ptr == GetRawMasterInstance(); }

References PTL::Singleton< Type, PointerT >::GetRawMasterInstance().

IsMasterThread()

template<typename Type , typename PointerT >

bool PTL::Singleton< Type, PointerT >::IsMasterThread

static

Definition at line 371 of file Singleton.hh.

{
    return std::this_thread::get_id() == f_master_thread();
}

Referenced by PTL::Singleton< Type, PointerT >::GetRawInstance().

operator delete()

template<typename Type , typename PointerT = std::unique_ptr<Type, std::default_delete<Type>>>

void PTL::Singleton< Type, PointerT >::operator delete ( void *  ptr )

inline

Definition at line 97 of file Singleton.hh.

    {
        this_type* _instance = (this_type*) (ptr);
        ::delete _instance;
        if(std::this_thread::get_id() == f_master_thread())
            f_master_instance() = nullptr;
    }

References PTL::Singleton< Type, PointerT >::f_master_instance(), and PTL::Singleton< Type, PointerT >::f_master_thread().

operator delete[]()

template<typename Type , typename PointerT = std::unique_ptr<Type, std::default_delete<Type>>>

void PTL::Singleton< Type, PointerT >::operator delete[] ( void *  )

inlineprivatenoexcept

Definition at line 134 of file Singleton.hh.

{}

operator new()

template<typename Type , typename PointerT = std::unique_ptr<Type, std::default_delete<Type>>>

void * PTL::Singleton< Type, PointerT >::operator new ( size_t  )

inline

Definition at line 89 of file Singleton.hh.

    {
        this_type* ptr = ::new this_type();
        return static_cast<void*>(ptr);
    }

operator new[]()

template<typename Type , typename PointerT = std::unique_ptr<Type, std::default_delete<Type>>>

void * PTL::Singleton< Type, PointerT >::operator new[] ( std::size_t  )

inlineprivatenoexcept

Definition at line 133 of file Singleton.hh.

{ return nullptr; }

operator=() [1/2]

template<typename Type , typename PointerT = std::unique_ptr<Type, std::default_delete<Type>>>

Singleton & PTL::Singleton< Type, PointerT >::operator= ( const Singleton< Type, PointerT > &  )

delete

operator=() [2/2]

template<typename Type , typename PointerT = std::unique_ptr<Type, std::default_delete<Type>>>

Singleton & PTL::Singleton< Type, PointerT >::operator= ( Singleton< Type, PointerT > &&  )

delete

Remove()

template<typename Type , typename PointerT >

void PTL::Singleton< Type, PointerT >::Remove ( pointer  itr )

static

Definition at line 390 of file Singleton.hh.

{
    auto_lock_t l(f_mutex());
    for(auto litr = f_children().begin(); litr != f_children().end(); ++litr)
    {
        if(*litr == itr)
        {
            f_children().erase(litr);
            break;
        }
    }
}

Reset() [1/2]

template<typename Type , typename PointerT >

void PTL::Singleton< Type, PointerT >::Reset

Definition at line 359 of file Singleton.hh.

{
    if(IsMasterThread())
        _master_instance().reset();
    _local_instance().reset();
    f_persistent_data().reset();
}

References G4Threading::IsMasterThread().

Reset() [2/2]

template<typename Type , typename PointerT >

void PTL::Singleton< Type, PointerT >::Reset

(

pointer

ptr

)

Definition at line 335 of file Singleton.hh.

{
    if(IsMaster(ptr))
    {
        if(_master_instance().get())
            _master_instance().reset();
        else if(f_master_instance())
        {
            auto& del = GetDeleter();
            del(_master_instance());
            f_master_instance() = nullptr;
        }
        f_persistent_data().reset();
    }
    else
    {
        _local_instance().reset();
    }
}

References PTL::get().

Friends And Related Function Documentation

Type

template<typename Type , typename PointerT = std::unique_ptr<Type, std::default_delete<Type>>>

friend class Type

friend

Definition at line 106 of file Singleton.hh.

Field Documentation

m_IsMaster

template<typename Type , typename PointerT = std::unique_ptr<Type, std::default_delete<Type>>>

bool PTL::Singleton< Type, PointerT >::m_IsMaster = false

private

Definition at line 184 of file Singleton.hh.

---

The documentation for this class was generated from the following file:

• source/externals/ptl/include/PTL/Singleton.hh