samplequeue.h

Go to the documentation of this file.

 
#pragma once
#include "sample_intf.h"
#include "samplequeue_intf.h"
 
#include <shared_mutex>
 
namespace adtf
{
namespace streaming
{
namespace ant
{
 
struct cSampleQueueCompareByTime
{
    bool operator()(const adtf::ucom::iobject_ptr<ISample>& pSampleAdd, const adtf::ucom::iobject_ptr<ISample>& pSample) const
    {
        if (pSample.Get() != nullptr && pSampleAdd.Get() != nullptr)
        {
            return (pSampleAdd.Get()->GetTime() < pSample.Get()->GetTime());
        }
        return true;
    }
};
 
#define ADTF_SAMPLEQUEUE_CLASS_VERSION_01      0x01
 
class cSampleQueue :
    public ucom::catwo::object<ISampleQueue>
{
    A_UTILS_D(cSampleQueue)
 
    public:
        cSampleQueue(tTimeStamp tmTimeRange, size_t szMaxSize, bool bClearOnTimeJumps = false);
 
        virtual ~cSampleQueue();
 
    protected:
        adtf::base::tNanoSeconds m_tmTimeRange;                              
        size_t       m_szMaxSize;                                
        bool       m_bError;                                   
 
        bool       m_bTimeStampsInitialized;                   
        adtf::base::tNanoSeconds m_tmFirstTime;                              
        adtf::base::tNanoSeconds m_tmLastTime;                               
 
        std::recursive_mutex        m_oEventListLocked;        
        std::list<ISampleQueueEventSink*> m_lstQueueEventReceiver;    
        bool                       m_bFireEvents;              
        int                        m_nClearingQueueCount;      
 
        adtf::ucom::object_ptr<ISample>   m_pLastSample;        
        std::shared_mutex        m_oQueueReadWriteLock;        
 
        typedef std::multimap<adtf::base::tNanoSeconds, adtf::ucom::ant::object_ptr<ISample>> tSampleQueue; 
        tSampleQueue    m_qSamples;                             
 
    public: //implements ISampleQueue
        tResult Push(const iobject_ptr<ISample>& pSample);
        tResult Pop(iobject_ptr<ISample>& pSample);
        tResult Pop();
        tResult Top(iobject_ptr<ISample>& pSample);
 
        size_t GetSize();
        bool Empty();
 
        tResult Get(iobject_ptr<ISample>& pSample,
                       tTimeStamp     tmTime,
                       tTimeStamp     tmDeltaT,
                       uint32_t        ui32GetMethod=SQG_GetLast);
 
        tResult RegisterQueueEventSink(ISampleQueueEventSink* pQueueEventSink);
        tResult UnregisterQueueEventSink(const ISampleQueueEventSink* pQueueEventSink);
 
        tResult GetSettings(tTimeStamp& tmTimeRange, size_t& szSizeRange) const;
        tResult SetSettings(const tTimeStamp tmTimeRange, const size_t szSizeRange);
        void GetTimes(tTimeStamp& tmFirst, tTimeStamp& tmLast) const;
 
    public:
        tResult Clear();
 
        tResult SetRanges(tTimeStamp tmTimeRange, size_t szMaxSize=0);
 
    protected:
        tResult ClearEventList();
        tResult GetNearest2(iobject_ptr<ISample>& pSampleOlder, iobject_ptr<ISample>& pSampleNewer, tTimeStamp tmTime);
        tResult GetNearest(iobject_ptr<ISample>& pSample, tTimeStamp tmTime, tTimeStamp tmDeltaT);
        tResult GetNearestOlder(iobject_ptr<ISample>& pSample, tTimeStamp tmTime, tTimeStamp tmDeltaT);
        tResult GetNearestNewer(iobject_ptr<ISample>& ppSample, tTimeStamp tmTime, tTimeStamp tmDeltaT);
 
        tResult FireEvent(uint32_t ui32Event,
                          int nParam1,
                          int nParam2);
 
    public: 
        //not implemented
        tResult HandleEvent(ucom::IEventSource* pSource, void* pvEventData);
    private:
        tResult InternalPop(iobject_ptr<ISample>& pSample);
};
 
} //namesapce ant
} //namespac streaming
} // namespace adtf