filtergraphport.h

Go to the documentation of this file.

#pragma once
 
#include "triggerpipe.h"
#include "runner_intf.h"
#include "pin_intf.h"
#include "inpin_intf.h"
#include "outpin_intf.h"
#include "filtergraphport_intf.h"
#include "interface_binding_client_intf.h"
 
#include <adtfbase/runnable_intf.h>
 
#include <memory>
 
namespace adtf
{
namespace streaming
{
namespace ant
{
namespace detail
{
template<typename T, typename U = T>
struct port_router
{
    adtf::ucom::object_ptr<T> m_pFrom;
    std::vector<adtf::ucom::object_ptr<U>> m_oTos;

    port_router() = default;
    ~port_router()
    {
        RemoveTos();
    }

    tResult ResetFrom(const adtf::ucom::ant::iobject_ptr<T>& pFrom)
    {
        if (m_pFrom.Get() == pFrom.Get())
        {
            // we do nothing ... already routing
            // or nullptr == nullptr
        }
        else
        {
            if (m_pFrom)
            {
                if (pFrom.Get())
                {
                    RETURN_ERROR_DESC(ERR_DEVICE_IN_USE,
                                      "This port is already connected to a sample stream / binding proxy.");
                }
 
                for (const auto& pTo : m_oTos)
                {
                    DisconnectRouting(m_pFrom, pTo);
                }
            }
            m_pFrom = pFrom;
            if (m_pFrom)
            {
                for (const auto& pTo : m_oTos)
                {
                    RETURN_IF_FAILED(ConnectRouting(m_pFrom, pTo));
                }
            }
        }
        RETURN_NOERROR;
    }

    tResult AddTo(const adtf::ucom::ant::iobject_ptr<U>& pTo)
    {
        if (std::find(m_oTos.begin(), m_oTos.end(), pTo) != m_oTos.end())
        {
            // we do nothing ... already forwarding
            // or nullptr == nullptr
        }
        else
        {
            if (pTo.Get())
            {
                if (m_pFrom)
                {
                    RETURN_IF_FAILED(ConnectRouting(m_pFrom, pTo));
                }
 
                m_oTos.push_back(pTo);
            }
        }
        RETURN_NOERROR;
    }
 
    void RemoveTos()
    {
        for (const auto& pTo : m_oTos)
        {
            DisconnectRouting(m_pFrom, pTo);
        }
 
        m_oTos.clear();
    }

    tResult ConnectRouting(const adtf::ucom::ant::iobject_ptr<T>& pFrom, const adtf::ucom::ant::iobject_ptr<U>& pTo)
    {
        if (pFrom.Get() != nullptr && pTo.Get() != nullptr)
        {
            LOG_DETAIL("Attach routing '%s' -> '%s'", get_named_graph_object_full_name(*pFrom.Get()).GetPtr(),
                       get_named_graph_object_full_name(*pTo.Get()).GetPtr());
            return pFrom->AttachRouting(pTo);
        }
        else
        {
            RETURN_NOERROR;
        }
    }

    tResult DisconnectRouting(const adtf::ucom::ant::iobject_ptr<T>& pFrom, const adtf::ucom::ant::iobject_ptr<U>& pTo)
    {
        if (pFrom.Get() != nullptr && pTo.Get() != nullptr)
        {
            return pFrom->DetachRouting(pTo);
        }
        else
        {
            RETURN_NOERROR;
        }
    }
};
} // namespace detail

class cFilterGraphDataInPort :
    public trigger_pipe_item<INamedGraphObject,
                             IPin,
                             IInPin,
                             IFilterGraphPort,
                             IFilterGraphDataPort,
                             IFilterGraphDataInPort>
{
private:
    detail::port_router<ISampleStream> m_oStreamRouter;
    std::atomic_bool m_bActive;
 
public:
    cFilterGraphDataInPort();
    cFilterGraphDataInPort(const char* strName);
    virtual ~cFilterGraphDataInPort() override;
 
public:
    tResult InnerConnect(const adtf::ucom::ant::iobject_ptr<ISampleStream>& pSampleStream) override;
    tResult InnerDisconnect() override;
 
public:
    tResult GetType(adtf::ucom::ant::iobject_ptr<const IStreamType>& pStreamType) const override;
 
    bool IsConnected() const override;
    tResult SetActive() override;
    tResult SetInactive() override;
 
    tResult Disconnect() override;
    tResult GetSampleStream(adtf::ucom::ant::iobject_ptr<ISampleStream>& pSampleStream) const override;
 
public:
    tResult Connect(const adtf::ucom::ant::iobject_ptr<ISampleStream>& pSampleStream) override;
};

class cFilterGraphDataOutPort :
    public trigger_pipe_item<INamedGraphObject,
                             IPin,
                             IOutPin,
                             IFilterGraphPort,
                             IFilterGraphDataPort,
                             IFilterGraphDataOutPort>
{
public:
    template<typename T>
    using iobject_ptr = adtf::ucom::ant::iobject_ptr<T>;
 
private:
    detail::port_router<ISampleStream> m_oStreamRouter;
    std::atomic_bool m_bActive;
 
public:
    cFilterGraphDataOutPort();
    cFilterGraphDataOutPort(const char* strName);
    virtual ~cFilterGraphDataOutPort() override;
 
public:
    tResult InnerConnect(const iobject_ptr<ISampleStream>& pSampleStream);
    tResult InnerDisconnect();
 
public:
    tResult Connect(const iobject_ptr<ISampleStream>& pSampleStream) override;
 
public:
    tResult GetType(iobject_ptr<const IStreamType>& pStreamType) const override;
 
    bool IsConnected() const override;
    tResult SetActive() override;
    tResult SetInactive() override;
 
    tResult Disconnect() override;
    tResult GetSampleStream(iobject_ptr<ISampleStream>& pSampleStream) const override;
};

class cFilterGraphServerPort :
    public ucom::catwo::object<IBindingObject,
                               IBindingServer,
                               IFilterGraphPort,
                               IFilterGraphInterfacePort,
                               named_graph_object<IFilterGraphInterfaceServerPort>>
{
public:
    template<typename T>
    using iobject_ptr = adtf::ucom::ant::iobject_ptr<T>;
 
private:
    detail::port_router<IBindingProxy> m_oProxyRouter;
 
public:
    cFilterGraphServerPort();
    cFilterGraphServerPort(const char* strName);
    virtual ~cFilterGraphServerPort() override;
 
public:
    tResult InnerBind(const iobject_ptr<IBindingProxy>& pSampleStream);
    tResult InnerUnbind();
 
public:
    tResult Bind(const iobject_ptr<IBindingProxy>& pBindingProxy);
 
public:
    tResult GetBindingType(iobject_ptr<const IBindingType>& pBindingType) const;
    tResult GetServerObject(iobject_ptr<IObject>& pServerObject) const;
    tResult GetBindingProxy(iobject_ptr<IBindingProxy>& pBindingProxy) const;
    tResult Unbind();
};

class cFilterGraphClientPort :
    public ucom::catwo::object<IBindingObject,
                               IBindingClient,
                               IFilterGraphPort,
                               IFilterGraphInterfacePort,
                               named_graph_object<IFilterGraphInterfaceClientPort>>
{
public:
    template<typename T>
    using iobject_ptr = adtf::ucom::ant::iobject_ptr<T>;
 
private:
    adtf::ucom::object_ptr<IBindingClient> m_pClientRouter;
    adtf::ucom::object_ptr<IBindingProxy> m_pOuterProxy;
 
public:
    cFilterGraphClientPort();
    cFilterGraphClientPort(const char* strName);
    virtual ~cFilterGraphClientPort() override;
 
public:
    tResult InnerBind(const iobject_ptr<IBindingClient>& pClientForward) override;
    tResult InnerUnbind() override;
 
public:
    tResult Bind(const iobject_ptr<IBindingProxy>& pBindingProxy) override;
 
public:
    tResult GetBindingType(iobject_ptr<const IBindingType>& pBindingType) const override;
    tResult GetServerObject(iobject_ptr<IObject>& pServerObject) const override;
    tResult GetBindingProxy(iobject_ptr<IBindingProxy>& pBindingProxy) const override;
    tResult Unbind() override;
};

class cFilterGraphRunnerPort :
    public trigger_pipe_item<INamedGraphObject, IFilterGraphPort, IRunner, IFilterGraphRunnerPort>
{
public:
    template<typename T>
    using iobject_ptr = adtf::ucom::ant::iobject_ptr<T>;
 
public:
    cFilterGraphRunnerPort();
    cFilterGraphRunnerPort(const char* strName);
    virtual ~cFilterGraphRunnerPort() override;
 
public:
    tResult InnerRegisterSubItem(const iobject_ptr<IRunner>& pRunner) override;
    tResult InnerUnregisterSubItem(const iobject_ptr<IRunner>& pRunner) override;
};
 
} // namespace ant
 
namespace flash
{
 
using ant::cFilterGraphRunnerPort;
 
class cFilterGraphDataInPort :
    public trigger_pipe_item<INamedGraphObject,
                             IPin,
                             IInPin,
                             IFilterGraphPort,
                             IFilterGraphDataPort,
                             IFilterGraphDataInPort>
{
public:
    cFilterGraphDataInPort();
    cFilterGraphDataInPort(const char* strName);
    ~cFilterGraphDataInPort() override;
 
public:
    tResult InnerConnect(const ucom::ant::iobject_ptr<ant::ISampleStream>& pSampleStream) override;
    tResult InnerDisconnect() override;
 
public:
    tResult GetType(ucom::ant::iobject_ptr<const ant::IStreamType>& pStreamType) const override;
 
    bool IsConnected() const override;
    tResult SetActive() override;
    tResult SetInactive() override;
 
    tResult Disconnect() override;
    tResult GetSampleStream(ucom::ant::iobject_ptr<ant::ISampleStream>& pSampleStream) const override;
 
public:
    tResult Connect(const ucom::ant::iobject_ptr<ant::ISampleStream>& pSampleStream) override;
 
protected:
    class cImplementation;
    std::unique_ptr<cImplementation> m_pImplementation;
};
 
class cFilterGraphDataOutPort :
    public trigger_pipe_item<INamedGraphObject,
                             IPin,
                             IOutPin,
                             IFilterGraphPort,
                             IFilterGraphDataPort,
                             IFilterGraphDataOutPort>
{
public:
    cFilterGraphDataOutPort();
    cFilterGraphDataOutPort(const char* strName);
    ~cFilterGraphDataOutPort() override;
 
public:
    tResult InnerConnect(const ucom::ant::iobject_ptr<ant::ISampleStream>& pSampleStream) override;
    tResult InnerDisconnect() override;
 
public:
    tResult GetType(ucom::ant::iobject_ptr<const ant::IStreamType>& pStreamType) const override;
 
    bool IsConnected() const override;
    tResult SetActive() override;
    tResult SetInactive() override;
 
    tResult Disconnect() override;
    tResult GetSampleStream(ucom::ant::iobject_ptr<ant::ISampleStream>& pSampleStream) const override;
 
public:
    tResult Connect(const ucom::ant::iobject_ptr<ant::ISampleStream>& pSampleStream) override;
 
protected:
    class cImplementation;
    std::unique_ptr<cImplementation> m_pImplementation;
};
 
} // namespace flash
 
namespace hollow
{

class cFilterGraphClientPort :
    public ucom::catwo::object<IBindingObject,
                               IBindingClient,
                               IFilterGraphPort,
                               IFilterGraphInterfacePort,
                               named_graph_object<IFilterGraphInterfaceClientPort>>
{
public:
    cFilterGraphClientPort();
    cFilterGraphClientPort(const char* strName);
    virtual ~cFilterGraphClientPort() override;
 
public:
    tResult InnerBind(const ucom::ant::iobject_ptr<IBindingClient>& pClientForward) override;
    tResult InnerUnbind() override;
 
public:
    tResult Bind(const ucom::ant::iobject_ptr<IBindingProxy>& pBindingProxy) override;
 
public:
    tResult GetBindingType(ucom::ant::iobject_ptr<const IBindingType>& pBindingType) const override;
    tResult GetServerObject(ucom::ant::iobject_ptr<IObject>& pServerObject) const override;
    tResult GetBindingProxy(ucom::ant::iobject_ptr<IBindingProxy>& pBindingProxy) const override;
    tResult Unbind() override;
 
protected:
    class cImplementation;
    std::unique_ptr<cImplementation> m_pImplementation;
};
 
} // namespace hollow
 
namespace quiet
{

using flash::cFilterGraphRunnerPort;

using flash::cFilterGraphDataInPort;

using flash::cFilterGraphDataOutPort;
 
} // namespace quiet

using quiet::cFilterGraphRunnerPort;
using quiet::cFilterGraphDataInPort;
using quiet::cFilterGraphDataOutPort;
using ant::cFilterGraphServerPort;
using hollow::cFilterGraphClientPort;
} // namespace streaming
} // namespace adtf