streamitem_intf.h

Go to the documentation of this file.

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

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

        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 IStreamItem {…};

class cStreamItem: public IStreamItem
{
    private:
        tType m_eType;
        adtf::ucom::ant::object_ptr<const IStreamType> m_pStreamType;
        adtf::ucom::ant::object_ptr<const ISample> m_pSample;
 
    public:
        cStreamItem(): m_eType(tType::Undefined)
        {
        }
        cStreamItem(): m_eType(tType::Undefined) {…}

        cStreamItem(const IStreamItem& oItem):
            m_eType(oItem.GetType())
        {
            switch (m_eType)
            {
                case tType::StreamType:
                {
                    oItem.GetStreamType(m_pStreamType);
                    break;
                }
                case tType::Sample:
                {
                    oItem.GetSample(m_pSample);
                    break;
                }
                default:
                {
                    break;
                }
            }
        }
        cStreamItem(const IStreamItem& oItem): {…}

        cStreamItem(const ucom::ant::iobject_ptr<const ISample>& pSample):
            m_eType(tType::Sample),
            m_pSample(pSample)
        {
        }
        cStreamItem(const ucom::ant::iobject_ptr<const ISample>& pSample): {…}

        cStreamItem(const ucom::ant::iobject_ptr<const IStreamType>& pStreamType):
            m_eType(tType::StreamType),
            m_pStreamType(pStreamType)
        {
        }
        cStreamItem(const ucom::ant::iobject_ptr<const IStreamType>& pStreamType): {…}

        cStreamItem(const cStreamItem&) = default;
        cStreamItem(cStreamItem&&) = default;

        cStreamItem& operator=(const cStreamItem&) = default;
        cStreamItem& operator=(cStreamItem&&) = default;
 
        tType GetType() const
        {
            return m_eType;
        }
        tType GetType() const {…}
 
        tResult GetObject(ucom::ant::iobject_ptr<const ucom::ant::IObject>& pObject) const
        {
            switch (m_eType)
            {
                case tType::StreamType:
                {
                    return pObject.Reset(m_pStreamType);
                }
                case tType::Sample:
                {
                    return pObject.Reset(m_pSample);
                }
                default:
                {
                    RETURN_ERROR(ERR_INVALID_TYPE);
                }
            }
        }
        tResult GetObject(ucom::ant::iobject_ptr<const ucom::ant::IObject>& pObject) const {…}
 
        tResult GetSample(ucom::ant::iobject_ptr<const ISample>& pSample) const
        {
            if (m_eType != tType::Sample)
            {
                RETURN_ERROR(ERR_INVALID_TYPE);
            }
 
            return pSample.Reset(m_pSample);
        }
        tResult GetSample(ucom::ant::iobject_ptr<const ISample>& pSample) const {…}
 
        tResult GetStreamType(ucom::ant::iobject_ptr<const IStreamType>& pStreamType) const
        {
            if (m_eType != tType::StreamType)
            {
                RETURN_ERROR(ERR_INVALID_TYPE);
            }
 
            return pStreamType.Reset(m_pStreamType);
        }
        tResult GetStreamType(ucom::ant::iobject_ptr<const IStreamType>& pStreamType) const {…}
 
        tResult SetSample(const ucom::ant::iobject_ptr<const ISample>& pSample)
        {
            m_pSample = pSample;
            m_eType = tType::Sample;
            m_pStreamType.Reset();
            RETURN_NOERROR;
        }
        tResult SetSample(const ucom::ant::iobject_ptr<const ISample>& pSample) {…}
 
        tResult SetStreamType(const ucom::ant::iobject_ptr<const IStreamType>& pStreamType)
        {
            m_pStreamType = pStreamType;
            m_eType = tType::StreamType;
            m_pSample.Reset();
            RETURN_NOERROR;
        }
        tResult SetStreamType(const ucom::ant::iobject_ptr<const IStreamType>& pStreamType) {…}

        tResult CopyTo(IStreamItem& oDest) const
        {
            switch (m_eType)
            {
                case tType::StreamType:
                {
                    return oDest.SetStreamType(m_pStreamType);
                }
                case tType::Sample:
                {
                    return oDest.SetSample(m_pSample);
                }
                default:
                {
                    RETURN_ERROR(ERR_INVALID_TYPE);
                }
            }
        }
        tResult CopyTo(IStreamItem& oDest) const {…}
};
class cStreamItem: public IStreamItem {…};
 
 
} //namespace ant

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