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>
 
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)
 
    
    cSample();
    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 cReferenceSample: public cSample
{
    public:
        cReferenceSample();
};
 
template <typename T>
class sample_data
{
protected:
    ucom::object_ptr<const ISample>                     m_pCurrentSample;
    ucom::object_ptr_shared_locked<const ISampleBuffer> m_pBuffer;
public:
    sample_data()
    {
    }
    sample_data(const sample_data& oSampleData)
    {
        Reset(oSampleData.m_pCurrentSample);
    }
    sample_data(sample_data&& oSampleData)
    {
        std::swap(m_pCurrentSample, oSampleData.m_pCurrentSample);
        std::swap(m_pBuffer, oSampleData.m_pBuffer);
    }
    sample_data(const ucom::iobject_ptr<const ISample>& pSample)
    {
        Reset(pSample);
    }
    tTimeStamp GetTime() const
    {
        if (m_pCurrentSample)
        {
            return m_pCurrentSample->GetTime();
        }
        return -1;
    }
    const T* GetDataPtr() const
    {
        if (m_pBuffer)
        {
            return reinterpret_cast<const T*>(m_pBuffer->GetPtr());
        }
        return nullptr;
    }
    const T GetData() const
    {
        const T* pData = GetDataPtr();
        if (pData)
        {
            T sData;
            sData = *pData;
            return sData;
        }
        return T();
    }
    bool IsValid() const
    {
        return (m_pCurrentSample && m_pBuffer && m_pBuffer->GetSize() >= sizeof(T));
    }
    operator bool() const
    {
        return IsValid();
    }
    operator T() const
    {
        if (IsValid())
        {
            return *GetDataPtr();
        }
        return T();
    }
 
    tResult Reset(const ucom::ant::iobject_ptr<const ISample>& pSample)
    {
        RETURN_IF_FAILED(pSample->Lock(m_pBuffer));
        m_pCurrentSample = pSample;
        RETURN_NOERROR;
    }
 
    tResult Reset()
    {
        m_pCurrentSample.Reset();
        m_pBuffer = nullptr;
        RETURN_NOERROR;
    }
};
 
//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());
}
 
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);
}
 
}
 
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 sample_data
{
    static_assert(std::is_trivially_copyable<T>::value,
                  "You can only use plain types or structs without pointers or complex members.");
 
private:
    ucom::object_ptr<const ant::ISample> m_pCurrentSample;
    ucom::object_ptr_shared_locked<const ISampleBuffer> m_pBuffer;
public:
    sample_data()
    {
    }
 
    sample_data(const sample_data& oSampleData)
    {
        Reset(oSampleData.m_pCurrentSample);
    }
    sample_data(sample_data&& oSampleData)
    {
        std::swap(m_pCurrentSample, oSampleData.m_pCurrentSample);
        std::swap(m_pBuffer, oSampleData.m_pBuffer);
    }
    sample_data(const ucom::iobject_ptr<const ant::ISample>& pSample)
    {
        Reset(pSample);
    }
 
    sample_data(const ucom::iobject_ptr<const ISample>& pSample)
    {
        Reset(ucom::ucom_object_ptr_cast<const ant::ISample>(pSample));
    }
 
    tTimeStamp GetTime() const
    {
        if (m_pCurrentSample)
        {
            return m_pCurrentSample->GetTime();
        }
        return -1;
    }
 
    adtf::base::flash::tNanoSeconds GetTimeNs() const
    {
        if (m_pCurrentSample)
        {
            return get_sample_time(m_pCurrentSample);
        }
        return adtf::base::tNanoSeconds{-1};
    }
 
    const T* GetDataPtr() const
    {
        if (m_pBuffer)
        {
            return reinterpret_cast<const T*>(m_pBuffer->GetPtr());
        }
        else
        {
            return nullptr;
        }
    }
 
    size_t GetDataSize() const
    {
        if (m_pBuffer)
        {
            return m_pBuffer->GetSize();
        }
        else
        {
            return 0;
        }
    }
 
    const T* operator->()
    {
        return GetDataPtr();
    }
 
    const T* operator->() const
    {
        return GetDataPtr();
    }
 
    const T& GetData() const
    {
        if (IsValid())
        {
            return *GetDataPtr();
        }
        else
        {
            static T oDefaultValue;
            return oDefaultValue;
        }
    }
 
    const T& operator*() const
    {
        return GetData();
    }
 
    bool IsValid() const
    {
        return (m_pCurrentSample && m_pBuffer && m_pBuffer->GetSize() >= sizeof(T));
    }
 
    operator const T&() const
    {
        return GetData();
    }
 
    tResult Reset(const ucom::ant::iobject_ptr<const ant::ISample>& pSample)
    {
        RETURN_IF_FAILED(pSample->Lock(m_pBuffer));
        m_pCurrentSample = pSample;
        RETURN_NOERROR;
    }
 
    tResult Reset()
    {
        m_pCurrentSample.Reset();
        m_pBuffer = nullptr;
        RETURN_NOERROR;
    }
};
 
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(tTimeStamp tmSampleTime)
        {
            THROW_IF_FAILED(alloc_sample(m_pSample, tmSampleTime));
            THROW_IF_FAILED(m_pSample->WriteLock(m_pBuffer, sizeof(T)));
        }
 
        output_sample_data(base::flash::tNanoSeconds tmSampleTime,
                           const T& oValue):
            output_sample_data(tmSampleTime)
        {
            GetData() = oValue;
        }
 
        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)));
            GetData() = oValue;
        }
 
        output_sample_data(tTimeStamp tmSampleTime,
                           const T& oValue):
            output_sample_data(tmSampleTime)
        {
            GetData() = oValue;
        }
 
        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 (%d), does not match the size of the requested type (%d).",
                                 m_pBuffer->GetSize(),
                                 sizeof(T));
            }
        }
 
        explicit output_sample_data(const ucom::ant::iobject_ptr<const ant::ISample>& pSampleToCopy):
            output_sample_data(*pSampleToCopy.Get())
        {
        }
 
        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);
        }
 
        T* GetDataPtr()
        {
            return const_cast<T*>(const_cast<const output_sample_data*>(this)->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());
        }
 
        T* operator->()
        {
            return GetDataPtr();
        }
 
        const T* operator->() const
        {
            return GetDataPtr();
        }
 
        T& GetData()
        {
            return *GetDataPtr();
        }
 
        const T& GetData() const
        {
            return *GetDataPtr();
        }
 
        T& operator*()
        {
            return GetData();
        }
 
        const T& operator*() const
        {
            return GetData();
        }
 
        output_sample_data& operator=(const T& oValue)
        {
            GetData() = oValue;
            return *this;
        }
 
        operator T&()
        {
            return GetData();
        }
 
        operator const T&() const
        {
            return GetData();
        }
 
        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;
        }
 
    protected:
        ucom::ant::object_ptr<ant::ISample> m_pSample;
        ucom::ant::object_ptr_locked<ant::ISampleBuffer> m_pBuffer;
 
    private:
        output_sample_data(const output_sample_data&) = delete;
        output_sample_data& operator=(const output_sample_data&) = delete;
};
 
}
 
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::sample_data;
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