samplewriter.h

Go to the documentation of this file.

#pragma once
#include "samplestream_intf.h"
#include "sampleoutstream_intf.h"
#include "sample_intf.h"
#include "streamtype_intf.h"
#include "samplestreamer_intf.h"
#include "pin.h"
#include "sample.h"
#include "samplereader.h"
#include <adtf_base_deprecated.h>
 
#include "reference_clock_intf.h"
 
namespace adtf
{
namespace streaming
{
namespace ant
{
class cSampleWriter : public sample_streamer<ISampleWriter, cOutPin>
{
protected:
    ucom::object_ptr<ISampleOutStream> m_pOutStream;

    typedef sample_streamer<ISampleWriter, cOutPin> base_type;
 
protected:
    ucom::object_ptr<adtf::services::IReferenceClock> _clock;
 
public:
    cSampleWriter()
    {
    }

    virtual ~cSampleWriter()
    {
    }

    cSampleWriter(const char* strName, const ucom::ant::iobject_ptr<const IStreamType>& pStreamType):
        base_type(strName, pStreamType)
    {
    }
 
    tResult BeginStreaming(ISampleStream& oSampleStream) override
    {
        adtf::ucom::object_ptr<const IStreamType> pConstType = m_pStreamType;
 
        RETURN_IF_FAILED(oSampleStream.Open(m_strName, m_pOutStream, ISampleStreamAccess::PushRead, 0));
 
        if (pConstType)
        {
            RETURN_IF_FAILED(m_pOutStream->Write(pConstType));
        }
 
        if (_runtime)
        {
            _runtime->GetObject(_clock);
        }
 
        RETURN_NOERROR;
    }
 
    tResult EndStreaming() override
    {
        _clock.Reset();
        m_pOutStream.Reset();
        RETURN_NOERROR;
    }
 
public: // Streaming Functions for
    virtual tResult Transmit(const ucom::ant::iobject_ptr<const ISample>& pSample)
    {
        if (m_pOutStream)
        {
            RETURN_IF_FAILED(m_pOutStream->Write(pSample));
            RETURN_NOERROR;
        }
        else
        {
            RETURN_ERROR_DESC(ERR_INVALID_STATE, "No valid output stream.");
        }
    }

    virtual tResult ChangeType(const ucom::ant::iobject_ptr<const IStreamType>& pType)
    {
        RETURN_IF_FAILED(SetType(pType));
        if (m_pOutStream)
        {
            RETURN_IF_FAILED(m_pOutStream->Write(pType));
        }
        RETURN_NOERROR;
    }

    virtual tResult Flush()
    {
        if (m_pOutStream)
        {
            RETURN_IF_FAILED(m_pOutStream->Flush());
            RETURN_NOERROR;
        }
        else
        {
            RETURN_ERROR_DESC(ERR_INVALID_STATE, "No valid output stream.");
        }
    }

    virtual tResult SetStreamError(tResult oErr)
    {
        if (m_pOutStream)
        {
            RETURN_IF_FAILED(m_pOutStream->SetStreamError(oErr));
            RETURN_NOERROR;
        }
        else
        {
            RETURN_ERROR_DESC(ERR_INVALID_STATE, "No valid output stream.");
        }
    }

    tResult ManualTrigger()
    {
        if (m_poPin)
        {
            tTimeStamp tmTime = _clock ? _clock->GetStreamTime() : adtf::util::cSystem::GetTime();
            RETURN_IF_FAILED(m_poPin->Run(tmTime, base::ant::IRunnable::RUN_TRIGGER, nullptr, 0));
            RETURN_NOERROR;
        }
        RETURN_ERROR_DESC(ERR_NOT_INITIALIZED, "No connected pin.");
    }
};

inline cSampleWriter& operator<<(cSampleWriter& oSampleWriter, const ucom::ant::iobject_ptr<const ISample>& pSample)
{
    oSampleWriter.Transmit(pSample);
    return oSampleWriter;
}

inline cSampleWriter& operator<<(cSampleWriter& oSampleWriter, const ucom::ant::iobject_ptr<ISample>& pSample)
{
    oSampleWriter.Transmit(ucom::ucom_object_ptr_cast<const ISample>(pSample));
    return oSampleWriter;
}

inline cSampleWriter& operator<<(cSampleWriter& oSampleWriter, const ucom::ant::iobject_ptr<const IStreamType>& pType)
{
    oSampleWriter.ChangeType(pType);
    return oSampleWriter;
}

inline cSampleWriter& operator<<(cSampleWriter& oSampleWriter, cSampleWriter& (*pStreamfunc)(cSampleWriter&) )
{
    return pStreamfunc(oSampleWriter);
}

inline cSampleWriter& operator<<(cSampleWriter& oSampleWriter, const tResult& oError)
{
    oSampleWriter.SetStreamError(oError);
    return oSampleWriter;
}

template<typename DATA_TYPE>
class sample_writer : public cSampleWriter
{
public:
    tResult Transmit(const DATA_TYPE& oSampleData)
    {
        ucom::ant::object_ptr<ISample> pSample;
        RETURN_IF_FAILED(adtf::streaming::alloc_sample(pSample));
        tTimeStamp tmTime = _clock ? _clock->GetStreamTime() : adtf_util::cSystem::GetTime();
        RETURN_IF_FAILED(pSample->Set(tmTime, &oSampleData, sizeof(DATA_TYPE)));
        return cSampleWriter::Transmit(ucom::ant::object_ptr<const ISample>(pSample));
    }
};

template<typename DATA_TYPE>
ADTF3_DEPRECATED("Use sample_writer<DATA_TYPE>::Write(tmTime, oSampleData) instead.")
sample_writer<DATA_TYPE>& operator<<(sample_writer<DATA_TYPE>& oSampleWriter, const DATA_TYPE& oSampleData)
{
    oSampleWriter.Transmit(oSampleData);
    return oSampleWriter;
}

inline cSampleReader& operator>>(cSampleReader& oSampleReader, cSampleWriter& oSampleWriter)
{
    ucom::ant::object_ptr<const ISample> pSample;
    while (IS_OK(oSampleReader.GetNextSample(pSample)))
    {
        oSampleWriter << pSample;
    };
    return oSampleReader;
}

inline tResult make_sample_writer(cSampleWriter& oWriter,
                                  const char* strNameOfWriter,
                                  const ucom::ant::iobject_ptr<const IStreamType>& pStreamType)
{
    oWriter.SetName(strNameOfWriter);
    return oWriter.SetType(pStreamType);
}
 
} // namespace ant
 
namespace flash
{
class cSampleWriter : public ISampleWriter
{
public:
    cSampleWriter();
    ~cSampleWriter() override;
 
    void SetName(const char* strName) override;
    tResult GetName(base::ant::IString&& strName) override;
 
    tResult SetType(const ucom::ant::iobject_ptr<const ant::IStreamType>& pStreamType) override;
    tResult GetType(ucom::ant::iobject_ptr<const ant::IStreamType>& pStreamType) const override;
 
    tResult BeginStreaming(ISampleStream& oSampleStream) override;
    tResult EndStreaming() override;
 
    tResult SetStreamerPin(const ucom::ant::iobject_ptr<IStreamerPin>& pStreamerPin) override;
    tResult GetStreamerPin(ucom::ant::iobject_ptr<IStreamerPin>& pStreamerPin) const;
 
    tResult Write(const ucom::ant::iobject_ptr<const ant::ISample>& pSample) override;

    virtual tResult Transmit(const ucom::ant::iobject_ptr<const ant::ISample>& pSample);
 
    tResult ChangeType(const ucom::ant::iobject_ptr<const ant::IStreamType>& pType) override;
    tResult Flush() override;
    tResult SetStreamError(tResult oError) override;
    tResult ManualTrigger(base::flash::tNanoSeconds tmActivationTime = base::flash::tNanoSeconds{-1}) override;
 
protected:
    class cImplementation;
    std::unique_ptr<cImplementation> m_pImplementation;
};
 
inline tResult make_sample_writer(ISampleWriter& oWriter,
                                  const char* strNameOfWriter,
                                  const ucom::ant::iobject_ptr<const IStreamType>& pStreamType)
{
    oWriter.SetName(strNameOfWriter);
    return oWriter.SetType(pStreamType);
}

inline ISampleWriter& operator<<(ISampleWriter& oSampleWriter,
                                 const ucom::ant::iobject_ptr<const ant::ISample>& pSample)
{
    THROW_IF_FAILED(oSampleWriter.Write(pSample));
    return oSampleWriter;
}

inline ISampleWriter& operator<<(ISampleWriter& oSampleWriter,
                                 const ucom::ant::iobject_ptr<const ant::IStreamType>& pType)
{
    THROW_IF_FAILED(oSampleWriter.ChangeType(pType));
    return oSampleWriter;
}

inline ISampleWriter& operator<<(ISampleWriter& oSampleWriter, ISampleWriter& (*pStreamfunc)(ISampleWriter&) )
{
    return pStreamfunc(oSampleWriter);
}

inline ISampleWriter& operator<<(ISampleWriter& oSampleWriter, const tResult& oError)
{
    THROW_IF_FAILED(oSampleWriter.SetStreamError(oError));
    return oSampleWriter;
}

template<typename DATA_TYPE>
inline ISampleWriter& operator<<(ISampleWriter& oSampleWriter, output_sample_data<DATA_TYPE>&& oOutputSampleData)
{
    THROW_IF_FAILED(oSampleWriter.Write(oOutputSampleData.Release()));
    return oSampleWriter;
}
 
inline ISampleReader& operator>>(ISampleReader& oSampleReader, ISampleWriter& oSampleWriter)
{
    ucom::ant::object_ptr<const ant::ISample> pSample;
    while (IS_OK(oSampleReader.GetNextSample(pSample)))
    {
        oSampleWriter << pSample;
    };
    return oSampleReader;
}

template<typename DATA_TYPE, typename BASE = cSampleWriter>
class sample_writer : public BASE
{
public:
    sample_writer()
    {
        _runtime->GetObject(m_pClock);
    }
 
    using BASE::Write;
    using BASE::Transmit;

    ADTF3_DEPRECATED("Use sample_writer<DATA_TYPE>::Write(tmTime, oSampleData) instead.")
    tResult Write(const DATA_TYPE& oSampleData)
    {
        auto tmTime = m_pClock ? m_pClock->GetStreamTimeNs() :
                                 base::flash::duration_cast<base::flash::tNanoSeconds>(adtf_util::cSystem::GetTime());
        return Write(tmTime, oSampleData);
    }

    tResult Write(tTimeStamp tmTime, const DATA_TYPE& oSampleData)
    {
        return Write(base::flash::duration_cast<base::flash::tNanoSeconds>(tmTime), oSampleData);
    }

    tResult Write(base::flash::tNanoSeconds tmTime, const DATA_TYPE& oSampleData)
    {
        static_assert(!std::is_pointer_v<DATA_TYPE>, "pointer types are not allowed for sample writing. To support "
                                                     "this you need to specialize the sample_writer template");
 
        ucom::ant::object_ptr<ant::ISample> pSample;
        RETURN_IF_FAILED(ant::alloc_sample(pSample));
        ucom::ant::object_ptr<ISample> pFlashSample(pSample);
        RETURN_IF_POINTER_NULL(pFlashSample);
        RETURN_IF_FAILED(pFlashSample->SetTime(tmTime));
        {
            ucom::ant::object_ptr_locked<ant::ISampleBuffer> pSampleBuffer;
            const adtf::base::adtf_memory<const DATA_TYPE> oMemory(&oSampleData);
            RETURN_IF_FAILED(pFlashSample->WriteLock(pSampleBuffer, oMemory.GetSize()));
            pSampleBuffer->Write(oMemory);
        }
        return BASE::Write(pSample);
    }
 
    ADTF3_DEPRECATED("Use sample_writer<DATA_TYPE>::Write(tmTime, oSampleData) instead.")
    tResult Transmit(const DATA_TYPE& oSampleData)
    {
        return Write(oSampleData);
    }

    tResult Transmit(tTimeStamp tmTime, const DATA_TYPE& oSampleData)
    {
        return Write(base::flash::duration_cast<base::flash::tNanoSeconds>(tmTime), oSampleData);
    }

    tResult Transmit(base::flash::tNanoSeconds tmTime, const DATA_TYPE& oSampleData)
    {
        return Write(tmTime, oSampleData);
    }
 
protected:
    ucom::ant::object_ptr<services::flash::IReferenceClock> m_pClock;
};
 
template<typename DATA_TYPE>
ADTF3_DEPRECATED("Use sample_writer<DATA_TYPE>::Write(tmTime, oSampleData) instead.")
sample_writer<DATA_TYPE>& operator<<(sample_writer<DATA_TYPE>& oSampleWriter, const DATA_TYPE& oSampleData)
{
    THROW_IF_FAILED(oSampleWriter.Write(oSampleData));
    return oSampleWriter;
}
 
} // namespace flash
 
using flash::cSampleWriter;
using flash::sample_writer;
using flash::make_sample_writer;
 
} // namespace streaming
} // namespace adtf