graph_utils.h

Go to the documentation of this file.

#pragma once
 
#include "graph.h"
#include "samplestream.h"
#include "interface_binding_proxy.h"
#include "filtergraphport.h"
#include "samplestreaminport.h"
#include "samplestreamoutport.h"
#include "data_binding_intf.h"
#include "interface_binding_intf.h"
#include "runtime_behaviour_intf.h"
#include <memory>
 
namespace adtf
{
 
namespace streaming
{
 
namespace devil
{
inline tResult add_graph_object(ant::cGraph& oGraph,
                                const util::cString& strCID,
                                const util::cString& strName,
                                const std::map<util::cString, util::cString>& oProperties,
                                int32_t nOrderNumber,
                                ucom::iobject_ptr<ucom::IObject>& pObject)
{
    ucom::object_ptr<ant::INamedGraphObject> pNewObject;
    RETURN_IF_FAILED(_runtime->CreateInstance(strCID, pNewObject));
    RETURN_IF_FAILED(pNewObject->SetName(strName));
    if (!oProperties.empty())
    {
        auto pConfiguration = ucom::ucom_cast<base::IConfiguration*>(pNewObject.Get());
        for (const auto& oProperty: oProperties)
        {
            base::set_property_by_path<util::cString>(*pConfiguration, oProperty.first, oProperty.second);
        }
    }
 
    RETURN_IF_FAILED(oGraph.AddNamedGraphObject(pNewObject, nOrderNumber));
    return pObject.Reset(pNewObject);
}

inline tResult add_graph_object(ant::cGraph& oGraph,
                                const util::cString& strCID,
                                const util::cString& strName,
                                const std::map<util::cString, util::cString>& oProperties = {},
                                int32_t nOrderNumber = 0)
{
    ucom::object_ptr<ucom::IObject> pObject;
    return add_graph_object(oGraph, strCID, strName, oProperties, nOrderNumber, pObject);
}
 
inline tResult add_sample_stream(ant::cGraph& oGraph,
                                 const util::cString& strName,
                                 int32_t nOrderNumber,
                                 ucom::iobject_ptr<ucom::IObject>& pSampleStream)
{
    ucom::object_ptr<ant::INamedGraphObject> pNewSampleStream = ucom::make_object_ptr<cSampleStream>(strName);
    RETURN_IF_FAILED(oGraph.AddNamedGraphObject(pNewSampleStream, nOrderNumber));
    return pSampleStream.Reset(pNewSampleStream);
}

inline tResult add_sample_stream(ant::cGraph& oGraph,
                                 const util::cString& strName,
                                 int32_t nOrderNumber = 0)
{
    ucom::object_ptr<ucom::IObject> pSampleStream;
    return add_sample_stream(oGraph, strName, nOrderNumber, pSampleStream);
}

inline tResult add_binding_proxy(ant::cGraph& oGraph,
                                 const util::cString& strName,
                                 int32_t nOrderNumber,
                                 ucom::iobject_ptr<ucom::IObject>& pBindingProxy)
{
    ucom::object_ptr<ant::INamedGraphObject> pNewBindingProxy = ucom::make_object_ptr<cDefaultBindingProxy>(strName);
    RETURN_IF_FAILED(oGraph.AddNamedGraphObject(pNewBindingProxy, nOrderNumber));
    return pBindingProxy.Reset(pNewBindingProxy);
}

inline tResult add_binding_proxy(cGraph& oGraph, const util::cString& strName, int32_t nOrderNumber = 0)
{
    ucom::object_ptr<ucom::IObject> pBindingProxy;
    return add_binding_proxy(oGraph, strName, nOrderNumber, pBindingProxy);
}

inline tResult add_data_out_port(ant::cGraph& oGraph,
                                 const util::cString& strName,
                                 int32_t nOrderNumber,
                                 ucom::iobject_ptr<ucom::IObject>& pPort)
{
    ucom::object_ptr<ant::INamedGraphObject> pNewPort = ucom::make_object_ptr<cFilterGraphDataOutPort>(strName);
    RETURN_IF_FAILED(oGraph.AddNamedGraphObject(pNewPort, nOrderNumber));
    return pPort.Reset(pNewPort);
}

inline tResult add_data_out_port(ant::cGraph& oGraph,
                                 const util::cString& strName,
                                 int32_t nOrderNumber = 0)
{
    ucom::object_ptr<ucom::IObject> pPort;
    return add_data_out_port(oGraph, strName, nOrderNumber, pPort);
}

inline tResult add_data_in_port(ant::cGraph& oGraph,
                                 const util::cString& strName,
                                 int32_t nOrderNumber,
                                 ucom::iobject_ptr<ucom::IObject>& pPort)
{
    ucom::object_ptr<ant::INamedGraphObject> pNewPort = ucom::make_object_ptr<cFilterGraphDataInPort>(strName);
    RETURN_IF_FAILED(oGraph.AddNamedGraphObject(pNewPort, nOrderNumber));
    return pPort.Reset(pNewPort);
}

inline tResult add_data_in_port(ant::cGraph& oGraph,
                                 const util::cString& strName,
                                 int32_t nOrderNumber = 0)
{
    ucom::object_ptr<ucom::IObject> pPort;
    return add_data_in_port(oGraph, strName, nOrderNumber, pPort);
}

inline tResult add_sample_stream_out_port(ant::cGraph& oGraph,
                                 const util::cString& strName,
                                 const util::cString& strPortID,
                                 int32_t nOrderNumber,
                                 ucom::iobject_ptr<ucom::IObject>& pPort)
{
    ucom::object_ptr<ant::INamedGraphObject> pNewPort = ucom::make_object_ptr<cSampleStreamOutPort>(strName, strPortID);
    RETURN_IF_FAILED(oGraph.AddNamedGraphObject(pNewPort, nOrderNumber));
    return pPort.Reset(pNewPort);
}

inline tResult add_sample_stream_out_port(ant::cGraph& oGraph,
                                 const util::cString& strName,
                                 const util::cString& strPortID,
                                 int32_t nOrderNumber = 0)
{
    ucom::object_ptr<ucom::IObject> pPort;
    return add_sample_stream_out_port(oGraph, strName, strPortID, nOrderNumber, pPort);
}

inline tResult add_sample_stream_in_port(ant::cGraph& oGraph,
                                 const util::cString& strName,
                                 const util::cString& strPortID,
                                 int32_t nOrderNumber,
                                 ucom::iobject_ptr<ucom::IObject>& pPort)
{
    ucom::object_ptr<ant::INamedGraphObject> pNewPort = ucom::make_object_ptr<cSampleStreamInPort>(strName, strPortID);
    RETURN_IF_FAILED(oGraph.AddNamedGraphObject(pNewPort, nOrderNumber));
    return pPort.Reset(pNewPort);
}

inline tResult add_sample_stream_in_port(ant::cGraph& oGraph,
                                 const util::cString& strName,
                                 const util::cString& strPortID,
                                 int32_t nOrderNumber = 0)
{
    ucom::object_ptr<ucom::IObject> pPort;
    return add_sample_stream_in_port(oGraph, strName, strPortID, nOrderNumber, pPort);
}
 
} // END of namespace devil.
 
namespace hollow
{

inline void get_data_binding_objects(ant::IDataBinding* pDataBinding,
                                      ucom::ant::iobject_enum<adtf::ucom::ant::IObject>& oObjects)
{
    adtf::ucom::object_vector<IPin> oPins;
    pDataBinding->GetPins(oPins);
    for (auto& pPin: oPins)
    {
        oObjects.PushObject(pPin);
    }
}

inline void get_interface_binding_objects(ant::IInterfaceBinding* pInterfaceBinding,
                                           ucom::ant::iobject_enum<adtf::ucom::ant::IObject>& oObjects)
{
    adtf::ucom::object_vector<IBindingObject> oBindingObjects;
    pInterfaceBinding->GetBindingObjects(oBindingObjects);
    for (auto& pBindingObject: oBindingObjects)
    {
        oObjects.PushObject(pBindingObject);
    }
}

inline void get_runner_objects(ant::IRuntimeBehaviour* pRuntimeBehaviour, ucom::ant::iobject_enum<ucom::ant::IObject>& oObjects)
{
    adtf::ucom::object_vector<IRunner> oRunnerObjects;
    pRuntimeBehaviour->GetRunners(oRunnerObjects);
    for (auto& pRunner: oRunnerObjects)
    {
        oObjects.PushObject(pRunner);
    }
}

void get_child_objects(ant::INamedGraphObject& oObject, ucom::ant::iobject_enum<ucom::ant::IObject>& oObjects);

inline void get_graph_objects(ant::IGraph* pGraph,
                               ucom::ant::iobject_enum<ucom::ant::IObject>& oObjects)
{
    adtf::ucom::object_vector<INamedGraphObject> oChildren;
    pGraph->GetNamedGraphObjects(oChildren);
    for (auto& pChild: oChildren)
    {
        oObjects.PushObject(pChild);
        get_child_objects(*pChild, oObjects);
    }
}

inline void get_child_objects(ant::INamedGraphObject& oObject,
                               ucom::ant::iobject_enum<ucom::ant::IObject>& oObjects)
{
    using namespace adtf::ucom;
    auto pDataBinding = ucom_cast<IDataBinding*>(&oObject);
    if (pDataBinding)
    {
        get_data_binding_objects(pDataBinding, oObjects);
    }
 
    auto pInterfaceBinding = ucom_cast<IInterfaceBinding*>(&oObject);
    if (pInterfaceBinding)
    {
        get_interface_binding_objects(pInterfaceBinding, oObjects);
    }
 
    auto pRuntimeBehaviour = ucom_cast<IRuntimeBehaviour*>(&oObject);
    if (pRuntimeBehaviour)
    {
        get_runner_objects(pRuntimeBehaviour, oObjects);
    }
 
    auto pGraph = ucom_cast<IGraph*>(&oObject);
    if (pGraph)
    {
        get_graph_objects(pGraph, oObjects);
    }
}
 
} // END of namespace hollow.
 
using devil::add_graph_object;
using devil::add_binding_proxy;
using devil::add_data_in_port;
using devil::add_data_out_port;
using devil::add_sample_stream;
using devil::add_sample_stream_in_port;
using devil::add_sample_stream_out_port;
 
using hollow::get_child_objects;
using hollow::get_graph_objects;
using hollow::get_runner_objects;
using hollow::get_data_binding_objects;
using hollow::get_interface_binding_objects;
 
} // END of namespace streaming.
 
} // END of namespace adtf.