interface_binding_proxy.h

Go to the documentation of this file.

#pragma once
#include "named_graph_object.h"
#include "interface_binding_proxy_intf.h"
#include "interface_binding_type.h"
 
namespace adtf
{
namespace streaming
{
namespace ant
{

template<typename INTERFACE, bool INTERFACE_CHECK=true>
class binding_proxy: public named_graph_object<IBindingProxy>
{
 
protected:
    adtf::ucom::object_ptr<INTERFACE>       m_pServerObject;
    adtf::ucom::object_ptr<IBindingType>    m_pBindingType;
    adtf::ucom::object_list<IBindingProxy>  m_lstBindingRoutes;
 
public:
    binding_proxy()
    {
    }

    binding_proxy(const char* strName)
    {
        named_graph_object<IBindingProxy>::SetName(strName);
    }

    binding_proxy(const char* strName, const adtf::ucom::iobject_ptr<const IBindingType>& pBindingType)
    {
        named_graph_object<IBindingProxy>::SetName(strName);
        m_pBindingType = adtf::ucom::make_object_ptr<cBindingType>(*pBindingType.Get());
    }

    virtual ~binding_proxy()
    {
    }

    tResult SetBindingType(const adtf::ucom::iobject_ptr<const IBindingType>& pBindingType)
    {
        m_pBindingType = adtf::ucom::make_object_ptr<cBindingType>(*pBindingType.Get());
        RETURN_IF_POINTER_NULL(m_pBindingType);
        RETURN_NOERROR;
    }
public: //interface IBindingProxy
    
    tResult GetBindingType(adtf::ucom::iobject_ptr<const IBindingType>& pBindingType) const override
    {
        adtf::ucom::reset_object_ptr(pBindingType, m_pBindingType);
        if (!pBindingType.Get())
        {
            RETURN_ERROR_DESC(ERR_POINTER, "Binding proxy has not connected to a binding server");
        }
        RETURN_NOERROR;
    }
 
    tResult GetServerObject(adtf::ucom::iobject_ptr<adtf::ucom::IObject>& pBindingServer) const override
    {
        if (m_pServerObject)
        {
            pBindingServer.Reset(m_pServerObject);
            RETURN_NOERROR;
        }
        else
        {
            RETURN_ERROR(ERR_INVALID_STATE);
        }
    }
 
    tResult BindServerObject(const adtf::ucom::iobject_ptr<adtf::ucom::IObject>& pBindingServer,
                             const adtf::ucom::iobject_ptr<const IBindingType>& pBindingType) override
    {
        if (m_pServerObject)
        {
            RETURN_ERROR_DESC(ERR_DEVICE_IN_USE, "This binding proxy has already been bound to a server.");
        }
 
        if (INTERFACE_CHECK)
        {
            adtf::ucom::object_ptr<INTERFACE> pCheckServer = pBindingServer;
            if (pCheckServer)
            {
                //interface is valid
            }
            else
            {
                RETURN_ERROR(ERR_INVALID_INTERFACE);
            }
        }
        if (m_pBindingType)
        {
            if (!m_pBindingType->IsEqual(*pBindingType.Get()))
            {
                RETURN_ERROR(ERR_INVALID_TYPE);
            }
        }
        m_pBindingType = adtf::ucom::make_object_ptr<cBindingType>(*pBindingType.Get());
        m_pServerObject = pBindingServer;
 
        //Bind to the forwarded proxies
        //Usually this list should be synchronized, but at common the initialization is sequential AND while RL_Running prohibited
        for (auto it : m_lstBindingRoutes)
        {
            it->BindServerObject(m_pServerObject, adtf::ucom::ucom_object_ptr_cast<const IBindingType>(m_pBindingType));
        }
        RETURN_NOERROR;
    }
 
    tResult UnbindServerObject(const adtf::ucom::iobject_ptr<adtf::ucom::IObject>& pBindingServer) override
    {
        if (INTERFACE_CHECK)
        {
            adtf::ucom::object_ptr<INTERFACE> pCheckServer = pBindingServer;
            if (pCheckServer && pCheckServer == m_pServerObject)
            {
                //interface is valid
            }
            else
            {
                RETURN_ERROR(ERR_INVALID_INTERFACE);
            }
        }
        else
        {
            if (m_pServerObject == pBindingServer)
            {
                //interface is valid
            }
            else
            {
                RETURN_ERROR(ERR_INVALID_INTERFACE);
            }
        }
 
        //unbind on forwards
        for (auto it : m_lstBindingRoutes)
        {
            it->UnbindServerObject(m_pServerObject);
        }
 
        m_pServerObject = nullptr;
        m_pBindingType = nullptr;
        RETURN_NOERROR;
    }
 
    tResult AttachRouting(const adtf::ucom::iobject_ptr<IBindingProxy>& pBindingTo) override
    {
        auto it = std::find(m_lstBindingRoutes.begin(), m_lstBindingRoutes.end(), pBindingTo);
        if (it != m_lstBindingRoutes.end())
        {
            //already forwarding
            RETURN_NOERROR;
        }
        else
        {
            if (m_pServerObject)
            {
                RETURN_IF_FAILED(pBindingTo->BindServerObject(m_pServerObject,
                                                              adtf::ucom::ucom_object_ptr_cast<const IBindingType>(m_pBindingType)));
            }
            m_lstBindingRoutes.PushBack(pBindingTo);
            RETURN_NOERROR;
        }
    }
 
    tResult DetachRouting(const adtf::ucom::iobject_ptr<IBindingProxy>& pBindingTo) override
    {
        auto it = std::find(m_lstBindingRoutes.begin(), m_lstBindingRoutes.end(), pBindingTo);
        if (it != m_lstBindingRoutes.end())
        {
            //already forwarding
            RETURN_ERROR(ERR_NOT_FOUND);
        }
        else
        {
            m_lstBindingRoutes.DeleteObject(pBindingTo);
            if (m_pServerObject)
            {
                RETURN_IF_FAILED(pBindingTo->UnbindServerObject(m_pServerObject));
            }
            RETURN_NOERROR;
        }
    }
};

class cDefaultBindingProxy : public binding_proxy<adtf::ucom::ant::IObject, false>
{
 
    public: 
        ADTF_CLASS_ID_NAME(cDefaultBindingProxy,
                           "default_binding_proxy.streaming.adtf.cid",
                           "Binding Proxy");
 
    public:
        cDefaultBindingProxy() {};
        cDefaultBindingProxy(const char* strName)
        {
            named_graph_object::SetName(strName);
        }
        virtual ~cDefaultBindingProxy() = default;
 
};
 
} //namespace ant

using ant::binding_proxy;

using ant::cDefaultBindingProxy;
} //namespace streaming
} //namespace adtf