substream_handling.h

Go to the documentation of this file.

 
#pragma once
#include "graph_object.h"
#include "filter.h"
#include <vector>
#include <optional>
#include <variant>
#include <functional>
#include <regex>
 
namespace adtf
{
namespace filter
{
namespace riddler
{
 
class cSubstreamHandling
{
public:        
    cSubstreamHandling();
 
    cSubstreamHandling(adtf::filter::hollow::cGraphObject* pFilter, 
                       const std::string& strInputPinName, 
                       bool bForwardTriggerViaOutputPins = true);
 
    ~cSubstreamHandling();
    cSubstreamHandling(cSubstreamHandling&& oOther);
    cSubstreamHandling& operator=(cSubstreamHandling&& oOther);
 
    cSubstreamHandling(const cSubstreamHandling&) = delete;
    cSubstreamHandling& operator=(const cSubstreamHandling&) = delete;
 
    using tSampleCallback = std::function<void(const adtf::ucom::iobject_ptr<const adtf::streaming::ISample>&)>;
 
    using tGeneratorCallback = std::function<tSampleCallback(const adtf::ucom::iobject_ptr<const adtf::streaming::IStreamType>&)>;
 
    using tNamedGeneratorCallback = std::function<tSampleCallback(const std::string&, const adtf::ucom::iobject_ptr<const adtf::streaming::IStreamType>&)>;
 
    void AddSubstreamHandler(const std::string& strName, 
                             tGeneratorCallback fnGeneratorCallback);
 
    void AddSubstreamHandler(const std::regex& strNameExpression, 
                             tNamedGeneratorCallback fnGeneratorCallback);
 
    void AddSubstreamHandler(const std::string& strName, 
                             tSampleCallback fnCallback);
 
    using tElementValue = std::variant<bool, int8_t, uint8_t, int16_t, uint16_t, int32_t, uint32_t, int64_t, uint64_t, float, double>;
 
    void AddElementHandler(const std::string& strSubstreamName, 
                           const std::string& strElementName, 
                           std::function<void(adtf::base::flash::tNanoSeconds, tElementValue)> fnCallback,
                           bool bNameHeuristic = false);
 
    template <typename T>
    void AddElementHandler(const std::string& strSubstreamName, 
                           const std::string& strElementName, 
                           std::function<void(adtf::base::flash::tNanoSeconds, T)> fnCallback,
                           bool bNameHeuristic = false)
    {
        AddElementHandler(strSubstreamName, strElementName, [fnCallback](adtf::base::flash::tNanoSeconds tmSampleTime, tElementValue xValue)
        {
            std::visit([&](auto&& xTypedValue) 
            { 
                fnCallback(tmSampleTime, static_cast<T>(xTypedValue));
            }, xValue);
        },
        bNameHeuristic);
    }
 
    void RemoveAllHandlers();
 
private:
    class cImplementation;
    std::unique_ptr<cImplementation> m_pImplementation;                
};
 
template <typename FilterBase = adtf::filter::cFilter>
class substream_filter: public FilterBase, protected cSubstreamHandling
{
public:
    substream_filter(const std::string& strInputPinName = "input"):
        cSubstreamHandling(this, strInputPinName)
    {
    }
};
 
using cSubstreamFilter = substream_filter<>;
 
}
 
using riddler::cSubstreamHandling;
using riddler::substream_filter;
using riddler::cSubstreamFilter;
 
}
}