configurable_runner.h

Go to the documentation of this file.

#pragma once
#include <adtfstreaming3/runner.h>
#include <adtffiltersdk/trigger_intf.h>
 
#include <map>
#include <unordered_set>
#include <string>
 
namespace adtf
{
namespace filter
{
namespace private_implementations
{

// internal configuration interface for the Trigger (Runner)
class IInternalTriggerConfiguration : public ITriggerConfiguration
{
public:
    ADTF_IID(IInternalTriggerConfiguration, "internal_triggerconfiguration.ant.streaming.adtf.iid");
 
public:
    using ITriggerConfiguration::GetConfiguration;
    virtual adtf::base::ant::IConfiguration& GetConfiguration(tKindOfConfiguration eKind) = 0;
 
    virtual tResult AppendDataIn(const char* strInPin) = 0;
    virtual tResult AppendDataOut(const char* strOutPin) = 0;
    virtual tResult AddTimerConfig(tTimeStamp tmDefaultPeriod) = 0;
    virtual tResult AddThreadConfig(bool bCyclic) = 0;
};

// private implementation of the filter
class cConfigurableRunner :
    public adtf::ucom::object<ITriggerConfiguration, IInternalTriggerConfiguration, streaming::cRunner>
{
private:
    cConfigurableRunner() = default;
    std::map<uint32_t, base::ant::configuration<>> m_mapConfig;
    util::log::ILogChannel* m_pLogChannel = nullptr;
 
public:
    cConfigurableRunner(const char* strName, util::log::ILogChannel* pLogChannel);
    cConfigurableRunner(const char* strName,
                        util::log::ILogChannel* pLogChannel,
                        adtf::base::ant::IRunnable& oRunnable);
    explicit cConfigurableRunner(const char* strName,
                                 util::log::ILogChannel* pLogChannel,
                                 adtf::base::flash::IRunnable& oRunnable);
    template<typename CALLABLE>
    cConfigurableRunner(const char* strName, util::log::ILogChannel* pLogChannel, CALLABLE&& oCallable):
        cConfigurableRunner(strName, pLogChannel)
    {
        SetCallable(std::forward<CALLABLE>(oCallable));
    }
 
    ~cConfigurableRunner() override = default;
 
    const base::ant::IConfiguration& GetConfiguration(tKindOfConfiguration eKind) const override;
    base::ant::IConfiguration& GetConfiguration(tKindOfConfiguration eKind) override;
 
    tResult AppendDataIn(const char* strInPin) override;
    tResult AppendDataOut(const char* strOutPin) override;
    tResult AddTimerConfig(tTimeStamp tmDefaultPeriod) override;
    tResult AddThreadConfig(bool bCyclic) override;
 
    tResult Run(tTimeStamp tmTimeofActivation,
                base::ant::IRunnable::tActivationType ui32ActivationType,
                const void* pvUserData,
                size_t nUserDataSize) override;
    tResult Run(base::flash::tNanoSeconds tmTimeofActivation,
                base::ant::IRunnable::tActivationType ui32ActivationType,
                const void* pvUserData,
                size_t nUserDataSize) override;
 
private:
    template<typename VALUETYPE>
    tResult SetProperty(ITriggerConfiguration::tKindOfConfiguration eKind, const char* strNameOfValue, VALUETYPE oValue)
    {
        ucom::object_ptr<base::IProperties> pProps;
        RETURN_IF_FAILED(m_mapConfig[eKind].GetProperties(pProps));
        return pProps->SetProperty(base::property<VALUETYPE>(strNameOfValue, oValue));
    }
 
    template<typename VALUETYPE>
    VALUETYPE GetProperty(ITriggerConfiguration::tKindOfConfiguration eKind, const char* strNameOfValue)
    {
        ucom::object_ptr<base::IProperties> pProps;
        m_mapConfig[eKind].GetProperties(pProps);
        base::property<VALUETYPE> oValue;
        pProps->GetProperty(strNameOfValue, oValue);
        return oValue.GetValueT();
    }
 
    void AddToCommaSepList(const char* strValueToAdd, adtf_util::cString& strListOfValuesCommaSep);
};
 
} // namespace private_implementations
} // namespace filter
} // namespace adtf