ServiceManager.hpp

 
//
//  Copyright Phoenix Contact GmbH & Co. KG
//
#pragma once
#include "Arp/Base/Core/Arp.hpp"
#include "Arp/Base/Core/CommonTypeName.hxx"
#include "Arp/Base/Rsc/Commons/Rsc.hpp"
#include "Arp/Base/Rsc/Commons/IRscService.hpp"
#include "Arp/Base/Commons/Exceptions/InvalidCastException.hpp"
#include "Arp/Base/Commons/Exceptions/InvalidOperationException.hpp"
 
// forwards
namespace Arp::Base::Rsc::Commons::Services
{
class IRscServiceFactory;
class IRscServiceProxyFactory;
}
 
namespace Arp::Base::Rsc
{
 
// imports
using Arp::Base::Rsc::Commons::IRscService;
using Arp::Base::Rsc::Commons::Services::IRscServiceFactory;
using Arp::Base::Rsc::Commons::Services::IRscServiceProxyFactory;
 
class ARP_EXPORT ServiceManager
{
public: // forwards
    class Impl;
 
public: // construction
    ServiceManager(void) = delete; 
 
public: // static service operations
    template<class TService> static typename TService::Ptr  GetService(void);
    template<class TService> static typename TService::Ptr  GetService(const char* serviceProviderName);
    template<class TService> static bool                    TryGetService(typename TService::Ptr& result);
    template<class TService> static bool                    TryGetService(const char* serviceProviderName, typename TService::Ptr& result);
 
    template<class TService, class TServiceFactory> static void PublishService(void);
    template<class TService, class TServiceFactory> static void PublishService(const char* serviceProviderName);
 
    static void PublishComponentService(const char* componentName, const char* serviceName, IRscServiceFactory* pServiceFactory);
 
public: // internal operations
    static Impl& GetImpl(void);
 
private: // methods
    static IRscService::Ptr GetServiceInternal(IRscServiceProxyFactory& proxyFactory, const char* serviceProviderName = nullptr);
    static void             PublishServiceInternal(const char* serviceProviderName, const char* serviceName, IRscServiceFactory& serviceFactory);
};
 
// inline methods of class ServiceManager
 
template<class TService>
inline typename TService::Ptr ServiceManager::GetService()
{
    typename TService::Ptr result;
    if (!ServiceManager::TryGetService<TService>(result))
    {
        throw InvalidOperationException("Could not retrieve service '{0}'.", TypeName<TService>());
    }
    return result;
}
 
template<class TService>
inline typename TService::Ptr ServiceManager::GetService(const char* serviceProviderName)
{
    typename TService::Ptr result;
    if (!ServiceManager::TryGetService<TService>(serviceProviderName, result))
    {
        throw InvalidOperationException("Could not retrieve service '{0}' from service provider '{1}'.", TypeName<TService>(), serviceProviderName);
    }
    return result;
}
 
template<class TService>
inline bool ServiceManager::TryGetService(typename TService::Ptr& result)
{
    return ServiceManager::TryGetService<TService>("", result);
}
 
template<class TService>
inline bool ServiceManager::TryGetService(const char* serviceProviderName, typename TService::Ptr& result)
{
    IRscService::Ptr servicePtr = ServiceManager::GetServiceInternal(TService::GetProxyFactory(), serviceProviderName);
 
    if (servicePtr == nullptr)
    {
        return false; // not found
    }
    result = dynamic_pointer_cast<TService>(servicePtr);
    if (result == nullptr)
    {
        // error: wrong type
        throw InvalidCastException("The retrieved service does not implement service interface '{0}'.", TypeName<TService>());
    }
    // else
    return true;
}
 
template<class TService, class TServiceFactory>
inline void ServiceManager::PublishService()
{
    String serviceProviderName = TServiceFactory::GetInstance().GetServiceProviderName();
    ServiceManager::PublishServiceInternal(serviceProviderName, CommonTypeName<TService>().GetFullName(), TServiceFactory::GetInstance());
}
 
template<class TService, class TServiceFactory>
inline void ServiceManager::PublishService(const char* serviceProviderName)
{
    ServiceManager::PublishServiceInternal(serviceProviderName, CommonTypeName<TService>().GetFullName(), TServiceFactory::GetInstance());
}
 
} // end of namespace Arp::Base::Rsc