graph.h

Go to the documentation of this file.

#pragma once
#include "named_graph_object.h"
#include "graph_intf.h"
 
namespace adtf
{
namespace streaming
{
namespace ant
{
class cGraph 
{
    private:
        std::map<adtf_util::cString, ucom::object_ptr<INamedGraphObject>> m_oGraphObjects;
        std::multimap<int32_t, ucom::object_ptr<INamedGraphObject>>        m_oObjectOrder;
 
    public:
        cGraph() = default;
        virtual ~cGraph();
 
    public: //implements IGraph
        tResult GetNamedGraphObject(const char* strName, ucom::ant::iobject_ptr<ucom::ant::IObject>& pObject) const;
        tResult GetNamedGraphObjects(ucom::ant::iobject_list<INamedGraphObject>& lstItems) const;
 
    public:
        virtual tResult AddNamedGraphObject(const ucom::ant::iobject_ptr<INamedGraphObject>& pGraphObject,
                                            int32_t ui32OrderNumber);
        tResult RemoveNamedGraphObject(const char* strName);

        virtual tResult RemoveNamedGraphObject(const ucom::ant::iobject_ptr<INamedGraphObject>& pGraphObject);
 
    protected:
        tResult CheckName(const adtf_util::cString& strObjectName);
 
        template <typename OBJECT_INTERFACE>
        tResult AddObject(const ucom::ant::iobject_ptr<OBJECT_INTERFACE>& pGraphObject, int32_t ui32OrderNumber)
        {
            adtf::ucom::ant::object_ptr<INamedGraphObject> pNamedObject = pGraphObject;
            RETURN_IF_POINTER_NULL(pNamedObject);
            return AddNamedGraphObject(pNamedObject, ui32OrderNumber);
        }
 
       // tResult RemoveConnection(const adtf::ucom::ant::iobject_ptr<IGraphConnection>& pConnection);
        tResult RemoveAllConnectionsFrom(const INamedGraphObject* pObj);
 
        tResult AddAlias(const char* strAliasName, const ucom::ant::iobject_ptr<INamedGraphObject>& pGraphObject);
        tResult GetAliasObjects(ucom::ant::iobject_list<INamedGraphObject>& lstItems) const;
 
    private:
        template <typename OBJECT_INTERFACE>
        tResult EraseObject(const ucom::ant::iobject_ptr<OBJECT_INTERFACE>& pGraphObject);
};

template <typename INTERFACE = IGraph>
class graph : public cGraph,
              public ucom::catwo::object<IGraph, INTERFACE>
{
public:
    graph() = default;
    virtual ~graph() = default;
    
public:
    tResult GetNamedGraphObject(const char* strName, ucom::ant::iobject_ptr<adtf::ucom::ant::IObject>& pObject) const override
    {
        return cGraph::GetNamedGraphObject(strName, pObject);
    }
    tResult GetNamedGraphObjects(ucom::ant::iobject_list<INamedGraphObject>& lstItems) const override
    {
        return cGraph::GetNamedGraphObjects(lstItems);
    }
 
    tResult AddNamedGraphObject(const ucom::ant::iobject_ptr<INamedGraphObject>& pGraphObject,
                                int32_t ui32OrderNumber) override
    {
        RETURN_IF_FAILED(cGraph::AddNamedGraphObject(pGraphObject, ui32OrderNumber));
        pGraphObject.Get()->SetParent(static_cast<ucom::ant::IObject*>(static_cast<INamedGraphObject*>(this)));
        RETURN_NOERROR;
    }
};
 
template<typename CONNECTOR,
         typename INTERFACE = IGraphConnection>
class graph_connection : public ucom::catwo::object<IGraphConnection, named_graph_object<INTERFACE>>
{
protected:    
    bool     m_bConnected = false;
 
    ucom::weak_object_ptr<INamedGraphObject> m_pSource;
    ucom::weak_object_ptr<INamedGraphObject> m_pDest;
    adtf_util::cString                      m_strSourceName;
    adtf_util::cString                      m_strSourceConnectorName;
    adtf_util::cString                      m_strDestinationName;
    adtf_util::cString                      m_strDestinationConnectorName;
    bool                                   m_bConnectRunner;
    
protected:
    graph_connection(const graph_connection&) = delete;
    graph_connection(graph_connection&&) = delete;
    graph_connection& operator=(const graph_connection&) = delete;
    graph_connection& operator=(graph_connection&&) = delete;
 
public:
    graph_connection() = default;
 
    graph_connection(const char* strName,
                     const char* strSource,
                     const char* strSourceConnector,
                     const char* strDest,
                     const char* strDestConnector,
                     const ucom::ant::iobject_ptr<INamedGraphObject>& pSource,
                     const ucom::ant::iobject_ptr<INamedGraphObject>& pDest,
                     bool bConnectRunner)
    {
        THROW_IF_FAILED_DESC(CONNECTOR::IsSupported(pSource,
                                                    strSourceConnector,
                                                    pDest,
                                                    strDestConnector),
                             "The connection from %s.%s to %s.%s is not supported.",
                             strSource,
                             strSourceConnector,
                             strDest,
                             strDestConnector);
 
        named_graph_object<INTERFACE>::SetName(strName);
        m_strSourceName = strSource;
        m_strSourceConnectorName = strSourceConnector;
        m_strDestinationName = strDest;
        m_strDestinationConnectorName = strDestConnector;
        m_pSource = pSource;
        m_pDest   = pDest;
        m_bConnectRunner = bConnectRunner;
 
        LOG_DUMP("Init CONNECTION %s.%s -> %s.%s ", strSource, strSourceConnector, strDest, strDestConnector);
    }
    
    virtual ~graph_connection()
    {
        if (m_bConnected)
        {
            Disconnect();
        }
    }
 
    tResult Connect() override
    {
        auto pSource = m_pSource.Lock();
        auto pDest   = m_pDest.Lock();
        if (pSource && pDest)
        {
            adtf_util::cString oSourceName;
            pSource->GetName(adtf_string_intf(oSourceName));
 
            adtf_util::cString oDestName;
            pDest->GetName(adtf_string_intf(oDestName));
            LOG_DETAIL("Connecting CONNECTION %s.%s -> %s.%s ",
                     oSourceName.GetPtr(),
                     m_strSourceConnectorName.GetPtr(),
                     oDestName.GetPtr(),
                     m_strDestinationConnectorName.GetPtr());
 
            tResult nRes = CONNECTOR::Connect(pSource,
                m_strSourceConnectorName,
                pDest,
                m_strDestinationConnectorName,
                m_bConnectRunner);
            if (IS_FAILED(nRes))
            {
                RETURN_ERROR_DESC(nRes.GetErrorCode(), 
                                  "Can not connect %s.%s with %s.%s - %s", 
                                  m_strSourceName.GetPtr(),
                                  m_strSourceConnectorName.GetPtr(),
                                  m_strDestinationName.GetPtr(),
                                  m_strDestinationConnectorName.GetPtr(),
                                  nRes.GetDescription());
            }
        }
        else
        {
            RETURN_ERROR_DESC(ERR_NOT_FOUND,
                              "Can not connect %s.%s with %s.%s, "
                              "a connection point disappeared ??",
                              m_strSourceName.GetPtr(),
                              m_strSourceConnectorName.GetPtr(),
                              m_strDestinationName.GetPtr(),
                              m_strDestinationConnectorName.GetPtr());
        }
        m_bConnected = true;
        RETURN_NOERROR;
    }
 
    tResult Disconnect() override
    {
        //we set the state to disconnected also if it fails
        m_bConnected = false;
        auto pSource = m_pSource.Lock();
        auto pDest   = m_pDest.Lock();
 
        if (pSource && pDest)
        {
            RETURN_IF_FAILED(CONNECTOR::Disconnect(pSource,
                m_strSourceConnectorName,
                pDest,
                m_strDestinationConnectorName,
                m_bConnectRunner));
        }
        RETURN_NOERROR;
    }
 
    tResult GetSource(ucom::ant::iobject_ptr<INamedGraphObject>& pSource) const override
    {
        auto pNO = m_pSource.Lock();
        if (pNO)
        {
            return pSource.Reset(pNO);
        }
        RETURN_ERROR(ERR_NOT_FOUND);
    }
    tResult GetSourceName(base::ant::IString&& strName) const override
    {
        return strName.Set(m_strSourceName);
    }
 
    tResult GetSourceConnectorName(base::ant::IString&& strName) const override
    {
        return strName.Set(m_strSourceConnectorName);
    }
 
    tResult GetDestination(ucom::ant::iobject_ptr<INamedGraphObject>& pDestination) const override
    {
        auto pNO = m_pDest.Lock();
        if (pNO)
        {
            return pDestination.Reset(pNO);
        }
        RETURN_ERROR(ERR_NOT_FOUND);
    }
 
    tResult GetDestinationName(base::ant::IString&& strName) const override
    {
        return strName.Set(m_strDestinationName);
    }
 
    tResult GetDestinationConnectorName(base::ant::IString&& strName) const override
    {
        return strName.Set(m_strDestinationConnectorName);
    }
 
    bool IsConnected() const override
    {
        return m_bConnected;
    }
};
 

tResult get_named_graph_object_from_graph(IGraph& oGraph, const char* strName, ucom::ant::iobject_ptr<ucom::ant::IObject>& pObjectFound);

adtf_util::cString get_named_graph_object_full_name(const INamedGraphObject& oGraphObject);

adtf_util::cString get_named_graph_object_full_name(const INamedGraphObject& oGraphObject, const char* strSeperator);
 
 
} //namespace ant

using ant::cGraph;
using ant::graph;
 
using ant::graph_connection;
 
using ant::get_named_graph_object_from_graph;
using ant::get_named_graph_object_full_name;
 
 
}
}