ServiceManager.hpp

//
//  Copyright PHOENIX CONTACT Electronics GmbH
//
#pragma once
#include "Arp/System/Core/Arp.h"
#include "Arp/System/Rsc/Services/Rsc.h"
#include "Arp/System/Rsc/Services/IRscService.hpp"
#include "Arp/System/Rsc/Services/IRscServiceProxy.hpp"
#include "Arp/System/Rsc/Services/IRscServiceFactory.hpp"
#include "Arp/System/Rsc/Services/IRscServiceProxyFactory.hpp"
 
// forwards
namespace CommonRemoting
{
class IService;
class IServiceFactory;
class IServiceProxyFactory;
class CRemotingServiceProviderBase;
}
 
namespace Arp { namespace System { namespace Rsc
{
 
using namespace CommonRemoting;
using namespace Arp::System::Rsc::Services;
 
class ServiceManager
{
private: // deleted construction/destruction
    ServiceManager(void) = delete;
    ServiceManager(const ServiceManager& arg) = delete;
    ServiceManager& operator=(const ServiceManager& arg) = delete;
    ~ServiceManager(void) = delete;
 
public: // static Rsc service operations
    template<class TService, class TServiceFactory>
    static void PublishService(void);
 
    template<class TService, class TServiceFactory>
    static void PublishService(const char* serviceProviderName);
 
    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);
 
public: // static Remoting service operations
    static void PublishComponentService(const char* componentName, const char* serviceName, IRscServiceFactory* pServiceFactory);
 
    static void PublishRemotingServiceProvider(CRemotingServiceProviderBase* pServiceProvider);
 
    template<class TService, class TServiceFactory>
    static void PublishRemotingService(const char* serviceProviderName);
 
    template<class TService>
    static typename TService::Ptr GetRemotingService(const char* serviceProviderName);
 
private: // Rsc service methods
    static void             PublishService(const char* serviceProviderName, const char* serviceName, IRscServiceFactory& serviceFactory);
    static void             PublishService(const char* serviceProviderName, const char* serviceName, IServiceFactory& serviceFactory);
    static IRscService*     GetService(const char* serviceProviderName, IRscServiceProxyFactory& proxyFactory);
    static IService*        GetService(const char* serviceProviderName, IServiceProxyFactory& proxyFactory);
};
 
// inline methods of class ServiceManager
 
template<class TService, class TServiceFactory>
inline void ServiceManager::PublishService(void)
{
    String serviceProviderName = TServiceFactory::GetInstance().GetServiceProviderName();
    ServiceManager::PublishService(serviceProviderName, TService::GetProxyFactory().GetServiceName(), TServiceFactory::GetInstance());
}
 
template<class TService, class TServiceFactory>
inline void ServiceManager::PublishService(const char* serviceProviderName)
{
    ServiceManager::PublishService(serviceProviderName, TService::GetProxyFactory().GetServiceName(), TServiceFactory::GetInstance());
}
 
template<class TService, class TServiceFactory>
inline void ServiceManager::PublishRemotingService(const char* serviceProviderName)
{
    ServiceManager::PublishService(serviceProviderName, TService::GetProxyFactory().GetServiceName(), TServiceFactory::GetInstance());
}
 
template<class TService>
inline typename TService::Ptr ServiceManager::GetService()
{
    String serviceProviderName = TService::GetProxyFactory().GetServiceProviderName();
    if (serviceProviderName.IsEmpty())
    {
        throw ArgumentException::Create("TService", TService::GetProxyFactory().GetServiceName(), "Service does not specify a service provider");
    }
    typename TService::Ptr result;
    if (!ServiceManager::TryGetService<TService>(serviceProviderName, result))
    {
        throw InvalidOperationException("Could not retrieve service '{0}' from service provider '{1}'.", TypeName<TService>().Value, serviceProviderName);
    }
    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>().Value, serviceProviderName);
    }
    return result;
}
 
template<class TService>
inline bool ServiceManager::TryGetService(typename TService::Ptr& result)
{
    const String& serviceProviderName = TService::GetProxyFactory().GetServiceProviderName();
    if (serviceProviderName.IsEmpty())
    {
        throw ArgumentException::Create("TService", TService::GetProxyFactory().GetServiceName(), "Service does not specify a service provider");
    }
    // else
    return ServiceManager::TryGetService<TService>(serviceProviderName, result);
}
 
template<class TService>
inline bool ServiceManager::TryGetService(const char* serviceProviderName, typename TService::Ptr& result)
{
    IRscService* pService = ServiceManager::GetService(serviceProviderName, TService::GetProxyFactory());
 
    if (pService == nullptr)
    {
        return false; // not found
    }
    TService* pResult = dynamic_cast<TService*>(pService);
    if (pResult == nullptr)
    {
        // error: wrong type
        throw InvalidCastException("The service does not implement service interface '{0}'.", TService::GetProxyFactory().GetServiceName());
    }
    // else
    result = typename TService::Ptr(pResult);
    return true;
}
 
template<class TService>
inline typename TService::Ptr ServiceManager::GetRemotingService(const char* serviceProviderName)
{
    IService* pService = ServiceManager::GetService(serviceProviderName, TService::GetProxyFactory());
    if (pService == nullptr)
    {
        return typename TService::Ptr(); // not found
    }
    TService* pResult = dynamic_cast<TService*>(pService);
    if (pResult == nullptr)
    {
        // error: wrong type
        throw InvalidCastException("The service does not implement service interface '{0}'.", TService::GetProxyFactory().GetServiceName());
    }
    // else
    return typename TService::Ptr(pResult);
}
 
}}} // end of namespace Arp::System::Rsc