RscClient.hpp

 
//
//  Copyright PHOENIX CONTACT Electronics GmbH
//
#pragma once
#include "Arp/System/Core/Arp.h"
#include "Arp/System/Rsc/Services/Rsc.h"
#include "Arp/System/Security/SecurityToken.hpp"
 
// forwards
namespace CommonRemoting
{
class RemotingClient;
class RemotingSession;
}
 
// forwards
namespace Arp { namespace System { namespace Rsc { namespace Client
{
class RemoteServiceManager;
}}}}
 
namespace Arp { namespace System { namespace Rsc { namespace Services
{
 
// forwards
class IRscServiceProxy;
 
class RscClient
{
public: // forwards/friends
    class ITransaction;
 
private: // forwards/friends
    class IpcTransaction;
    friend class IpcTransaction;
    friend class Arp::System::Rsc::Client::RemoteServiceManager;
 
public: // usings
    using Ptr = std::shared_ptr<RscClient>;
    using RemotingClient = CommonRemoting::RemotingClient;
    using RemotingSession = CommonRemoting::RemotingSession;
    using RemotingClientPtr = std::shared_ptr<RemotingClient>;
    using ITransactionPtr = std::shared_ptr<ITransaction>;
    using SecurityToken = Arp::System::Security::SecurityToken;
 
public: // nested class TransactionGuard
    class TransactionGuard
    {
    public:
        TransactionGuard(RscClient& client, IRscServiceProxy& proxy);
        TransactionGuard(const TransactionGuard&) = delete;
        TransactionGuard(TransactionGuard&&) = delete;
        TransactionGuard& operator=(const TransactionGuard&) = delete;
        TransactionGuard& operator=(TransactionGuard&&) = delete;
        ~TransactionGuard(void);
 
    private:
        RscClient&          client;
        IRscServiceProxy&   proxy;
    };
 
public: // nested interface ITransaction
    class ITransaction
    {
    public:
        virtual ~ITransaction(void) = default;
        virtual void Begin(IRscServiceProxy& proxy) = 0;
        virtual void End(IRscServiceProxy& proxy) = 0;
    };
 
public: // construction/destruction
    RscClient(const String& appName, RemotingClientPtr remotingClientPtr);
    RscClient(const String& url, RemotingClientPtr remotingClientPtr, ITransactionPtr transactionPtr);
    RscClient(const RscClient& arg) = delete;
    RscClient(RscClient&& arg)noexcept = default;
    RscClient& operator=(const RscClient& arg) = delete;
    RscClient& operator=(RscClient&& arg)noexcept = default;
    ~RscClient(void);
 
public: // setter/getter operations
    bool                IsConnected(void)const;
    RemotingSession&    GetSession(void) const;
 
public: // operations
    void        Authenticate(SecurityToken securityToken);
    RscHandle   GetServiceProviderHandle(const char* serviceProviderName);
    RscHandle   GetServiceHandle(RscHandle serviceProviderHandle, const char* serviceName);
    RscHandle   GetServiceHandle(const char* serviceProviderName, const char* serviceName);
    void        GetServiceHandles(const char* serviceProviderName, const char* serviceName, RscHandle& serviceProviderHandle, RscHandle& serviceHandle);
    void        Close(bool disconnectRemoting = true); // same as Disconnect
 
private: // methods
    void        BeginTransaction(IRscServiceProxy& proxy);
    void        EndTransaction(IRscServiceProxy& proxy);
    void        BeginRemotingTransaction(void);
    void        EndRemotingTransaction(void);
 
private: // fields
    String              url;
    RemotingClientPtr   remotingClientPtr;
    ITransactionPtr     transactionPtr;
};
 
// inline methods of class RemotingClient::TransactionGuard
inline RscClient::TransactionGuard::TransactionGuard(RscClient& client, IRscServiceProxy& proxy)
    : client(client)
    , proxy(proxy)
{
    this->client.BeginTransaction(this->proxy);
}
 
inline RscClient::TransactionGuard::~TransactionGuard()
{
    this->client.EndTransaction(this->proxy);
}
 
}}}} // end of namespace Arp::System::Rsc::Services