sample.h

Go to the documentation of this file.

#pragma once
#include "sample_intf.h"
 
#include <adtfucom3/class_factory/class_id.h>
#include <adtfucom3/object.h>
#include <adtfbase/chrono.h>
#include <adtfbase/exception_handling.h>
#include <adtf_base_deprecated.h>
#include <adtfstreaming3/sampleinfo.h>
 
#include <cstring>
#include <cinttypes>
 
namespace adtf
{
namespace streaming
{
namespace ant
{

class cSample :
    public adtf::ucom::catwo::object<ant::ISample,
                                     flash::ISample,
                                     hollow::ISample,
                                     ucom::ant::IClassInfo>
{
private:
    A_UTILS_D(cSample)
 
public:
    ADTF_CLASS_ID_NAME(cSample, "sample.streaming.adtf.cid", "ADTF Default Sample");
    UCOM_RESOLVE(IObject, ISample)
 
    ADTF_CLASS_INFO_IMPL(cSample)
 
    
    ADTF3_DEPRECATED("The class 'cSample' is deprecated. Please use 'alloc_sample()' instead.")
    cSample();
    ADTF3_DEPRECATED("The class 'cSample' is deprecated. Please use 'alloc_sample()' instead.")
    cSample(const ucom::ant::iobject_ptr<ISampleBufferFactory>& oSampleFactory);

    virtual ~cSample();
 
private: //no copy, no assignment allowed - Samples will be treated only by ISample inferface !
    cSample(const cSample&) = delete;
    cSample(cSample&&) = delete;
    cSample& operator=(const cSample&) = delete;
    cSample& operator=(cSample&&) = delete;
 
public: //implements ant::ISample
    tResult Lock(ucom::ant::iobject_ptr_shared_locked<const adtf::streaming::ant::ISampleBuffer>& oSampleBuffer) const override;
    tResult WriteLock(ucom::ant::iobject_ptr_locked<ISampleBuffer>& oSampleBuffer, size_t szPreAllocateSize) override;
    tResult Set(const ant::ISample& oSample) override;
    tResult Get(ant::ISample& oSample) const override;
    tResult Reset() override;
    tTimeStamp GetTime() const;
    tResult SetTime(tTimeStamp tmTimeStamp);
    uint32_t GetFlags() const override;
    tResult SetFlags(uint32_t ui32Flags) override;
    tResult Set(tTimeStamp    tmTime,
                const void*  pData,
                size_t         nSize,
                uint32_t       ui32Flags=0) override;
 
    tResult GetSampleBufferFactory(ucom::ant::iobject_ptr<ISampleBufferFactory>& oFactory) const override;
    tResult GetSampleInfo(ucom::ant::iobject_ptr<const ISampleInfo>& oSampleInfo) const override;
    tResult GetSampleInfo(ucom::ant::iobject_ptr<ISampleInfo>& oSampleInfo) override;
    tResult GetSampleLog(ucom::ant::iobject_ptr<ISampleLog>& oSampleLog) const override;
 
public: //implements flash::ISample
    base::flash::tNanoSeconds GetTimeNs() const override;
    tResult SetTime(base::flash::tNanoSeconds tmTimeStamp) override;
    tResult Set(base::flash::tNanoSeconds tmTimeStamp,
                const void*  pData,
                size_t         szSize,
                uint32_t       ui32Flags=0) override;
 
public: //implements hollow::ISample
    uint32_t GetSubStreamId() const override;
    void SetSubStreamId(uint32_t nSubStreamId) override;
 
public:
    tResult SetSampleBufferFactory(const ucom::ant::iobject_ptr<ISampleBufferFactory>& pFactory);
 
    tResult SetSampleInfo(const ucom::ant::iobject_ptr<ISampleInfo>& oInfo);
    tResult SetSampleLog(const ucom::ant::iobject_ptr<ISampleLog>& oLog);
};
class cSample : {…};

class cReferenceSample: public cSample
{
    public:
        ADTF3_DEPRECATED("The class 'cReferenceSample' is deprecated because it is inherently unsafe. Please use 'alloc_sample()' in combination with 'ISample::SetSampleBuffer()' instead.")
        cReferenceSample();
};
class cReferenceSample: public cSample {…};
 
//helper  functions for Sampleallocation
tResult alloc_sample(ucom::ant::iobject_ptr<ucom::ant::IObject>& pSampleObject, const char* strSampleCID);

tResult alloc_sample(ucom::ant::iobject_ptr<ucom::ant::IObject>& pSample, const char* strSampleCID, tTimeStamp nTimeStamp);

tResult alloc_sample(ucom::ant::iobject_ptr<ISample>& pSample);

tResult alloc_sample(ucom::ant::iobject_ptr<ISample>& pSample, tTimeStamp nTimeStamp);
 
} // namespace ant
 
namespace hollow
{

uint32_t get_sample_substream_id(const ant::ISample& oSample);

inline uint32_t get_sample_substream_id(const ucom::ant::iobject_ptr<const ant::ISample>& pSample)
{
    return get_sample_substream_id(*pSample.Get());
}
inline uint32_t get_sample_substream_id(const ucom::ant::iobject_ptr<const ant::ISample>& pSample) {…}

void set_sample_substream_id(ant::ISample& oSample, uint32_t nSubStreamId);

inline void set_sample_substream_id(const ucom::ant::iobject_ptr<ant::ISample>& pSample, uint32_t nSubStreamId)
{
    set_sample_substream_id(*pSample.Get(), nSubStreamId);
}
inline void set_sample_substream_id(const ucom::ant::iobject_ptr<ant::ISample>& pSample, uint32_t nSubStreamId) {…}
 
}
 
namespace flash
{

tResult alloc_sample(ucom::ant::iobject_ptr<ucom::ant::IObject>& pSample);

tResult alloc_sample(ucom::ant::iobject_ptr<ucom::ant::IObject>& pSample, base::flash::tNanoSeconds nTimeStamp);

tResult alloc_sample(ucom::ant::iobject_ptr<ucom::ant::IObject>& pSample, tTimeStamp nTimeStamp);

tResult alloc_sample(ucom::ant::iobject_ptr<ucom::ant::IObject>& pSample, const char* strSampleCID);

tResult alloc_sample(ucom::ant::iobject_ptr<ucom::ant::IObject>& pSample, const char* strSampleCID, base::flash::tNanoSeconds nTimeStamp);

tResult alloc_sample(ucom::ant::iobject_ptr<ucom::ant::IObject>& pSample, const char* strSampleCID, tTimeStamp nTimeStamp);

base::flash::tNanoSeconds get_sample_time(const ucom::ant::iobject_ptr<const ant::ISample>& pSample);

template <typename T>
class output_sample_data
{
    static_assert(std::is_trivially_copyable<T>::value,
                  "You can only use plain types or structs without pointers or complex members.");
 
    public:
        explicit output_sample_data(base::flash::tNanoSeconds tmSampleTime)
        {
            THROW_IF_FAILED(alloc_sample(m_pSample, tmSampleTime));
            THROW_IF_FAILED(m_pSample->WriteLock(m_pBuffer, sizeof(T)));
        }
        explicit output_sample_data(base::flash::tNanoSeconds tmSampleTime) {…}

        explicit output_sample_data(tTimeStamp tmSampleTime)
        {
            THROW_IF_FAILED(alloc_sample(m_pSample, tmSampleTime));
            THROW_IF_FAILED(m_pSample->WriteLock(m_pBuffer, sizeof(T)));
        }
        explicit output_sample_data(tTimeStamp tmSampleTime) {…}

        output_sample_data(base::flash::tNanoSeconds tmSampleTime,
                           const T& oValue):
            output_sample_data(tmSampleTime)
        {
            AssignValue(oValue);
        }
        output_sample_data(base::flash::tNanoSeconds tmSampleTime, {…}
 
        output_sample_data(base::flash::tNanoSeconds tmSampleTime,
                           const T& oValue,
                           uint32_t nSubStreamId):
            output_sample_data(tmSampleTime)
        {
            ucom::object_ptr<hollow::ISample> pSample;
            THROW_IF_FAILED(alloc_sample(pSample));
            pSample->SetTime(tmSampleTime);
            pSample->SetSubStreamId(nSubStreamId);
            m_pSample = pSample;
            THROW_IF_FAILED(m_pSample->WriteLock(m_pBuffer, sizeof(T)));
            AssignValue(oValue);
        }

        output_sample_data(tTimeStamp tmSampleTime,
                           const T& oValue):
            output_sample_data(tmSampleTime)
        {
            AssignValue(oValue);
        }
        output_sample_data(tTimeStamp tmSampleTime, {…}

        explicit output_sample_data(const ant::ISample& oSampleToCopy)
        {
            THROW_IF_FAILED(alloc_sample(m_pSample));
            THROW_IF_FAILED(m_pSample->Set(oSampleToCopy));
            THROW_IF_FAILED(m_pSample->WriteLock(m_pBuffer, 0));
            if (m_pBuffer->GetSize() != sizeof(T))
            {
                THROW_ERROR_DESC(ERR_INVALID_ARG, "The sample passed to output_sample_data (%zu), does not match the size of the requested type (%zu).",
                                 m_pBuffer->GetSize(),
                                 sizeof(T));
            }
        }
        explicit output_sample_data(const ant::ISample& oSampleToCopy) {…}

        explicit output_sample_data(const ucom::ant::iobject_ptr<const ant::ISample>& pSampleToCopy):
            output_sample_data(*pSampleToCopy.Get())
        {
        }
        explicit output_sample_data(const ucom::ant::iobject_ptr<const ant::ISample>& pSampleToCopy): {…}
 
        output_sample_data(output_sample_data&&) = default;
        output_sample_data& operator=(output_sample_data&&) = default;
 
        virtual ~output_sample_data() = default;

        void SetSubStreamId(uint32_t nSubStreamId)
        {
            hollow::set_sample_substream_id(m_pSample, nSubStreamId);
        }
        void SetSubStreamId(uint32_t nSubStreamId) {…}

        T* GetDataPtr()
        {
            return const_cast<T*>(const_cast<const output_sample_data*>(this)->GetDataPtr());
        }
        T* GetDataPtr() {…}

        const T* GetDataPtr() const
        {
            if (!m_pBuffer)
            {
                THROW_ERROR_DESC(ERR_INVALID_STATE,
                                 "This output_sample_data instance is not valid. Maybe you tried to access it after you called Release()");
            }
 
            return reinterpret_cast<T*>(m_pBuffer->GetPtr());
        }
        const T* GetDataPtr() const {…}

        T* operator->()
        {
            return GetDataPtr();
        }
        T* operator->() {…}

        const T* operator->() const
        {
            return GetDataPtr();
        }
        const T* operator->() const {…}

        T& GetData()
        {
            return *GetDataPtr();
        }
        T& GetData() {…}

        const T& GetData() const
        {
            return *GetDataPtr();
        }
        const T& GetData() const {…}

        T& operator*()
        {
            return GetData();
        }
        T& operator*() {…}

        const T& operator*() const
        {
            return GetData();
        }
        const T& operator*() const {…}

        output_sample_data& operator=(const T& oValue)
        {
            AssignValue(oValue);
            return *this;
        }
        output_sample_data& operator=(const T& oValue) {…}

        operator T&()
        {
            return GetData();
        }
        operator T&() {…}

        operator const T&() const
        {
            return GetData();
        }
        operator const T&() const {…}

        ucom::ant::object_ptr<ant::ISample> Release()
        {
            if (!m_pBuffer)
            {
                THROW_ERROR_DESC(ERR_INVALID_STATE,
                                 "This output_sample_data instance is not valid. Maybe you tried to access it after you called Release()");
            }
 
            m_pBuffer = nullptr;
            ucom::ant::object_ptr<ant::ISample> pSample(std::move(m_pSample));
            m_pSample.Reset();
            return pSample;
        }
        ucom::ant::object_ptr<ant::ISample> Release() {…}

        tResult SetSampleInfo(const ISampleInfo::tHashKey& oHash, const adtf::util::cVariant oValue)
        {
            return ant::set_sample_info(*m_pSample, oHash, oValue);
        }
        tResult SetSampleInfo(const ISampleInfo::tHashKey& oHash, const adtf::util::cVariant oValue) {…}
 
    protected:
        ucom::ant::object_ptr<ant::ISample> m_pSample;
        ucom::ant::object_ptr_locked<ant::ISampleBuffer> m_pBuffer;
 
    private:
        inline void AssignValue(const T& oValue)
        {
            std::memcpy(this->GetDataPtr(), &oValue, sizeof(T));
        }
 
        output_sample_data(const output_sample_data&) = delete;
        output_sample_data& operator=(const output_sample_data&) = delete;
};
class output_sample_data {…};
 
}
 
namespace giant
{

base::flash::tNanoSeconds get_sample_time(const ant::ISample& oSample);

void set_sample_time(const ucom::ant::iobject_ptr<ant::ISample>& pSample, base::flash::tNanoSeconds tmTimeStamp);

void set_sample_time(ant::ISample& oSample, base::flash::tNanoSeconds tmTimeStamp);
 
}
 
using ant::cSample;
using ant::cReferenceSample;
using flash::output_sample_data;
using flash::alloc_sample;
using flash::get_sample_time;
using giant::get_sample_time;
using giant::set_sample_time;
using hollow::set_sample_substream_id;
using hollow::get_sample_substream_id;
 
} // namespace streaming
} // namespace adtf
 
#include <adtfstreaming3/sample_data.h>