data_triggered_filter.h

Go to the documentation of this file.

 
#pragma once
#include "triggered_filter.h"
 
#include <adtf_base_deprecated.h>
 
namespace adtf
{
namespace filter
{
namespace ant
{
 
template<typename TriggerFunctionImpl, typename InPinListOfTriggers>
class data_triggered_filter : public triggered_filter < TriggerFunctionImpl >
{
protected:
    typedef triggered_filter < TriggerFunctionImpl > base_type;
 
public:
    
    ADTF3_DEPRECATED("Class 'data_triggered_filter' is deprecated, as well as macro 'ADTF_DATA_TRIGGERED_FILTER'."
                     "Use class filter_with_trigger_function or macros 'ADTF_TRIGGER_FUNCTION_FILTER' / 'ADTF_TRIGGER_FUNCTION_FILTER_PLUGIN' instead.")
    data_triggered_filter() : base_type()
    {
    }
    
    ~data_triggered_filter()
    {
    }
 
    tResult CreateDefaultTrigger(const char* strFunctionName) override
    {
        adtf_util::cStringList strPinList = adtf_util::cStringList(InPinListOfTriggers::GetPinTriggerList());
        for (adtf_util::cStringList::iterator it = strPinList.begin();
            it != strPinList.end();
            it++)
        {
            (*it).Trim();
            RETURN_IF_FAILED(base_type::ConfigureDataInTrigger(strFunctionName, *it));
        }
        RETURN_NOERROR;
    }
};
 
} //namespace ant
 
namespace detail
{
 
template<typename FilterClass>
tResult pin_trigger(FilterClass& oFilter, const std::vector<util::cString>& oTriggerPins)
{
    for (util::cString strTriggerPin: oTriggerPins)
    {
        strTriggerPin.Trim();
        RETURN_IF_FAILED(oFilter.ConfigureDataInTrigger(oFilter.GetTriggerFunctionName(), strTriggerPin));
    }
    RETURN_NOERROR;
}
 
}
 
namespace devil
{
 
inline std::function<tResult(cFilterWithTriggerFunction&)> pin_trigger(std::vector<util::cString> oTriggerPins)
{
    return std::bind(detail::pin_trigger<cFilterWithTriggerFunction>, std::placeholders::_1, oTriggerPins);
}
 
} //namespace devil
 
namespace hollow
{
 
inline std::function<tResult(cFilterWithTriggerFunction&)> pin_trigger(std::vector<util::cString> oTriggerPins)
{
    return std::bind(detail::pin_trigger<cFilterWithTriggerFunction>, std::placeholders::_1, oTriggerPins);
}
 
} //namespace devil
 
using ant::data_triggered_filter;
using hollow::pin_trigger;
 
} //namespace filter
} //namespace adtf
 
#define ADTF_DATA_TRIGGERED_PIN_LIST(_triggerlistclass_, _listcommaseparated_) \
struct _triggerlistclass_ \
{ \
    static adtf_util::cStringList GetPinTriggerList() \
    { \
         return adtf_util::cStringList(_listcommaseparated_); \
    } \
}
 
#define ADTF_DATA_TRIGGERED_FILTER_NAME(_class_identifier_, \
                                        _class_name_, \
                                        _datatriggerfilterclass_, \
                                        _triggerfunction_, \
                                        _triggerlistclass_, \
                                        ...) \
class _datatriggerfilterclass_ : public adtf::filter::data_triggered_filter<_triggerfunction_,  _triggerlistclass_> \
{ \
    public:\
        ADTF_CLASS_ID_NAME(_datatriggerfilterclass_, _class_identifier_, _class_name_); \
        __VA_ARGS__;\
    public: \
    _datatriggerfilterclass_() = default; \
    virtual ~_datatriggerfilterclass_() = default; \
}
 
#define ADTF_DATA_TRIGGERED_FILTER(_class_identifier_, \
                                   _datatriggerfilterclass_, \
                                   _triggerfunction_, \
                                   _triggerlistclass_)\
    ADTF_DATA_TRIGGERED_FILTER_NAME(_class_identifier_, \
                                    _class_identifier_, \
                                    _datatriggerfilterclass_, \
                                    _triggerfunction_, \
                                    _triggerlistclass_)