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)
{
    if (serviceProviderName == nullptr || strlen(serviceProviderName) == 0)
    {
        throw ArgumentNullException::Create("serviceProviderName");
    }
    ServiceManager::PublishService(serviceProviderName, TService::GetProxyFactory().GetServiceName(), TServiceFactory::GetInstance());
}

template<class TService, class TServiceFactory>
inline void ServiceManager::PublishRemotingService(const char* serviceProviderName)
{
    if (serviceProviderName == nullptr || strlen(serviceProviderName) == 0)
    {
        throw ArgumentNullException::Create("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)
{
    if (serviceProviderName == nullptr || strlen(serviceProviderName) == 0)
    {
        throw ArgumentNullException::Create("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)
{
    if (serviceProviderName == nullptr || strlen(serviceProviderName) == 0)
    {
        throw ArgumentNullException::Create("serviceProviderName");
    }

    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)
{
    if (serviceProviderName == nullptr || strlen(serviceProviderName) == 0)
    {
        throw ArgumentNullException::Create("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