rpc_object_client.h

Go to the documentation of this file.

 
#pragma once
 
#include "rpc_object_client_intf.h"
#include <adtf_utils.h>
#include <adtfucom3/adtf_ucom3.h>
#include <memory>
 
namespace adtf
{
    namespace remote
    {
        namespace ant
        {
 
            template<typename INTERFACE>
            class rpc_object_client_ptr : public IRPCObjectClientPtr
            {
            private:
                std::shared_ptr<IRPCObjectClient> m_pObjectCLient;
                INTERFACE*                        m_pInterface = nullptr;
 
            public:
                rpc_object_client_ptr() = default;
                rpc_object_client_ptr(const rpc_object_client_ptr& oVal)
                {
                    Reset(oVal.m_pObjectCLient);
                }
                rpc_object_client_ptr& operator=(const rpc_object_client_ptr& oVal)
                {
                    Reset(oVal.m_pObjectCLient);
                    return *this;
                }
                rpc_object_client_ptr(rpc_object_client_ptr&& oVal)
                {
                    std::swap(m_pObjectCLient, oVal.m_pObjectCLient);
                    std::swap(m_pInterface, oVal.m_pInterface);
                }
                rpc_object_client_ptr& operator=(rpc_object_client_ptr&& oVal)
                {
                    std::swap(m_pObjectCLient, oVal.m_pObjectCLient);
                    std::swap(m_pInterface, oVal.m_pInterface);
                    return *this;
                }
 
                rpc_object_client_ptr(const std::shared_ptr<IRPCObjectClient>& pObjectCLient)
                {
                    Reset(pObjectCLient);
                }
                rpc_object_client_ptr& operator=(const std::shared_ptr<IRPCObjectClient>& pObjectCLient)
                {
                    Reset(pObjectCLient);
                    return *this;
                }
 
                ~rpc_object_client_ptr()
                {
                    Reset();
                }
 
                explicit operator bool() const
                {
                    return (m_pInterface != nullptr);
                }
 
                const std::shared_ptr<IRPCObjectClient>& GetObjectClient() const
                {
                    return m_pObjectCLient;
                }
 
                INTERFACE& GetInterface() const
                {
                    return *m_pInterface;
                }
 
                INTERFACE* operator->() const
                {
                    return m_pInterface;
                }
 
                tResult Reset(const std::shared_ptr<IRPCObjectClient>& oObject) override
                {
                    if (oObject)
                    {
                        adtf::util::cString strIID;
                        oObject->GetRPCIID(adtf_string_intf(strIID));
                        if (strIID.IsEqual(adtf::ucom::get_iid<INTERFACE>()))
                        {
                            m_pInterface = dynamic_cast<INTERFACE*>(oObject.get());
                            RETURN_IF_POINTER_NULL(m_pInterface);
                            m_pObjectCLient = oObject;
                        }
                        else
                        {
                            Reset();
                            RETURN_ERROR(ERR_INVALID_INTERFACE);
                        }
                    }
                    else
                    {
                        Reset();
                    }
                    RETURN_NOERROR;
                }
 
                void Reset()
                {
                    m_pInterface = nullptr;
                    m_pObjectCLient.reset();
                }
            };
 
            template<typename INTERFACE, typename RPC_CLIENT_OBJECT_FACTORY>
            rpc_object_client_ptr<INTERFACE> make_rpc_object_client_ptr(const char* strFullURL)
            {
                rpc_object_client_ptr<INTERFACE> oObj;
                RPC_CLIENT_OBJECT_FACTORY::CreateClient(oObj, adtf::ucom::get_iid<INTERFACE>(), strFullURL);
                return oObj;
            }
 
            template<typename INTERFACE, typename RPC_CLIENT_OBJECT_FACTORY>
            rpc_object_client_ptr<INTERFACE> make_rpc_object_client_ptr(const char* strHostURL, const char* strObjectName)
            {
                rpc_object_client_ptr<INTERFACE> oObj;
                RPC_CLIENT_OBJECT_FACTORY::CreateClient(oObj, adtf::ucom::get_iid<INTERFACE>(), strHostURL, strObjectName);
                return oObj;
            }
 
        }
 
        using ant::rpc_object_client_ptr;
        using ant::make_rpc_object_client_ptr;
    }
}