filterbase.h

Go to the documentation of this file.

#pragma once
#include "filter_levelmachine.h"
#include "runtime_behaviour.h"
#include "interface_binding.h"
#include "data_binding.h"
#include "named_graph_object.h"
#include "reference_clock_intf.h"
#include "triggerpipe.h"
#include "runner.h"
#include "interface_binding_object.h"
 
namespace adtf
{
namespace streaming
{
namespace ant
{
 

class cFilterBase:
    public ucom::catwo::object<cFilterLevelmachine,
                               ucom::ant::cClassInfo,
                               runtime_behaviour<interface_binding<data_binding<named_graph_object<IFilter>>>>>
{
    A_UTILS_D(cFilterBase)
 
    public:
        typedef cFilterLevelmachine::tInitStage tInitStage;
 
    protected:

        ucom::object_ptr<services::ant::IReferenceClock>   _clock;
 
 
    public:
        cFilterBase();
        virtual ~cFilterBase();
 
    public: //overwrites cFilterBaseLevelmachine
        tResult Init(tInitStage eStage) override;
        tResult Shutdown(tInitStage eStage) override;
        tResult Start() override;
        tResult Stop() override;    
 
    public: // implements IFilter
        IFilter::tFilterState GetState() const override;

        tResult SetState(IFilter::tFilterState eState) override;
 
        
    public: //overwrites cDataBinding
        tResult RegisterPin(const ucom::ant::iobject_ptr<IPin>& pPin) override;

        using cDataBinding::RegisterPin;
        tResult UnregisterPin(const ucom::ant::iobject_ptr<IPin>& pPin) override;
 
    public: //overwrites cInterfaceBinding
        using cInterfaceBinding::RegisterBindingObject;
        tResult RegisterBindingObject(const ucom::ant::iobject_ptr<IBindingObject>& pBindingObject) override;
 
    public: //implements cFilterBase
        using cRuntimeBehaviour::RegisterRunner;
        using cRuntimeBehaviour::RegisterInnerPipe;
        tResult RegisterRunner(const ucom::ant::iobject_ptr<IRunner>& pBindingObject) override;
};
 
 

template <typename DATABINDING_BEHAVIOUR_CLASS>
inline tResult create_inner_pipe(DATABINDING_BEHAVIOUR_CLASS& oComponent,
                                 adtf_util::cStringList lstItems)
{
    adtf::ucom::ant::object_list<ITriggerPipeItem> lstListOfItemsForPipe;
    for (const auto& itElem : lstItems)
    {
        adtf::ucom::ant::object_ptr<ITriggerPipeItem> pCurrentItem;
        if (IS_FAILED(oComponent.FindPin(itElem, pCurrentItem)))
        {
            if (IS_FAILED(oComponent.FindRunner(itElem, pCurrentItem)))
            {
                RETURN_ERROR(ERR_NOT_FOUND);
            }
        }
        lstListOfItemsForPipe.PushObject(pCurrentItem);
    }
    adtf::ucom::ant::object_ptr<ITriggerPipe> pInnerPipe;
    RETURN_IF_FAILED(create_trigger_pipe("generated_pipe", pInnerPipe, lstListOfItemsForPipe));
    RETURN_IF_FAILED(oComponent.RegisterInnerPipe(pInnerPipe));
    return pInnerPipe->Open();
}

template <typename DATABINDING_BEHAVIOUR_CLASS, typename RUN_FUNC>
tResult create_inner_pipe(DATABINDING_BEHAVIOUR_CLASS& oComponent,
                          const adtf_util::cString& strNameOfRunner,
                          const adtf_util::cString& strSource,
                          RUN_FUNC&& oRunFunc)
{
    adtf::ucom::ant::object_list<ITriggerPipeItem> lstListOfItemsForPipe;
    adtf::ucom::ant::object_ptr<ITriggerPipeItem>  pCurrentItem;
    if (IS_FAILED(oComponent.FindPin(strSource, pCurrentItem)))
    {
        if (IS_FAILED(oComponent.FindRunner(strSource, pCurrentItem)))
        {
            RETURN_ERROR(ERR_NOT_FOUND);
        }
    }
    lstListOfItemsForPipe.PushObject(pCurrentItem);
    ucom::object_ptr<IRunner> pRunner = ucom::make_object_ptr<cRunner>(strNameOfRunner, std::forward<RUN_FUNC>(oRunFunc));
    RETURN_IF_FAILED(oComponent.RegisterRunner(pRunner));
 
    lstListOfItemsForPipe.PushObject(ucom::ucom_object_ptr_cast<ITriggerPipeItem>(pRunner));
 
    adtf::ucom::ant::object_ptr<ITriggerPipe> pInnerPipe;
    RETURN_IF_FAILED(create_trigger_pipe("generated_pipe", pInnerPipe, lstListOfItemsForPipe));
    RETURN_IF_FAILED(oComponent.RegisterInnerPipe(pInnerPipe));
    return pInnerPipe->Open();
}

template<typename INTERFACE>
tResult create_server(cFilterBase& oFilter,
                      const char* strServerName,
                      const adtf::ucom::iobject_ptr<INTERFACE>& pServerInterface)
{
    using namespace adtf::ucom;
    object_ptr<IBindingServer> pBindingServer = make_object_ptr<cBindingServer>(strServerName,
                                                                    object_ptr<const IBindingType>(make_object_ptr<binding_type<INTERFACE>>()),
                                                                    ucom_object_ptr_cast<IObject>(pServerInterface));
    RETURN_IF_FAILED(oFilter.RegisterBindingObject(pBindingServer));
    RETURN_NOERROR;
}

template<typename INTERFACE>
tResult create_client(cFilterBase& oFilter, const char* strClientName)
{
    using namespace adtf::ucom;
    object_ptr<IBindingClient> pBindingClient = make_object_ptr<cBindingClient>(strClientName,
        object_ptr<const IBindingType>(make_object_ptr<binding_type<INTERFACE>>()));
    RETURN_IF_FAILED(oFilter.RegisterBindingObject(pBindingClient));
    RETURN_NOERROR;
}

inline tResult create_runner(cFilterBase& oFilter, 
    const char* strNameOfRunner,
    adtf::base::ant::IRunnable& oRunnable)
{
    return oFilter.RegisterRunner(strNameOfRunner, oRunnable);
}
 
 
} //namespace ant
 
namespace flash
{
 
using ant::create_inner_pipe;

template<typename Interface, typename InterfaceBinding>
tResult create_server(InterfaceBinding& oInterfaceBinding,
                      const char* strServerName,
                      const adtf::ucom::iobject_ptr<Interface>& pServerInterface)
{
    using namespace adtf::ucom;
    object_ptr<IBindingServer> pBindingServer = make_object_ptr<cBindingServer>(strServerName,
                                                                    object_ptr<const IBindingType>(make_object_ptr<binding_type<Interface>>()),
                                                                    ucom_object_ptr_cast<IObject>(pServerInterface));
    RETURN_IF_FAILED(oInterfaceBinding.RegisterBindingObject(pBindingServer));
    RETURN_NOERROR;
}

template<typename Interface, typename InterfaceBinding>
tResult create_client(InterfaceBinding& oInterfaceBinding, const char* strClientName)
{
    using namespace adtf::ucom;
    object_ptr<IBindingClient> pBindingClient = make_object_ptr<cBindingClient>(strClientName,
        object_ptr<const IBindingType>(make_object_ptr<binding_type<Interface>>()));
    RETURN_IF_FAILED(oInterfaceBinding.RegisterBindingObject(pBindingClient));
    RETURN_NOERROR;
}
 
}

using ant::cFilterBase;
using flash::create_inner_pipe;
using flash::create_server;
using flash::create_client;
using ant::create_runner;
 
} //namespace streaming
} //namespace adtf