triggered_filter.h

Go to the documentation of this file.

#pragma once
#include <adtffiltersdk/filter.h>
 
#include <memory>
#include <functional>
 
namespace adtf
{
namespace filter
{
namespace ant
{
template<typename TriggerFunctionImpl>
class triggered_filter : public cFilter
{
    private:
        triggered_filter(const triggered_filter&) = delete;
        triggered_filter(triggered_filter&&) = delete;
        triggered_filter& operator=(const triggered_filter&) = delete;
        triggered_filter& operator=(triggered_filter&&) = delete;
 
        TriggerFunctionImpl m_oTriggerFunc;
 
    protected:
        triggered_filter()
        {
            adtf_util::cString strTriggerFuncName;
            m_oTriggerFunc.GetName(adtf_string_intf(strTriggerFuncName));
            if (strTriggerFuncName.IsEmpty())
            {
                strTriggerFuncName = "trigger";
                m_oTriggerFunc.SetName(strTriggerFuncName);
            }
            m_oTriggerFunc.SetFilter(*this);
        }
        ~triggered_filter()
        {
        }
        tResult Init(tInitStage eStage) override
        {
            RETURN_IF_FAILED(cFilter::Init(eStage));
            if (eStage == tInitStage::StageFirst)
            {
                adtf_util::cString strTriggerFuncName;
                m_oTriggerFunc.GetName(adtf_string_intf(strTriggerFuncName));
                RETURN_IF_FAILED(RegisterRunner(strTriggerFuncName, m_oTriggerFunc));
                RETURN_IF_FAILED(m_oTriggerFunc.ConnectReadersAndWriters(*this));
                RETURN_IF_FAILED(m_oTriggerFunc.Configure());
                RETURN_IF_FAILED(CreateDefaultTrigger(strTriggerFuncName));
            }
            RETURN_NOERROR;
        }
 
        tResult SetParent(const adtf::ucom::ant::IObject* poParentObject) override
        {
            RETURN_IF_FAILED(cFilter::SetParent(poParentObject));
            m_oTriggerFunc.SetParentFullName(adtf::streaming::ant::get_named_graph_object_full_name(*this));
            RETURN_NOERROR;
        }
 
        virtual tResult CreateDefaultTrigger(const char* strTriggerFuncName)
        {
            //no default defined here !!
            RETURN_NOERROR;
        }
 
};
 
 
 
} //namespace ant
 
namespace devil
{
 
class cFilterWithTriggerFunction: public cFilter
{
    public:
        virtual adtf::util::cString GetTriggerFunctionName() = 0;
};

template<typename TriggerFunctionImpl>
class filter_with_trigger_function: public cFilterWithTriggerFunction
{
    protected:
        typedef filter_with_trigger_function<TriggerFunctionImpl> filter_type;
 
    private:
        filter_with_trigger_function(const filter_with_trigger_function&) = delete;
        filter_with_trigger_function(filter_with_trigger_function&&) = delete;
        filter_with_trigger_function& operator=(const filter_with_trigger_function&) = delete;
        filter_with_trigger_function& operator=(filter_with_trigger_function&&) = delete;
 
        std::function<tResult(cFilterWithTriggerFunction&)> m_fnCreateTrigger;
        std::unique_ptr<TriggerFunctionImpl> m_pTriggerFunc;
        tResult m_oTriggerFunctionCreationResult;
 
    protected:
        filter_with_trigger_function(std::function<tResult(cFilterWithTriggerFunction&)> fnCreateTrigger):
            m_fnCreateTrigger(fnCreateTrigger),
            m_oTriggerFunctionCreationResult(CreateRunner())
        {
        }
 
    private:
        tResult CreateRunner()
        {
            RETURN_IF_THROWS_DESC(m_pTriggerFunc.reset(new TriggerFunctionImpl),
                                  "Unable to construct trigger function");
 
            if (GetTriggerFunctionName().IsEmpty())
            {
                m_pTriggerFunc->SetName("trigger");
            }
 
            return m_pTriggerFunc->SetFilter(*this);
        }
 
    public:
        tResult Init(tInitStage eStage) override
        {
            RETURN_IF_FAILED(cFilter::Init(eStage));
            if (eStage == tInitStage::StageFirst)
            {
                RETURN_IF_FAILED(m_oTriggerFunctionCreationResult);
                RETURN_IF_FAILED(RegisterRunner(GetTriggerFunctionName(), *m_pTriggerFunc.get()));
                RETURN_IF_FAILED(m_pTriggerFunc->Configure());
                RETURN_IF_FAILED(m_pTriggerFunc->ConnectReadersAndWriters(*this));
                RETURN_IF_FAILED(m_fnCreateTrigger(*this));
            }
 
            RETURN_NOERROR;
        }
 
        tResult Shutdown(tInitStage eStage) override
        {
            if (eStage == tInitStage::StageFirst)
            {
                m_pTriggerFunc.reset();
            }
 
            return cFilter::Shutdown(eStage);
        }
 
        adtf::util::cString GetTriggerFunctionName() override
        {
            adtf_util::cString strTriggerFuncName;
            if (m_pTriggerFunc)
            {
                m_pTriggerFunc->GetName(adtf_string_intf(strTriggerFuncName));
            }
            return strTriggerFuncName;
        }
};
 
} //namespace devil
 
namespace flash
{
 
template<typename TriggerFunctionImpl, typename FilterClass = devil::cFilterWithTriggerFunction>
class filter_with_trigger_function: public FilterClass
{
    protected:
        typedef filter_with_trigger_function<TriggerFunctionImpl, FilterClass> filter_type;
 
    public:
        filter_with_trigger_function(const filter_with_trigger_function&) = delete;
        filter_with_trigger_function(filter_with_trigger_function&&) = delete;
        filter_with_trigger_function& operator=(const filter_with_trigger_function&) = delete;
        filter_with_trigger_function& operator=(filter_with_trigger_function&&) = delete;
 
    private:
 
        std::function<tResult(FilterClass&)> m_fnCreateTrigger;
        std::unique_ptr<TriggerFunctionImpl> m_pTriggerFunc;
        tResult m_oTriggerFunctionCreationResult;
 
    protected:
        filter_with_trigger_function(std::function<tResult(FilterClass&)> fnCreateTrigger):
            m_fnCreateTrigger(fnCreateTrigger),
            m_oTriggerFunctionCreationResult(CreateRunner())
        {
        }
 
        ~filter_with_trigger_function()
        {
            FilterClass::SetState(streaming::ant::IFilter::tFilterState::State_Shutdown);
        }
 
    private:
        tResult CreateRunner()
        {
            RETURN_IF_THROWS_DESC(m_pTriggerFunc.reset(new TriggerFunctionImpl),
                                  "Unable to construct trigger function");
 
            if (GetTriggerFunctionName().IsEmpty())
            {
                m_pTriggerFunc->SetName("trigger");
            }
 
            RETURN_IF_FAILED(m_pTriggerFunc->SetFilter(*this));
 
            return FilterClass::AttachConfiguration(GetTriggerFunctionName(), *m_pTriggerFunc);
        }
 
    public:
        tResult Init(typename FilterClass::tInitStage eStage) override
        {
            RETURN_IF_FAILED(FilterClass::Init(eStage));
            if (eStage == FilterClass::tInitStage::StageFirst)
            {
                RETURN_IF_FAILED(m_oTriggerFunctionCreationResult);
                RETURN_IF_FAILED(FilterClass::RegisterRunner(GetTriggerFunctionName(), *m_pTriggerFunc.get()));
                RETURN_IF_FAILED(m_pTriggerFunc->Configure());
                RETURN_IF_FAILED(m_pTriggerFunc->ConnectReadersAndWriters(*this));
                RETURN_IF_FAILED(m_fnCreateTrigger(*this));
            }
 
            RETURN_NOERROR;
        }
 
        tResult Shutdown(typename FilterClass::tInitStage eStage) override
        {
            if (eStage == FilterClass::tInitStage::StageFirst)
            {
                m_pTriggerFunc.reset();
            }
 
            return FilterClass::Shutdown(eStage);
        }
 
        adtf::util::cString GetTriggerFunctionName() override
        {
            adtf_util::cString strTriggerFuncName;
            if (m_pTriggerFunc)
            {
                m_pTriggerFunc->GetName(adtf_string_intf(strTriggerFuncName));
            }
            return strTriggerFuncName;
        }
};
 
}
 
namespace hollow
{
 
class cFilterWithTriggerFunction: public cFilter
{
public:
    virtual adtf::util::cString GetTriggerFunctionName() = 0;
};
 
template<typename TriggerFunctionImpl, typename FilterClass = cFilterWithTriggerFunction>
using filter_with_trigger_function = flash::filter_with_trigger_function<TriggerFunctionImpl, cFilterWithTriggerFunction>;
 
}
 
using ant::triggered_filter;
using hollow::filter_with_trigger_function;

#define ADTF_TRIGGER_FUNCTION_FILTER(_class_identifier_,\
                                     _class_name_,\
                                     _triggerfilterclass_,\
                                     _triggerfunction_,\
                                     _trigger_configurator_,\
                                     ...) \
class _triggerfilterclass_ : public adtf::filter::filter_with_trigger_function<_triggerfunction_> \
{ \
    public:\
        ADTF_CLASS_ID_NAME(_triggerfilterclass_, _class_identifier_, _class_name_); \
        __VA_ARGS__;\
    public: \
        _triggerfilterclass_():\
          filter_type(_trigger_configurator_)\
        {\
        }\
}

#define ADTF_TRIGGER_FUNCTION_FILTER_PLUGIN(_class_identifier_,\
                                            _class_name_,\
                                            _triggerfunction_,\
                                            _trigger_configurator_,\
                                            ...)\
    ADTF_TRIGGER_FUNCTION_FILTER(_class_identifier_,\
                                 _class_name_,\
                                 _triggerfunction_##Filter,\
                                 _triggerfunction_,\
                                 _trigger_configurator_,\
                                 __VA_ARGS__);\
    ADTF_PLUGIN(_class_name_ " Plugin",\
                _triggerfunction_##Filter)
 
 
} //namespace filter
} //namespace adtf