sample_data.h

Go to the documentation of this file.

#pragma once
#include "sample_intf.h"
 
#include <type_traits>
#include <cstring>
 
namespace adtf
{
namespace streaming
{
namespace ant
{
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;
    }
};
 
} // namespace ant
 
namespace flash
{
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 base::duration_cast<tTimeStamp>(GetTimeNs());
        }
        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
        {
            THROW_ERROR_DESC(ERR_INVALID_STATE, "No sample attached.");
        }
    }

    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;
    }

    adtf_util::cVariant GetSampleInfo(const ISampleInfo::tHashKey& oHash,
                                      const adtf::util::cVariant oDefault = adtf::util::cVariant()) const
    {
        if (m_pCurrentSample)
        {
            return ant::get_sample_info(*m_pCurrentSample, oHash, oDefault);
        }
        return oDefault;
    }
};
} // namespace flash
 
namespace penguin
{
template<typename T, typename Enable = void>
class sample_data
{
private:
    ucom::object_ptr<const ant::ISample> m_pCurrentSample;
    ucom::object_ptr_shared_locked<const ISampleBuffer> m_pBuffer;
    T m_oExtractedValue = {};
 
public:
    sample_data()
    {
    }

    sample_data(const sample_data& oSampleData)
    {
        Reset(oSampleData.m_pCurrentSample);
    }

    sample_data(sample_data&& oSampleData):
        m_pCurrentSample(std::move(oSampleData.m_pCurrentSample)),
        m_pBuffer(std::move(oSampleData.m_pBuffer)),
        m_oExtractedValue(std::move(oSampleData.m_oExtractedValue))
    {
    }

    sample_data(const ucom::iobject_ptr<const ant::ISample>& pSample)
    {
        Reset(pSample);
    }
 
    sample_data(const ucom::iobject_ptr<const flash::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 &m_oExtractedValue;
        }
        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 m_oExtractedValue;
        }
        else
        {
            THROW_ERROR_DESC(ERR_INVALID_STATE, "No sample attached.");
        }
    }

    T&& GetData() &&
    {
        if (IsValid())
        {
            return std::move(m_oExtractedValue);
        }
        else
        {
            THROW_ERROR_DESC(ERR_INVALID_STATE, "No sample attached.");
        }
    }

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

    bool IsValid() const
    {
        return (m_pCurrentSample && m_pBuffer && m_pBuffer->GetSize() >= 0);
    }

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

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

    tResult Reset(const ucom::ant::iobject_ptr<const ant::ISample>& pSample)
    {
        RETURN_IF_FAILED(pSample->Lock(m_pBuffer));
        m_pCurrentSample = pSample;
        // We immediatelly read the value here if there is a specialization for T
        RETURN_IF_FAILED(m_pBuffer->Read(adtf::base::adtf_memory<T>(&m_oExtractedValue)));
        RETURN_NOERROR;
    }

    tResult Reset()
    {
        m_oExtractedValue = T{};
        m_pCurrentSample.Reset();
        m_pBuffer = nullptr;
        RETURN_NOERROR;
    }

    adtf_util::cVariant GetSampleInfo(const ISampleInfo::tHashKey& oHash,
                                      const adtf::util::cVariant oDefault = adtf::util::cVariant()) const
    {
        if (m_pCurrentSample)
        {
            return ant::get_sample_info(*m_pCurrentSample, oHash, oDefault);
        }
        return oDefault;
    }
};

template<typename T>
class sample_data<T, typename std::enable_if_t<std::is_trivially_copyable<T>::value>> : public flash::sample_data<T>
{
private:
    using _base_type = flash::sample_data<T>;
 
public:
    sample_data(): _base_type()
    {
    }

    sample_data(const sample_data& oSampleData): _base_type(oSampleData)
    {
    }

    sample_data(sample_data&& oSampleData): _base_type(oSampleData)
    {
    }

    sample_data(const ucom::iobject_ptr<const ant::ISample>& pSample): _base_type(pSample)
    {
    }

    sample_data(const ucom::iobject_ptr<const flash::ISample>& pSample): _base_type(pSample)
    {
    }
};
 
} // namespace penguin
 
using penguin::sample_data;
 
} // namespace streaming
} // namespace adtf