AppDomain.hpp

 
//
//  Copyright PHOENIX CONTACT Electronics GmbH
//
#pragma once
#include "Arp/System/Core/Arp.h"
#include "Arp/System/Core/Singleton.hxx"
#include <map>
#include <stack>
#include <typeinfo>
#include <typeindex>
 
#ifdef ARP_PLATFORM_LINUX
    #include <pthread.h>
#else
    #include <mutex>
#endif
 
 
// forwards
namespace Arp { namespace System { namespace Acf
{
class IApplication;
}}} // end of namesapce Arp::System::Acf
 
namespace Arp
{
 
 
#ifdef ARP_PLATFORM_LINUX
class RdLockGuard // TODO(OR): replace this by std::lock or move it to namespace Arp::Internal of Core
{
public: // construction/destruction
 
    RdLockGuard(pthread_rwlock_t* rw_lock);
 
    RdLockGuard(const RdLockGuard& arg) = delete;
 
    RdLockGuard& operator=(const RdLockGuard& arg) = delete;
 
    ~RdLockGuard(void);
 
private: // fields
    pthread_rwlock_t* rw_lock;
};
 
// inline methods of class Mutex
 
inline RdLockGuard::RdLockGuard(pthread_rwlock_t* rw_lockArg)
    : rw_lock(rw_lockArg)
{
    pthread_rwlock_rdlock(rw_lock);
}
 
inline RdLockGuard::~RdLockGuard()
{
    pthread_rwlock_unlock(rw_lock);
}
 
 
class WrLockGuard
{
public: // construction/destruction
 
    WrLockGuard(pthread_rwlock_t* rw_lock);
 
    WrLockGuard(const WrLockGuard& arg) = delete;
 
    WrLockGuard& operator=(const WrLockGuard& arg) = delete;
 
    ~WrLockGuard(void);
 
private: // fields
    pthread_rwlock_t* rw_lock;
};
 
// inline methods of class WrLockGuard
 
inline WrLockGuard::WrLockGuard(pthread_rwlock_t* rw_lockArg)
    : rw_lock(rw_lockArg)
{
    pthread_rwlock_wrlock(rw_lock);
}
 
inline WrLockGuard::~WrLockGuard()
{
    pthread_rwlock_unlock(rw_lock);
}
#endif //ARP_PLATFORM_LINUX
 
class AppDomain : private Singleton<AppDomain>
{
    friend class Singleton<AppDomain>;
 
public: // usings
    using Strings = std::vector<String>;
    using IApplication = Arp::System::Acf::IApplication;
 
private: // usings
    using SingletonDisposer = void(*)(void);
    using SingletonBase = Singleton<AppDomain>;
    using TypeKey = std::type_index;
    using Singletons = std::map<TypeKey, void*>;
 
private: // construction/destruction
    AppDomain(void);
    AppDomain(const AppDomain& arg) = delete;
    ~AppDomain(void);
 
public: // static getter
    static bool IsCreated(void);
 
    static AppDomain&   GetCurrent(void);
 
public: // static operations
    template<class TApp>
    static TApp&        Create(void);
 
    template<class TApp>
    static TApp&        Create(const String& appName);
 
    template<class TApp>
    static void         Dispose(void);
 
    static void         Assign(AppDomain& other);
 
public: // getter operations
    IApplication&   GetApplication(void);
 
    size_t  GetSingletonsCount(void)const;
 
    Strings GetSingletonsTypeName(void)const;
 
public: // singleton operations
    template<class TSingleton>
    void            AddSingleton(TSingleton* pSingleton);
 
    template<class TSingleton>
    TSingleton&     GetSingleton(void);
 
    template<class TSingleton>
    TSingleton*     GetSingletonPtr(void);
 
    template<class TSingleton>
    bool            RemoveSingleton(void);
 
private: // static methods
    template<class T>
    static TypeKey  GetTypeKey(void);
 
private: // fields
    IApplication*   pApplication;
    Singletons      singletons;
 
#ifdef ARP_PLATFORM_LINUX
    pthread_rwlock_t rw_lock;
#else
    std::mutex rw_lock;
#endif
};
 
// inline methods of class AppDomain
inline AppDomain::AppDomain()
    : pApplication(nullptr)
    , singletons()
{
#ifdef ARP_PLATFORM_LINUX
    pthread_rwlock_init(&this->rw_lock, NULL);
#endif
}
 
inline bool AppDomain::IsCreated(void)
{
    return SingletonBase::IsCreated();
}
 
inline AppDomain& AppDomain::GetCurrent(void)
{
    return SingletonBase::GetInstance();
}
 
template<class T>
inline AppDomain::TypeKey AppDomain::GetTypeKey(void)
{
    return std::type_index(typeid(T));
}
 
template<class TApp>
inline TApp& AppDomain::Create(void)
{
    // create this appDomain instance first
    SingletonBase::CreateInstance();
    // create app singleton next
    TApp::CreateInstance();
    // and get the app instance
    SingletonBase::GetInstance().pApplication = &TApp::GetInstance();
    // return just created app
    return dynamic_cast<TApp&>(TApp::GetInstance());
}
 
template<class TApp>
inline TApp& AppDomain::Create(const String& appName)
{
    // create this appDomain instance first
    SingletonBase::CreateInstance();
    // create app singleton next
    TApp::CreateInstance(appName);
    // and get the app instance
    SingletonBase::GetInstance().pApplication = &TApp::GetInstance();
    // return just created app
    return dynamic_cast<TApp&>(TApp::GetInstance());
}
 
inline void AppDomain::Assign(AppDomain& other)
{
    if (!SingletonBase::IsCreated())
    {
        SingletonBase::AssignInstanceFrom(other);
    }
}
 
template<class TApp>
inline void AppDomain::Dispose(void)
{
    TApp::DisposeInstance();
    SingletonBase::DisposeInstance();
}
 
inline AppDomain::IApplication& AppDomain::GetApplication(void)
{
    return *(this->pApplication);
}
 
inline size_t AppDomain::GetSingletonsCount()const
{
    return this->singletons.size();
}
 
template<class TSingleton>
inline void AppDomain::AddSingleton(TSingleton* pSingleton)
{
#ifdef ARP_PLATFORM_LINUX
    WrLockGuard lock(&this->rw_lock);
#else
    std::lock_guard<std::mutex> lock(this->rw_lock);
#endif
 
 
    auto result = this->singletons.insert(make_pair(AppDomain::GetTypeKey<TSingleton>(), pSingleton));
    if (!result.second)
    {
        throw Exception("AppDomain Singleton of type '{0}' has been added yet", TypeName<TSingleton>());
    }
}
 
template<class TSingleton>
inline TSingleton& AppDomain::GetSingleton()
{
    TSingleton* pResult = this->GetSingletonPtr<TSingleton>();
    if (pResult == nullptr)
    {
        throw Exception("AppDomain does not contain Singleton of type '{0}'", TypeName<TSingleton>().GetFullName());
    }
    return *pResult;
}
template<class TSingleton>
inline TSingleton* AppDomain::GetSingletonPtr()
{
#ifdef ARP_PLATFORM_LINUX
    RdLockGuard lock(&this->rw_lock);
#else
    std::lock_guard<std::mutex> lock(this->rw_lock);
#endif
 
    auto i = this->singletons.find(AppDomain::GetTypeKey<TSingleton>());
    if (i == this->singletons.end())
    {
        return nullptr;
    }
    // else
    return (TSingleton*)(i->second); // is there any other way than a brute force cast?
}
 
template<class TSingleton>
inline bool AppDomain::RemoveSingleton()
{
#ifdef ARP_PLATFORM_LINUX
    WrLockGuard lock(&this->rw_lock);
#else
    std::lock_guard<std::mutex> lock(this->rw_lock);
#endif
 
    return this->singletons.erase(AppDomain::GetTypeKey<TSingleton>()) != 0;
}
 
} // end of namesapce Arp