AppDomainSingleton.hxx

 
//
//  Copyright Phoenix Contact GmbH & Co. KG
//
#pragma once
 
#ifndef ARP_USE_ARP_SYSTEM_CORE
 
#include "Arp/Base/Core/AppDomainSingleton.hxx"
 
#else
 
#include "Arp/System/Core/Arp.h"
#include "Arp/System/Core/Singleton.hxx"
#include "Arp/System/Core/AppDomain.hpp"
 
namespace Arp
{
 
template <class Derived>
class AppDomainSingleton
{
protected: // typedefs
    typedef AppDomainSingleton<Derived> SingletonBase; // for use in derived classes
 
private: // typedefs
    typedef Derived     Instance;
 
protected: // construction/destruction
    AppDomainSingleton(void) = default;
    ~AppDomainSingleton(void) = default;
 
public: // static operations
    template <class T = Instance, class ...Args>
    static Derived & CreateInstance(Args && ... args);
 
    static bool     IsCreated(void);
 
    static Derived& GetInstance(void);
 
    ARP_DEPRECATED("Use &GetInstance() instead.")
    static Derived* GetInstancePtr(void);
 
    static void     DisposeInstance(void);
 
private:
    static Derived* GetInstancePtrInternal(void);
 
private: // deleted methods to avoid copying
    AppDomainSingleton(const AppDomainSingleton& arg) = delete;
    AppDomainSingleton& operator=(const AppDomainSingleton& arg) = delete;
};
 
// inline methods of class AppDomainSingleton<T>
template <class Derived>
template <class T, class ...Args>
inline Derived& AppDomainSingleton<Derived>::CreateInstance(Args&& ... args)
{
    Derived* pInstance = GetInstancePtrInternal();
    // create instance first
    if(pInstance != nullptr)
    {
        throw Exception("AppDomain Singleton instance of type '{0}' was created yet!", TypeName<Derived>());
    }
    // else
    pInstance = new T(std::forward<Args>(args)...);
    // and add it to appDomains singleton collection
    AppDomain::GetInstance().AddSingleton(pInstance);
 
    return *pInstance;
}
 
template <class Derived>
inline bool AppDomainSingleton<Derived>::IsCreated(void)
{
    if (!AppDomain::IsCreated())
    {
        return false;
    }
    // else
    return AppDomainSingleton::GetInstancePtrInternal() != nullptr;
}
 
template <class Derived>
inline Derived& AppDomainSingleton<Derived>::GetInstance()
{
    Derived* pResult = GetInstancePtrInternal();
    if (!IsCreated())
    {
        throw Exception("AppDomain Singleton instance of type '{0}' was not created yet!", TypeName<Derived>());
    }
    return *pResult;
}
 
template <class Derived>
inline Derived* AppDomainSingleton<Derived>::GetInstancePtr()
{
    return GetInstancePtrInternal();
}
 
template <class Derived>
inline Derived* AppDomainSingleton<Derived>::GetInstancePtrInternal()
{
    return AppDomain::GetCurrent().GetSingletonPtr<Derived>(); // might return nullptr
}
 
template <class Derived>
inline void AppDomainSingleton<Derived>::DisposeInstance()
{
    // destroy instance
    delete GetInstancePtrInternal();
    // and remove singleton from appDomain
    AppDomain::GetInstance().RemoveSingleton<Derived>();
}
 
} // end of namesapce Arp
 
#endif // ndef ARP_USE_ARP_SYSTEM_CORE