test_writer.h

Go to the documentation of this file.

#pragma once
#include <adtf_utils.h>
#include <adtfucom3/adtf_ucom3.h>
#include <adtfbase/exception_handling.h>
#include <adtfstreaming3/named_graph_object_intf.h>
#include <adtfstreaming3/sample.h>
#include <adtffiltersdk/graph_object.h>
#include <memory>
#include <set>
#include <mutex>
 
namespace adtf
{
 
namespace filter
{
 
namespace testing
{
 
namespace giant
{

class cTestWriter
{
public:
    cTestWriter(const ucom::ant::iobject_ptr<ucom::ant::IObject>& pObject,
                const char* strPinName,
                const filter::flash::cStreamTypeHelper& oType = streaming::stream_meta_type_anonymous());

    cTestWriter(const ucom::ant::iobject_ptr<ucom::ant::IObject>& pObject,
                const char* strPinName,
                const filter::flash::cStreamTypeHelper& oType,
                std::function<void(uint32_t, const base::IProperties*)> fnRequest,
                std::function<void(uint32_t)> fnCancel);

    ~cTestWriter();
    void ChangeType(const filter::flash::cStreamTypeHelper& oType);

    template<typename T>
    void Write(base::flash::tNanoSeconds tmTimeStamp, const T& xValue, bool bTrigger = false)
    {
        WriteSubStream<T>(0, tmTimeStamp, xValue, bTrigger);
    }

    template<typename T>
    void Write(const T& xValue, bool bTrigger = false)
    {
        Write<T>(GetCurrentStreamTime(), xValue, bTrigger);
    }

    template<typename T>
    void WriteSubStream(uint32_t nSubStreamId,
                        base::flash::tNanoSeconds tmTimeStamp,
                        const T& xValue,
                        bool bTrigger = false)
    {
        ucom::object_ptr<streaming::hollow::ISample> pSample;
        THROW_IF_FAILED(streaming::alloc_sample(pSample));
        THROW_IF_FAILED(pSample->SetTime(tmTimeStamp));
        pSample->SetSubStreamId(nSubStreamId);
 
        {
            ucom::object_ptr_locked<streaming::ISampleBuffer> pSampleBuffer;
            THROW_IF_FAILED(pSample->WriteLock(pSampleBuffer, 0));
            pSampleBuffer->Write(base::adtf_memory<const T>(&xValue));
        }
 
        WriteSample(ucom::ucom_object_ptr_cast<streaming::ISample>(pSample));
        if (bTrigger)
        {
            ManualTrigger(tmTimeStamp);
        }
    }

    template<typename T>
    void WriteSubStream(uint32_t nSubStreamId, const T& xValue, bool bTrigger = false)
    {
        WriteSubStream<T>(nSubStreamId, GetCurrentStreamTime(), xValue, bTrigger);
    }

    void WriteSample(const ucom::ant::iobject_ptr<const streaming::ant::ISample>& pSample);

    void ManualTrigger(base::flash::tNanoSeconds tmActivationTime = base::flash::tNanoSeconds{-1});

    void SetRequestCallbacks(std::function<void(uint32_t, const base::IProperties*)> fnRequest,
                             std::function<void(uint32_t)> fnCancel);
 
protected:
    base::flash::tNanoSeconds GetCurrentStreamTime() const;
 
private:
    class cImplementation;
    std::unique_ptr<cImplementation> m_pImplementation;
};
 
} // namespace giant
 
namespace penguin
{

class cTestWriterWithSubStreams : public giant::cTestWriter
{
public:
    cTestWriterWithSubStreams(const adtf::ucom::ant::iobject_ptr<adtf::ucom::ant::IObject>& pObject,
                              const char* strPinName,
                              const adtf::filter::flash::cStreamTypeHelper& oType
                              = adtf::streaming::stream_meta_type_anonymous());
 
    ~cTestWriterWithSubStreams();

    void ChangeType(const filter::flash::cStreamTypeHelper& oType);

    bool IsSubstreamRequested(uint32_t ui32SubStreamId) const;
    std::set<uint32_t> GetCurrentRequests() const;
 
private:
    std::set<uint32_t> m_setRequestedSubstreams;
    mutable std::mutex m_mxLock;
};
 
} // namespace penguin
 
using giant::cTestWriter;
using penguin::cTestWriterWithSubStreams;
 
} // namespace testing
} // namespace filter
} // namespace adtf