filter.h

Go to the documentation of this file.

#pragma once
#include "graph_object.h"
 
#include <adtfbase/configuration.h>
#include <adtfstreaming3/filterbase.h>
#include <adtfstreaming3/samplereader.h>
#include <adtfstreaming3/samplewriter.h>
#include <adtfstreaming3/inpin_intf.h>
#include <adtfstreaming3/outpin_intf.h>
#include <adtfstreaming3/pin_creation.h>
#include <adtfstreaming3/samplestreamer_intf.h>
 
#include <memory>
 
namespace adtf
{
namespace filter
{
namespace ant
{

class cConfigurableFilter : public ucom::catwo::object<streaming::ant::cFilterBase,
                                                       base::ant::configuration<>>
 
{
 
public:
    typedef base::ant::configuration<>  base_type_conf;
    typedef streaming::ant::cFilterBase base_type_filter;
 
protected:
    cConfigurableFilter() = default;
    virtual ~cConfigurableFilter() = default;
 
public:
    tResult GetProperties(ucom::ant::iobject_ptr<const base::ant::IProperties>& pProperties) const override
    {
        return base_type_conf::GetProperties(pProperties);
    }

    tResult GetProperties(ucom::ant::iobject_ptr<base::ant::IProperties>& pProperties) override
    {
        return base_type_conf::configuration::GetProperties(pProperties);
    }

    tResult AttachConfiguration(const char* strName, base::ant::IConfiguration& oAttachedConfiguration) override
    {
        return base_type_conf::configuration::AttachConfiguration(strName, oAttachedConfiguration);
    }

    tResult DetachConfiguration(const char* strName) override
    {
        return base_type_conf::configuration::DetachConfiguration(strName);
    }
};
 

using cPinWriter = adtf::streaming::ant::cSampleWriter;

template <typename DATA_TYPE>
using pin_writer = adtf::streaming::ant::sample_writer<DATA_TYPE>;

using cPinReader = adtf::streaming::ant::cDynamicSampleReader;

template<tTimeStamp TIME_RANGE, bool STORELASTSAMPLE = true>
using time_limited_pin_reader = adtf::streaming::ant::time_limited_sample_reader<TIME_RANGE, STORELASTSAMPLE>;

template<size_t MAX_SIZE, bool STORELASTSAMPLE = true>
using size_limited_pin_reader = adtf::streaming::ant::size_limited_sample_reader<MAX_SIZE, STORELASTSAMPLE>;
 

class cFilter : public cConfigurableFilter
{
    A_UTILS_D(cFilter)
 
public:
    using tInitStage   = streaming::ant::cFilterBase::tInitStage;
 
protected:
    ADTF3_DEPRECATED("Triggerfunctions have been superseded by using the API of flash::cFilter.")
    cFilter();
    virtual ~cFilter() override;
 
public:
 
    tResult RegisterRunner(const char* strName, adtf::base::ant::IRunnable& oRunnable) override;

    tResult ConfigureDataInTrigger(const char* strRunnerName, const char* strPinName);
    tResult ConfigureDataOutTrigger(const char* strRunnerName, const char* strPinName);

    tResult ConfigureTimerTrigger(const char* strRunnerName, tTimeStamp tmPeriod);
    tResult ConfigureThreadTrigger(const char* strRunnerName, bool bCallCyclic);
 
};

template<typename READERWRITERTYPE, typename PINTYPE>
tResult filter_create_pin_with_exact_name(cFilter& oFilter, READERWRITERTYPE& oReaderWriter, ucom::ant::iobject_ptr<PINTYPE>& pPinType)
{
    adtf::util::cString strName;
    oReaderWriter.GetName(adtf_string_intf(strName));
    ucom::ant::object_ptr<const adtf::streaming::ant::IStreamType> pType;
    oReaderWriter.GetType(pType);
    return streaming::ant::create_pin<cFilter>(oFilter, oReaderWriter, strName, pType, pPinType);
}

template<typename READERWRITERTYPE>
tResult filter_create_pin_with_exact_name(cFilter& oFilter, READERWRITERTYPE& oReaderWriter)
{
    adtf::util::cString strName;
    oReaderWriter.GetName(adtf_string_intf(strName));
    ucom::object_ptr<const adtf::streaming::ant::IStreamType> pType;
    oReaderWriter.GetType(pType);
    return streaming::ant::create_pin<cFilter>(oFilter, oReaderWriter, strName, pType);
}
 
 
template<typename READERWRITERTYPE, typename PINTYPE>
tResult filter_create_pin(cFilter& oFilter, READERWRITERTYPE& oReaderORWriter, ucom::ant::iobject_ptr<PINTYPE>& pPin)
{
    using namespace adtf::streaming::ant;
    adtf_util::cString strNameOfReaderAndPin;
    oReaderORWriter.GetName(adtf_string_intf(strNameOfReaderAndPin));
    int nCurrentTry = 1;
    while (true)
    {
        tResult nRes = filter_create_pin_with_exact_name<READERWRITERTYPE, PINTYPE>(oFilter, oReaderORWriter, pPin);
        if (IS_OK(nRes))
        {
            RETURN_NOERROR;
        }
        if (nRes == ERR_RESOURCE_IN_USE)
        {
            adtf_util::cString strNameOfReaderAndPinTry = adtf_util::cString::Format("%s_%d.3", strNameOfReaderAndPin.GetPtr(), nCurrentTry++);
            oReaderORWriter.SetName(strNameOfReaderAndPinTry);
        }
        else
        {
            return nRes;
        }
    }
    RETURN_NOERROR;
}
 
inline tResult filter_create_pin(cFilter& oFilter, adtf::streaming::ant::cSampleReader& oReader)
{
    ucom::object_ptr<streaming::ant::IInPin> pPin;
    return filter_create_pin<streaming::ant::cSampleReader, streaming::ant::IInPin>(oFilter, oReader, pPin);
}
 
inline tResult filter_create_pin(cFilter& oFilter, adtf::streaming::ant::cSampleWriter& oWriter)
{
    ucom::object_ptr<streaming::ant::IOutPin> pPin;
    return filter_create_pin<streaming::ant::cSampleWriter, streaming::ant::IOutPin>(oFilter, oWriter, pPin);
}
 
inline tResult filter_create_pin(cFilter& oFilter,
                          adtf::streaming::ant::cSampleReader& oReaderORWriter,
                          const char* strName,
                          const ucom::ant::iobject_ptr<const adtf::streaming::ant::IStreamType>& pType)
{
     RETURN_IF_FAILED(adtf::streaming::ant::make_sample_reader(oReaderORWriter, strName, pType));
     return filter_create_pin(oFilter, oReaderORWriter);
}
 
inline tResult filter_create_pin(cFilter& oFilter,
                          adtf::streaming::ant::cSampleWriter& oReaderORWriter,
                          const char* strName,
                          const ucom::ant::iobject_ptr<const streaming::ant::IStreamType>& pType)
{
    RETURN_IF_FAILED(adtf::streaming::ant::make_sample_writer(oReaderORWriter, strName, pType));
    return filter_create_pin(oFilter, oReaderORWriter);
}
 
} //namespace ant

class cFilter:
        public ucom::catwo::object<streaming::ant::INamedGraphObject,
                                   streaming::ant::IDataBinding,
                                   streaming::ant::IInterfaceBinding,
                                   streaming::ant::IRuntimeBehaviour,
                                   streaming::ant::IDynamicDataBinding,
                                   streaming::ant::IDynamicInterfaceBinding,
                                   streaming::ant::IFilter,
                                   base::ant::IConfiguration>,
        public cGraphObject,
        protected streaming::ant::cFilterLevelmachine
{
    public:
        // this needs to be here because unfortunately multiple base classes have this as well (altough it is not needed at all)
        template <typename T>
        using iobject_ptr = adtf::ucom::ant::iobject_ptr<T>;
 
        cFilter();
        ~cFilter() override;

        tResult Init(tInitStage eStage) override;

        tResult Start() override;
        tResult Stop() override;

        tResult Shutdown(tInitStage eStage) override;
 
        tResult SetName(const char* strName) override;
        tResult GetName(base::ant::IString&& strName) const override;
        tResult SetParent(const ucom::ant::IObject* poParentObject) override;
        tResult GetParent(const ucom::ant::IObject*& poParentObject) const override;
 
        tResult GetPins(ucom::ant::iobject_list<streaming::ant::IPin>& oPins) const override;
        tResult FindPin(const char* strName, ucom::ant::iobject_ptr<ucom::ant::IObject>& pPin) const override;
 
        tResult GetBindingObjects(ucom::ant::iobject_list<streaming::ant::IBindingObject>& lstBindingObject) override;
        tResult GetBindingObjects(ucom::ant::iobject_list<const streaming::ant::IBindingObject>& lstBindingObject) const override;
        tResult FindBindingObject(const char* strName,
            ucom::ant::iobject_ptr<const ucom::ant::IObject>& pIBindingObject) const override;
        tResult FindBindingObject(const char* strName,
            ucom::ant::iobject_ptr<ucom::ant::IObject>& pIBindingObject) override;
 
        tResult GetRunners(ucom::ant::iobject_list<streaming::ant::IRunner>& lstRunners) const override;
        tResult FindRunner(const char* strName, ucom::ant::iobject_ptr<ucom::ant::IObject>& pRunner) const override;
        tResult GetInnerPipes(ucom::ant::iobject_list<streaming::ant::ITriggerPipe>& lstInnerTriggerPipes) const override;
 
        tResult RequestPin(const char* strName,
                           const ucom::ant::iobject_ptr<const streaming::ant::IStreamType>& pType,
                           ucom::ant::iobject_ptr<streaming::ant::IInPin>& pInPin) override;
        tResult RequestPin(const char* strName,
                           const ucom::ant::iobject_ptr<const streaming::ant::IStreamType>& pType,
                           ucom::ant::iobject_ptr<streaming::ant::IOutPin>& pOutPin) override;
 
        tResult RequestBindingObject(const char* strName,
                                     const ucom::ant::iobject_ptr<const streaming::ant::IBindingType>& pType,
                                     ucom::ant::iobject_ptr<streaming::ant::IBindingClient>& pBindingClient) override;
        tResult RequestBindingObject(const char* strName,
                                     const ucom::ant::iobject_ptr<const streaming::ant::IBindingType>& pType,
                                     ucom::ant::iobject_ptr<streaming::ant::IBindingServer>& pBindingServer) override;
 
        tResult SetState(tFilterState eFilterState) override;
        tFilterState GetState() const override;
 
        tResult GetProperties(ucom::ant::iobject_ptr<const base::ant::IProperties>& pProperties) const override;
        tResult GetProperties(ucom::ant::iobject_ptr<base::ant::IProperties>& pProperties) override;
        tResult AttachConfiguration(const char* strName, base::ant::IConfiguration& oAttachedConfiguration) override;
        tResult DetachConfiguration(const char* strName) override;
 
    private:
        class cImplementation;
        std::unique_ptr<cImplementation> m_pImplementation;
};
 
template<typename DATA_BINDING_IMPL_TYPE>
inline tResult filter_create_pin(DATA_BINDING_IMPL_TYPE& oFilter, adtf::streaming::flash::ISampleReader& oReader)
{
    return streaming::flash::create_pin(oFilter, oReader);
}
 
template<typename DATA_BINDING_IMPL_TYPE>
inline tResult filter_create_pin(DATA_BINDING_IMPL_TYPE& oFilter, adtf::streaming::flash::ISampleWriter& oWriter)
{
    return streaming::flash::create_pin(oFilter, oWriter);
}
 
template<typename DATA_BINDING_IMPL_TYPE>
inline tResult filter_create_pin(DATA_BINDING_IMPL_TYPE& oFilter,
                          adtf::streaming::flash::ISampleReader& oReader,
                          const char* strName,
                          const ucom::ant::iobject_ptr<const adtf::streaming::ant::IStreamType>& pType)
{
    RETURN_IF_FAILED(adtf::streaming::flash::make_sample_reader(oReader, strName, pType));
    return streaming::flash::create_pin(oFilter, oReader);
}
 
template<typename DATA_BINDING_IMPL_TYPE>
inline tResult filter_create_pin(DATA_BINDING_IMPL_TYPE& oFilter,
                          adtf::streaming::flash::ISampleWriter& oWriter,
                          const char* strName,
                          const ucom::ant::iobject_ptr<const streaming::ant::IStreamType>& pType)
{
    RETURN_IF_FAILED(adtf::streaming::flash::make_sample_writer(oWriter, strName, pType));
    return filter_create_pin(oFilter, oWriter);
}
 
template<typename DATA_BINDING_IMPL_TYPE, typename READERWRITERTYPE, typename PINTYPE>
tResult filter_create_pin(DATA_BINDING_IMPL_TYPE& oFilter, READERWRITERTYPE& oReaderORWriter, ucom::ant::iobject_ptr<PINTYPE>& pPin)
{
    ucom::ant::object_ptr<ucom::ant::IObject> pHelper;
    RETURN_IF_FAILED(streaming::flash::create_pin(oFilter, oReaderORWriter, pHelper));
    return pPin.Reset(ucom::ant::ucom_object_ptr_cast<PINTYPE>(pHelper));
}
 
} //namespace filter
} //namespace adtf