samplestream.h

Go to the documentation of this file.

 
#pragma once
#include "samplestream_intf.h"
#include "sampleinstream_intf.h"
#include "sampleoutstream_intf.h"
#include "streamtype.h"
#include "samplestreamaccess_intf.h"
#include "triggerpipe_intf.h"
#include "triggerpipe.h"
#include "streamingrequests_intf.h"
 
#include <adtfbase/adtf_base.h>
#include <adtfucom3/adtf_ucom3.h>
 
#include <memory>
 
namespace adtf
{
namespace streaming
{
namespace ant
{
namespace detail
{ 
    class cSampleStreamBase: public adtf::base::ant::runnable<adtf::base::ant::IRunnable::RUN_TRIGGER>
    {
        A_UTILS_D(cSampleStreamBase);
 
 
    protected:
        cSampleStreamBase(const cSampleStreamBase&) = delete;
        cSampleStreamBase(cSampleStreamBase&&) = delete;
        cSampleStreamBase& operator=(const cSampleStreamBase&) = delete;
        cSampleStreamBase& operator=(cSampleStreamBase&&) = delete;
 
    public:
        cSampleStreamBase();
        virtual ~cSampleStreamBase() = default;
 
        tResult GetStreamError();
 
    public:
        tResult Open(const char* strName,
                     adtf::ucom::ant::iobject_ptr<ISampleInStream>& pInStream,
                     const adtf::ucom::ant::iobject_ptr<const IStreamType>& pInitialAcceptedStreamType,
                     ISampleStream::IPushReadEventSink*& pPushEventSink,
                     ISampleStreamAccess::tMode ui32Mode,
                     size_t szQueueSize,
                     adtf::ucom::ant::IObject* pParent);
        tResult Open(const char* strName,
                     adtf::ucom::ant::iobject_ptr<ISampleOutStream>& pOutStream,
                     ISampleStreamAccess::tMode ui32Mode,
                     size_t szQueueSize,
                     adtf::ucom::ant::IObject* pParent);
 
        tResult GetType(adtf::ucom::ant::iobject_ptr<const IStreamType>& pStreamType) const;
 
        tTimeStamp GetTime() const;
        tResult    SetStreamError(const tResult& oError);
        tResult AttachRouting(const adtf::ucom::ant::iobject_ptr<ISampleStream>& pSampleStreamTo);
        tResult DetachRouting(const adtf::ucom::ant::iobject_ptr<ISampleStream>& pSampleStreamTo);
        
        tResult SetFullName(const char* strName);
        
        tResult RunTrigger(tTimeStamp tmActivationTime);
 
        tResult GetInternalBindingProxy(ucom::ant::iobject_ptr<ant::IBindingProxy>& pBindingProxy);
 
        void SetSubStreamFilter(const char* strSubStream);
 
        uint64_t GetItemCount();
    };
}
 
    template <typename INTERFACE = ISampleStream>
    class sample_stream: public ucom::catwo::object<detail::cSampleStreamBase, ISampleStream, named_graph_object<trigger_pipe_item<INTERFACE>>>
    {
        typedef named_graph_object<trigger_pipe_item<INTERFACE>> base_type;
 
    protected:
        sample_stream(sample_stream&&) = delete;
        sample_stream(const sample_stream&) = delete;
        sample_stream& operator=(sample_stream&&) = delete;
        sample_stream& operator=(const sample_stream&) = delete;
 
    public:
        sample_stream()
        {
            base_type::SetRunnable(*static_cast<detail::cSampleStreamBase*>(this));
        }
        sample_stream(const char* strName) : sample_stream()
        {
            SetName(strName);
        }
        ~sample_stream() = default;
 
        tResult SetName(const char* strName) override
        {
            RETURN_IF_FAILED(base_type::SetName(strName));
            return detail::cSampleStreamBase::SetFullName(strName);
        }
 
        tResult SetParent(const ucom::ant::IObject* oParentObject) override
        {
            RETURN_IF_FAILED(base_type::SetParent(oParentObject));
            return detail::cSampleStreamBase::SetFullName(get_named_graph_object_full_name(*this));
        }
 
        tResult Open(const char* strName,
                     adtf::ucom::ant::iobject_ptr<ISampleInStream>& pInStream,
                     const adtf::ucom::ant::iobject_ptr<const IStreamType>& pInitialAcceptedStreamType,
                     ISampleStream::IPushReadEventSink*& pPushEventSink,
                     ISampleStreamAccess::tMode ui32Mode,
                     size_t szQueueSize) override
        {
            return detail::cSampleStreamBase::Open(strName,
                                                   pInStream,
                                                   pInitialAcceptedStreamType,
                                                   pPushEventSink,
                                                   ui32Mode,
                                                   szQueueSize,
                                                   adtf::ucom::ant::ucom_cast<adtf::ucom::ant::IObject*>(this));
        }
 
        tResult Open(const char* strName,
                     adtf::ucom::ant::iobject_ptr<ISampleOutStream>& pOutStream,
                     ISampleStreamAccess::tMode ui32Mode,
                     size_t szQueueSize) override
        {
            return detail::cSampleStreamBase::Open(strName,
                                                   pOutStream,
                                                   ui32Mode,
                                                   szQueueSize,
                                                   adtf::ucom::ant::ucom_cast<adtf::ucom::ant::IObject*>(this));
        }
 
        tResult GetType(adtf::ucom::ant::iobject_ptr<const IStreamType>& pStreamType) const override
        {
            return detail::cSampleStreamBase::GetType(pStreamType);
        }
 
        tTimeStamp GetTime() const override
        {
            return detail::cSampleStreamBase::GetTime();
        }
        tResult SetStreamError(const tResult& oError) override
        {
            return detail::cSampleStreamBase::SetStreamError(oError);
        }
        tResult AttachRouting(const adtf::ucom::ant::iobject_ptr<ISampleStream>& pSampleStreamTo) override
        {
            return detail::cSampleStreamBase::AttachRouting(pSampleStreamTo);
        }
        tResult DetachRouting(const adtf::ucom::ant::iobject_ptr<ISampleStream>& pSampleStreamTo) override
        {
            return detail::cSampleStreamBase::DetachRouting(pSampleStreamTo);
        }        
    };
 
    class cSampleStream :
        public sample_stream<ISampleStream>
    {
        A_UTILS_D(cSampleStream);
 
        public: 
            ADTF_CLASS_ID_NAME(cSampleStream, "sample_stream.streaming.adtf.cid", "Sample Stream");
 
        public:
            template<typename T>
            using iobject_ptr = adtf::ucom::ant::iobject_ptr < T >;
 
        protected: 
            cSampleStream(const cSampleStream&) = delete;
            cSampleStream(cSampleStream&&) = delete;
            cSampleStream& operator=(const cSampleStream&) = delete;
            cSampleStream& operator=(cSampleStream&&) = delete;
 
        public: 
            cSampleStream() = default;
            cSampleStream(const char* strName) 
            {
                sample_stream::SetName(strName);
            }
            virtual ~cSampleStream() = default;
 
    };
 
 
} //namespace ant
 
namespace flash
{
 
class cSampleStream: public ucom::catwo::object<base::ant::IRunnable,
                                                ant::ITriggerPipeSource,
                                                ant::ITriggerPipeItem,
                                                ant::INamedGraphObject,
                                                ant::ISampleStream,
                                                hollow::IInternalBindingProxy,
                                                base::flash::IRunnable>
{
    public:
        ADTF_CLASS_ID_NAME(cSampleStream, "sample_stream.streaming.adtf.cid", "Sample Stream");
 
    public:
        cSampleStream();
        cSampleStream(const char* strName);
 
    public:
        tResult GetStreamError();
        tResult GetType(ucom::ant::iobject_ptr<const ant::IStreamType>& pStreamType) const override;
        tTimeStamp GetTime() const override;
        tResult SetStreamError(const tResult& oError) override;
        tResult AttachRouting(const ucom::ant::iobject_ptr<ant::ISampleStream>& pSampleStreamTo) override;
        tResult DetachRouting(const ucom::ant::iobject_ptr<ant::ISampleStream>& pSampleStreamTo) override;
        tResult Open(const char* strName,
                     ucom::ant::iobject_ptr<ant::ISampleInStream>& pInStream,
                     const ucom::ant::iobject_ptr<const ant::IStreamType>& pInitialAcceptedStreamType,
                     ant::ISampleStream::IPushReadEventSink*& pPushEventSink,
                     ant::ISampleStreamAccess::tMode ui32Mode,
                     size_t szQueueSize) override;
        tResult Open(const char* strName,
                     ucom::ant::iobject_ptr<ant::ISampleOutStream>& pOutStream,
                     ant::ISampleStreamAccess::tMode ui32Mode,
                     size_t szQueueSize) override;
 
        ADTF_FLASH_TRIGGER_PIPE_ITEM_METHOD_DECLARATIONS
 
        tResult GetInternalBindingProxy(ucom::ant::iobject_ptr<ant::IBindingProxy>& pBindingProxy) override;
        void SetSubStreamFilter(const char* strSubStream);
        void SetForwardAllTriggers(bool bForwardAll);
 
    protected:
        ~cSampleStream() override;
 
    protected:
        class cImplementation;
        std::unique_ptr<cImplementation> m_pImplementation;
};
 
}
 
namespace quiet
{
 
class cSampleStream: public ucom::catwo::object<flash::cSampleStream,
                                                ITriggerPipeHierachy>
{
    public:
        ADTF_CLASS_ID_NAME(cSampleStream, "sample_stream.streaming.adtf.cid", "Sample Stream");
 
    public:
        cSampleStream();
        cSampleStream(const char* strName);
 
        ADTF_QUIET_TRIGGER_PIPE_ITEM_METHOD_DECLARATIONS
 
    protected:
        ~cSampleStream() override;
};
 
}
 
using quiet::cSampleStream;
 
using ant::sample_stream;
} //namespac streaming
} //namespace adtf