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
{

class cSubstreamHandling
{
public:
    cSubstreamHandling();

    cSubstreamHandling(adtf::filter::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<>;
 
}
}