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;
                }
            }
        };
    }
 
    class cFilterGraphDataInPort:
        public ucom::catwo::object<IPin,
                                   IInPin,
                                   IFilterGraphPort,
                                   IFilterGraphDataPort,
                                   named_graph_object<trigger_pipe_item<IFilterGraphDataInPort>>>
    {
 
    private:
        detail::port_router<ISampleStream> m_oStreamRouter;
        std::atomic_bool                   m_bActive; 
 
    public:
        cFilterGraphDataInPort() = default;
        cFilterGraphDataInPort(const char* strName);
        virtual ~cFilterGraphDataInPort() = default;
 
    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 ucom::catwo::object<IPin,
                                   IOutPin,
                                   IFilterGraphPort,
                                   IFilterGraphDataPort,
                                   named_graph_object<trigger_pipe_item<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() = default;
        cFilterGraphDataOutPort(const char* strName);
        virtual ~cFilterGraphDataOutPort() = default;
 
    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() = default;
        cFilterGraphServerPort(const char* strName);
        virtual ~cFilterGraphServerPort() = default;
 
    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() = default;
        cFilterGraphClientPort(const char* strName);
        virtual ~cFilterGraphClientPort() = default;
 
    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 ucom::catwo::object<IRunner,
                                   IFilterGraphPort,
                                   trigger_pipe_item<named_graph_object<IFilterGraphRunnerPort>>>
    {
 
        public:
            template <typename T>
            using iobject_ptr = adtf::ucom::ant::iobject_ptr < T >;   
 
        public:
            cFilterGraphRunnerPort() = default;
            cFilterGraphRunnerPort(const char* strName);
            virtual ~cFilterGraphRunnerPort() = default;
 
        public:
            tResult InnerRegisterSubItem(const iobject_ptr<IRunner>& pRunner) override;
            tResult InnerUnregisterSubItem(const iobject_ptr<IRunner>& pRunner) override;
    };
 
} // namespace ant
 
namespace flash
{
 
class cFilterGraphRunnerPort: public ucom::catwo::object<base::ant::IRunnable,
                                                         ant::ITriggerPipeSource,
                                                         ant::ITriggerPipeItem,
                                                         ant::INamedGraphObject,
                                                         ant::IRunner,
                                                         ant::IFilterGraphPort,
                                                         ant::IFilterGraphRunnerPort,
                                                         base::flash::IRunnable>
{
    public:
        cFilterGraphRunnerPort();
        cFilterGraphRunnerPort(const char* strName);
        ~cFilterGraphRunnerPort() override;
 
        tResult InnerRegisterSubItem(const ucom::ant::iobject_ptr<ant::IRunner>& pRunner) override;
        tResult InnerUnregisterSubItem(const ucom::ant::iobject_ptr<ant::IRunner>& pRunner) override;
 
        ADTF_FLASH_TRIGGER_PIPE_ITEM_METHOD_DECLARATIONS
 
    protected:
        class cImplementation;
        std::unique_ptr<cImplementation> m_pImplementation;
};
 
 
class cFilterGraphDataInPort: public ucom::catwo::object<base::ant::IRunnable,
                                                         ant::ITriggerPipeSource,
                                                         ant::ITriggerPipeItem,
                                                         ant::INamedGraphObject,
                                                         IPin,
                                                         IInPin,
                                                         IFilterGraphPort,
                                                         IFilterGraphDataPort,
                                                         IFilterGraphDataInPort,
                                                         base::flash::IRunnable>
{
    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;
 
    public:
        ADTF_FLASH_TRIGGER_PIPE_ITEM_METHOD_DECLARATIONS
 
    protected:
        class cImplementation;
        std::unique_ptr<cImplementation> m_pImplementation;
};
 
class cFilterGraphDataOutPort: public ucom::catwo::object<base::ant::IRunnable,
                                                         ant::ITriggerPipeSource,
                                                         ant::ITriggerPipeItem,
                                                         ant::INamedGraphObject,
                                                         IPin,
                                                         IOutPin,
                                                         IFilterGraphPort,
                                                         IFilterGraphDataPort,
                                                         IFilterGraphDataOutPort,
                                                         base::flash::IRunnable>
{
    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;
 
    public:
        ADTF_FLASH_TRIGGER_PIPE_ITEM_METHOD_DECLARATIONS
 
    protected:
        class cImplementation;
        std::unique_ptr<cImplementation> m_pImplementation;
};
 
}
 
namespace hollow
{
 
class cFilterGraphClientPort:
    public ucom::catwo::object<IBindingObject,
                               IBindingClient,
                               IFilterGraphPort,
                               IFilterGraphInterfacePort,
                               named_graph_object<IFilterGraphInterfaceClientPort>>
{
public:
    cFilterGraphClientPort();
    cFilterGraphClientPort(const char* strName);
    virtual ~cFilterGraphClientPort() = default;
 
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 quiet
{
 
class cFilterGraphRunnerPort: public ucom::catwo::object<flash::cFilterGraphRunnerPort,
                                                         ITriggerPipeHierachy>
{
    public:
        cFilterGraphRunnerPort();
        cFilterGraphRunnerPort(const char* strName);
        ~cFilterGraphRunnerPort() override;
 
        ADTF_QUIET_TRIGGER_PIPE_ITEM_METHOD_DECLARATIONS
};
 
class cFilterGraphDataInPort: public ucom::catwo::object<flash::cFilterGraphDataInPort,
                                                         ITriggerPipeHierachy>
{
    public:
        cFilterGraphDataInPort();
        cFilterGraphDataInPort(const char* strName);
        ~cFilterGraphDataInPort() override;
 
        ADTF_QUIET_TRIGGER_PIPE_ITEM_METHOD_DECLARATIONS
};
 
class cFilterGraphDataOutPort: public ucom::catwo::object<flash::cFilterGraphDataOutPort,
                                                          ITriggerPipeHierachy>
{
    public:
        cFilterGraphDataOutPort();
        cFilterGraphDataOutPort(const char* strName);
        ~cFilterGraphDataOutPort() override;
 
        ADTF_QUIET_TRIGGER_PIPE_ITEM_METHOD_DECLARATIONS
};
 
}
 
using quiet::cFilterGraphRunnerPort;
using quiet::cFilterGraphDataInPort;
using quiet::cFilterGraphDataOutPort;
using ant::cFilterGraphServerPort;
using hollow::cFilterGraphClientPort;
} // namespace streaming
} // namespace adtf