triggerfunction_base.h

Go to the documentation of this file.

 
#pragma once
#include "filter.h"
 
#include <adtf_utils.h>
#include <adtfbase/runnable.h>
#include <adtfbase/configuration.h>
#include <adtfbase/string_intf.h>
#include <adtfstreaming3/samplereader.h>
#include <adtfstreaming3/samplewriter.h>
 
#include <functional>
#include <memory>
#include <string>
#include <vector>
 
namespace adtf
{
namespace filter
{
namespace ant
{
    class cTriggerFunctionBase : public base::ant::runnable<base::ant::IRunnable::RUN_TRIGGER>,
                                 public base::ant::configuration<>
    {
 
    protected:
        adtf_util::cString          m_strName;
        adtf_util::cString          m_strProfilingFullName;
        adtf_util::cString          m_strProfilingInputs;
        adtf_util::cString          m_strProfilingProcess;
        adtf_util::cString          m_strProfilingOutputs;
        adtf_util::cString          m_strProfilingStartedEvent;
        adtf_util::cString          m_strProfilingFinishedEvent;
 
    public:
        cTriggerFunctionBase();
        cTriggerFunctionBase(const char* strName);
 
        virtual tResult GetName(base::IString&& strName) const;
        void SetName(const char* strName);
        virtual tResult SetDefaultProperties(base::ant::IConfiguration& /* pProperties */);
        virtual tResult Configure();
        virtual tResult SetFilter(cFilter& oFilter);
        virtual tResult ConnectReadersAndWriters(cFilter& /* oFilter */);
        virtual void SetParentFullName(const adtf::util::cString& strParentFullName);
 
    public: //implement the Trigger
 
        tResult RunTrigger(tTimeStamp tmTimeofActivation);
 
 
    public:
        virtual tResult ProcessInputs(tTimeStamp /* tmTime */);
 
        virtual tResult Process(tTimeStamp tmTime) = 0;
 
        virtual tResult ProcessOutputs(tTimeStamp /* tmTime */);
    };
 
 
    class cTriggerFunction : public cTriggerFunctionBase
    {
 
        protected:
            std::vector<streaming::ant::cSampleReader*>    m_vecOfReaders;
            std::vector<streaming::ant::cSampleWriter*>    m_vecOfWriters;
 
        public:
            cTriggerFunction();
            cTriggerFunction(const char* strName);
 
            tResult SetDefaultProperties(base::ant::IConfiguration& oFilterConfig);
 
            tResult ConnectReadersAndWriters(cFilter& oFilter) override;
 
            tResult ProcessOutputs(tTimeStamp /* tmTime */) override;
 
            tResult Register(adtf::streaming::ant::cSampleReader& oReader);
            tResult Register(adtf::streaming::ant::cSampleReader& oReader, const char* strName, const char* strDDLStruct);
            tResult Register(adtf::streaming::ant::cSampleReader& oReader, const char* strName, const ucom::ant::iobject_ptr<const adtf::streaming::IStreamType>& poStreamType);
            tResult Register(adtf::streaming::ant::cSampleReader& oReader, const char* strName, const adtf::streaming::IStreamType& oStreamType);
 
            tResult Register(adtf::streaming::ant::cSampleWriter& oWriter);
            tResult Register(adtf::streaming::ant::cSampleWriter& oWriter, const char* strName, const char* strDDLStruct);
            tResult Register(adtf::streaming::ant::cSampleWriter& oWriter, const char* strName, const ucom::ant::iobject_ptr<const adtf::streaming::IStreamType>& poStreamType);
            tResult Register(adtf::streaming::ant::cSampleWriter& oWriter, const char* strName, const streaming::IStreamType& oStreamType);
 
    };
 
 
 
} //namespace ant
 
namespace flash
{
 
class cTriggerFunction: public base::ant::configuration<>,
                        public base::flash::IRunnable
{
    public:
        cTriggerFunction();
        cTriggerFunction(const char* strName);
        ~cTriggerFunction() override;
 
        void SetName(const char* strName);
        tResult GetName(base::ant::IString&& strName) const;
 
        tResult Register(streaming::flash::ISampleReader& oReader);
        tResult Register(streaming::flash::ISampleReader& oReader, const char* strName, const char* strDDLStruct);
        tResult Register(streaming::flash::ISampleReader& oReader, const char* strName, const ucom::ant::iobject_ptr<const adtf::streaming::ant::IStreamType>& poStreamType);
        tResult Register(streaming::flash::ISampleReader& oReader, const char* strName, const adtf::streaming::ant::IStreamType& oStreamType);
 
        tResult Register(streaming::flash::ISampleWriter& oWriter);
        tResult Register(streaming::flash::ISampleWriter& oWriter, const char* strName, const char* strDDLStruct);
        tResult Register(streaming::flash::ISampleWriter& oWriter, const char* strName, const ucom::ant::iobject_ptr<const adtf::streaming::ant::IStreamType>& poStreamType);
        tResult Register(streaming::flash::ISampleWriter& oWriter, const char* strName, const streaming::ant::IStreamType& oStreamType);
 
        virtual tResult SetFilter(cFilter& oFilter);
        virtual tResult ConnectReadersAndWriters(cFilter& oFilter);
 
        virtual tResult Configure();
 
        virtual tResult ProcessInputs(tTimeStamp tmTime);
        virtual tResult Process(tTimeStamp tmTime);
        virtual tResult ProcessOutputs(tTimeStamp tmTime);
 
        virtual tResult ProcessInputs(base::flash::tNanoSeconds tmTime);
        virtual tResult Process(base::flash::tNanoSeconds tmTime);
        virtual tResult ProcessOutputs(base::flash::tNanoSeconds tmTime);
 
    public:
        tResult Run(base::flash::tNanoSeconds tmTimeofActivation,
                    base::ant::IRunnable::tActivationType ui32ActivationType,
                    const void* pvUserData,
                    size_t nUserDataSize) override;
 
    private:
        class cImplementation;
        std::unique_ptr<cImplementation> m_pImplementation;
};
 
}
 
namespace hollow
{
 
class cTriggerFunction: public base::ant::configuration<>,
                         public base::flash::IRunnable
{
public:
    cTriggerFunction();
    cTriggerFunction(const char* strName);
    ~cTriggerFunction() override;
 
    void SetName(const char* strName);
    tResult GetName(base::ant::IString&& strName) const;
 
    tResult Register(streaming::flash::ISampleReader& oReader);
    tResult Register(streaming::flash::ISampleReader& oReader, const char* strName, const char* strDDLStruct);
    tResult Register(streaming::flash::ISampleReader& oReader, const char* strName, const ucom::ant::iobject_ptr<const adtf::streaming::ant::IStreamType>& poStreamType);
    tResult Register(streaming::flash::ISampleReader& oReader, const char* strName, const adtf::streaming::ant::IStreamType& oStreamType);
 
    tResult Register(streaming::flash::ISampleWriter& oWriter);
    tResult Register(streaming::flash::ISampleWriter& oWriter, const char* strName, const char* strDDLStruct);
    tResult Register(streaming::flash::ISampleWriter& oWriter, const char* strName, const ucom::ant::iobject_ptr<const adtf::streaming::ant::IStreamType>& poStreamType);
    tResult Register(streaming::flash::ISampleWriter& oWriter, const char* strName, const streaming::ant::IStreamType& oStreamType);
 
    virtual tResult SetFilter(cFilter& oFilter);
    virtual tResult ConnectReadersAndWriters(cFilter& oFilter);
 
    virtual tResult Configure();
 
    virtual tResult ProcessInputs(tTimeStamp tmTime);
    virtual tResult Process(tTimeStamp tmTime);
    virtual tResult ProcessOutputs(tTimeStamp tmTime);
 
    virtual tResult ProcessInputs(base::flash::tNanoSeconds tmTime);
    virtual tResult Process(base::flash::tNanoSeconds tmTime);
    virtual tResult ProcessOutputs(base::flash::tNanoSeconds tmTime);
 
public:
    tResult Run(base::flash::tNanoSeconds tmTimeofActivation,
                base::ant::IRunnable::tActivationType ui32ActivationType,
                const void* pvUserData,
                size_t nUserDataSize) override;
 
private:
    class cImplementation;
    std::unique_ptr<cImplementation> m_pImplementation;
};
 
}
 
 
using ant::cTriggerFunctionBase;
using hollow::cTriggerFunction;
 
 
} //namespace filter
} //namespace adtf