streamitem_intf.h

Go to the documentation of this file.

#pragma once
 
#include "sample_intf.h"
#include "streamtype_intf.h"
 
#include <variant>
 
namespace adtf
{
namespace streaming
{
namespace ant
{

class IStreamItem
{
protected:
    ~IStreamItem() = default;
 
public:
    enum class tType : uint32_t
    {
        Undefined = 0,
        StreamType = 1,
        Sample = 2,
    };

    virtual tType GetType() const = 0;

    virtual tResult GetObject(ucom::ant::iobject_ptr<const ucom::ant::IObject>& pObject) const = 0;

    virtual tResult GetSample(ucom::ant::iobject_ptr<const ISample>& pSample) const = 0;

    virtual tResult GetStreamType(ucom::ant::iobject_ptr<const IStreamType>& pStreamType) const = 0;

    virtual tResult SetSample(const ucom::ant::iobject_ptr<const ISample>& pSample) = 0;

    virtual tResult SetStreamType(const ucom::ant::iobject_ptr<const IStreamType>& pStreamType) = 0;
};

class cStreamItem : public ant::IStreamItem
{
private:
    std::variant<std::monostate,
                 adtf::ucom::ant::object_ptr<const IStreamType>,
                 adtf::ucom::ant::object_ptr<const ISample>>
        m_oPtr;
 
public:
    constexpr cStreamItem() noexcept
    {
    }

    cStreamItem(const IStreamItem& oItem)
    {
        switch (oItem.GetType())
        {
            case tType::StreamType:
            {
                auto& pTypePtr = m_oPtr.emplace<adtf::ucom::ant::object_ptr<const IStreamType>>();
                THROW_IF_FAILED(oItem.GetStreamType(pTypePtr));
                break;
            }
            case tType::Sample:
            {
                auto& pSamplePtr = m_oPtr.emplace<adtf::ucom::ant::object_ptr<const ISample>>();
                THROW_IF_FAILED(oItem.GetSample(pSamplePtr));
                break;
            }
            default:
            {
                break;
            }
        }
    }

    constexpr cStreamItem(const ucom::ant::iobject_ptr<const ISample>& pSample) noexcept:
        m_oPtr(std::in_place_type<adtf::ucom::ant::object_ptr<const ISample>>, pSample)
    {
    }

    constexpr cStreamItem(const ucom::ant::iobject_ptr<const IStreamType>& pStreamType) noexcept:
        m_oPtr(std::in_place_type<adtf::ucom::ant::object_ptr<const IStreamType>>, pStreamType)
    {
    }

    cStreamItem(const cStreamItem& oOther) noexcept: m_oPtr(oOther.m_oPtr)
    {
    }

    cStreamItem(cStreamItem&& oOther) noexcept: m_oPtr(std::move(oOther.m_oPtr))
    {
    }

    cStreamItem& operator=(const cStreamItem&) = default;
    cStreamItem& operator=(cStreamItem&&) = default;
 
    tType GetType() const noexcept override
    {
        if (std::holds_alternative<adtf::ucom::ant::object_ptr<const IStreamType>>(m_oPtr))
        {
            return tType::StreamType;
        }
        else if (std::holds_alternative<adtf::ucom::ant::object_ptr<const ISample>>(m_oPtr))
        {
            return tType::Sample;
        }
        else
        {
            return tType::Undefined;
        }
    }
 
    tResult GetObject(ucom::ant::iobject_ptr<const ucom::ant::IObject>& pObject) const noexcept override
    {
        if (std::holds_alternative<adtf::ucom::ant::object_ptr<const IStreamType>>(m_oPtr))
        {
            RETURN_IF_FAILED(pObject.Reset(std::get<adtf::ucom::ant::object_ptr<const IStreamType>>(m_oPtr)));
            RETURN_NOERROR;
        }
        else if (std::holds_alternative<adtf::ucom::ant::object_ptr<const ISample>>(m_oPtr))
        {
            RETURN_IF_FAILED(pObject.Reset(std::get<adtf::ucom::ant::object_ptr<const ISample>>(m_oPtr)));
            RETURN_NOERROR;
        }
        else
        {
            RETURN_ERROR(ERR_INVALID_TYPE);
        }
    }
 
    tResult GetSample(ucom::ant::iobject_ptr<const ISample>& pSample) const noexcept override
    {
        if (std::holds_alternative<adtf::ucom::ant::object_ptr<const ISample>>(m_oPtr))
        {
            RETURN_IF_FAILED(pSample.Reset(std::get<adtf::ucom::ant::object_ptr<const ISample>>(m_oPtr)));
            RETURN_NOERROR;
        }
        else
        {
            RETURN_ERROR(ERR_INVALID_TYPE);
        }
    }
 
    tResult GetStreamType(ucom::ant::iobject_ptr<const IStreamType>& pStreamType) const noexcept override
    {
        if (std::holds_alternative<adtf::ucom::ant::object_ptr<const IStreamType>>(m_oPtr))
        {
            RETURN_IF_FAILED(pStreamType.Reset(std::get<adtf::ucom::ant::object_ptr<const IStreamType>>(m_oPtr)));
            RETURN_NOERROR;
        }
        else
        {
            RETURN_ERROR(ERR_INVALID_TYPE);
        }
    }
 
    tResult SetSample(const ucom::ant::iobject_ptr<const ISample>& pSample) noexcept override
    {
        RETURN_IF_THROWS(*this = cStreamItem(pSample));
        RETURN_NOERROR;
    }
 
    tResult SetStreamType(const ucom::ant::iobject_ptr<const IStreamType>& pStreamType) noexcept override
    {
        RETURN_IF_THROWS(*this = cStreamItem(pStreamType));
        RETURN_NOERROR;
    }

    tResult CopyTo(IStreamItem& oDest) const noexcept
    {
        if (std::holds_alternative<adtf::ucom::ant::object_ptr<const IStreamType>>(m_oPtr))
        {
            RETURN_IF_FAILED(oDest.SetStreamType(std::get<adtf::ucom::ant::object_ptr<const IStreamType>>(m_oPtr)));
            RETURN_NOERROR;
        }
        else if (std::holds_alternative<adtf::ucom::ant::object_ptr<const ISample>>(m_oPtr))
        {
            RETURN_IF_FAILED(oDest.SetSample(std::get<adtf::ucom::ant::object_ptr<const ISample>>(m_oPtr)));
            RETURN_NOERROR;
        }
        else
        {
            RETURN_ERROR(ERR_INVALID_TYPE);
        }
    }
};
} // namespace ant

using ant::IStreamItem;
using ant::cStreamItem;
 
} // namespace streaming
} // namespace adtf