cQueue.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cQueue_H
#define _INC_cQueue_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "cHeap.h"
#include "HResult.h"
#include "cArray.h"
#include "cStreamProgress.h"
 
namespace Gray
{
        class GRAYCORE_LINK cQueueBase
        {
 
        protected:
                ITERATE_t m_iReadLast;  
                ITERATE_t m_iWriteLast; 
 
        public:
                cQueueBase(ITERATE_t iReadLast = 0, ITERATE_t iWriteLast = 0) noexcept
                        : m_iReadLast(iReadLast)
                        , m_iWriteLast(iWriteLast)
                {
                }
                void InitQ(ITERATE_t iReadLast = 0, ITERATE_t iWriteLast = 0) noexcept
                {
                        m_iReadLast = iReadLast;
                        m_iWriteLast = iWriteLast;      // put new data here.
                }
                bool isEmptyQ() const noexcept
                {
                        return m_iReadLast == m_iWriteLast;
                }
                void EmptyQ() noexcept
                {
                        m_iReadLast = m_iWriteLast = 0;
                }
 
                ITERATE_t get_ReadIndex() const noexcept
                {
                        return m_iReadLast;
                }
                ITERATE_t get_WriteIndex() const noexcept
                {
                        return m_iWriteLast;
                }
                inline ITERATE_t get_ReadQty() const
                {
                        ASSERT(m_iWriteLast >= m_iReadLast);    // Assume will not will wrap to fill.
                        return m_iWriteLast - m_iReadLast;
                }
 
                inline void AdvanceRead(ITERATE_t iCount = 1)
                {
                        // Assume will not will wrap to fill.
                        m_iReadLast += iCount;
                        ASSERT(m_iReadLast >= 0 && m_iReadLast <= m_iWriteLast);        // Assume will not will wrap to fill.
                }
 
                STREAM_SEEKRET_t SeekQ(STREAM_OFFSET_t iOffset, SEEK_ORIGIN_TYPE eSeekOrigin = SEEK_Set);       // support virtual
 
                UNITTEST_FRIEND(cQueue);
        };
 
        //*********************************************************************
 
        template<class TYPE = BYTE, ITERATE_t _QTY = 1024>
        class cStackStatic
        {
 
                TYPE m_Data[_QTY];              
                ITERATE_t m_iWriteNext; 
 
        public:
                inline cStackStatic() noexcept
                        : m_iWriteNext(0)
                {
                        STATIC_ASSERT(_QTY > 0, cStackStatic);
                }
                inline bool isEmpty() const noexcept
                {
                        return m_iWriteNext == 0;
                }
                inline bool isFull() const noexcept
                {
                        return m_iWriteNext >= _QTY;
                }
                inline TYPE Pop()
                {
                        ASSERT(m_iWriteNext >= 1);
                        return m_Data[--m_iWriteNext];
                }
                inline void Push(TYPE v)
                {
                        ASSERT(m_iWriteNext < _QTY);
                        m_Data[m_iWriteNext++] = v;
                }
        };
 
        template<class TYPE = BYTE, ITERATE_t _QTY = 1024>
        class GRAYCORE_LINK cQueueStatic : public cQueueBase
        {
 
        public:
                TYPE m_Data[_QTY];              // Not heap allocation.
 
        protected:
                inline ITERATE_t GetWrapIndex(ITERATE_t i) const noexcept
                {
                        return i % _QTY;
                }
 
        private:
                inline ITERATE_t get_ReadQty() const    // Don't use this if we wrap.
                {
                        ASSERT(false);
                        return 0;
                }
 
        public:
                cQueueStatic() noexcept
                {
                        STATIC_ASSERT(_QTY > 0, _QTY);
#if defined(_DEBUG)
                        cMem::Zero(m_Data, sizeof(m_Data));
#endif
                }
                bool isFullQ() const noexcept
                {
                        return GetWrapIndex(m_iWriteLast + 1) == m_iReadLast;
                }
                void EmptyQ() noexcept
                {
                        m_iReadLast = m_iWriteLast;
                }
                ITERATE_t get_ReadQtyT() const noexcept
                {
                        ITERATE_t iWrite = m_iWriteLast;
                        ITERATE_t iRead = m_iReadLast;
                        if (iRead > iWrite)     // wrap
                        {
                                iWrite += _QTY;
                                DEBUG_ASSERT(iWrite > iRead, "get_ReadQtyT");   // sanity check. should never happen!
                        }
                        return iWrite - iRead;
                }
                ITERATE_t get_ReadQtyC() const noexcept
                {
                        ITERATE_t iTop = (m_iWriteLast >= m_iReadLast) ? m_iWriteLast : _QTY;
                        return iTop - m_iReadLast;
                }
                const TYPE* get_ReadPtr() const
                {
                        ASSERT(!isEmptyQ());    // ONLY call this if there is data to read.
                        return &m_Data[m_iReadLast];
                }
                void AdvanceRead(ITERATE_t iCount = 1)
                {
                        ITERATE_t iReadCount = get_ReadQtyT();
                        if (iCount > iReadCount)
                                iCount = iReadCount;
                        m_iReadLast = GetWrapIndex(m_iReadLast + iCount);
                }
 
                ITERATE_t get_WriteQtyT() const noexcept
                {
                        return (_QTY - 1) - get_ReadQtyT();
                }
 
                TYPE Read1()
                {
                        ASSERT(!isEmptyQ());
                        ITERATE_t iRead = m_iReadLast;
                        ASSERT(IS_INDEX_GOOD(iRead, _QTY));
                        ITERATE_t iReadNext = GetWrapIndex(iRead + 1);
                        TYPE val = m_Data[iRead];
                        m_iReadLast = iReadNext;
                        return val;
                }
                ITERATE_t ReadQty(TYPE* pBuf, ITERATE_t nCountMax)
                {
 
                        ITERATE_t i = 0;
                        for (; !isEmptyQ() && i < nCountMax; i++)
                        {
                                pBuf[i] = Read1();
                        }
                        return i;
                }
                ITERATE_t ReadQtySafe(TYPE* pBuf, ITERATE_t nCountMax)
                {
                        ITERATE_t i = 0;
                        for (; !isEmptyQ() && i < nCountMax; i++)
                        {
                                pBuf[i] = Read1();
                        }
                        return i;
                }
 
                bool WriteQ(TYPE val)
                {
                        ITERATE_t iWrite = m_iWriteLast;
                        ASSERT(IS_INDEX_GOOD(iWrite, _QTY));
                        ITERATE_t iWriteNext = GetWrapIndex(iWrite + 1);
                        if (iWriteNext == m_iReadLast)  // isFullQ() ?
                                return false;
                        m_Data[iWrite] = val;
                        m_iWriteLast = iWriteNext;
                        return true;
                }
                HRESULT WriteQty(const TYPE* pVal, ITERATE_t iLength)
                {
                        ITERATE_t iRoom = get_WriteQtyT();
                        ASSERT(iRoom >= 0 && iRoom <= _QTY);
                        ITERATE_t iWrite = m_iWriteLast;
                        ASSERT(iWrite >= 0 && iWrite < _QTY);
                        ITERATE_t iLengthMin = MIN(iRoom, iLength); // max i can write and hold.
                        if (iWrite + iLengthMin > _QTY) // will overflow/wrap?
                        {
                                ITERATE_t iTmp1 = _QTY - iWrite;
                                CopyElements(m_Data + iWrite, pVal, iTmp1);     // Write to end of buffer.
                                ITERATE_t iTmp2 = iLengthMin - iTmp1;
                                CopyElements(m_Data, pVal + iTmp1, iTmp2);      // Wrap back from beginning.
                                m_iWriteLast = iTmp2;
                        }
                        else
                        {
                                CopyElements(m_Data + iWrite, pVal, iLengthMin);
                                m_iWriteLast = iWrite + iLengthMin;
                        }
                        return (HRESULT)iLengthMin;
                }
 
                HRESULT WriteQtySafe(const TYPE* pVal, ITERATE_t iLength)
                {
                        ITERATE_t i = 0;
                        for (; !isFullQ() && i < iLength; i++)
                        {
                                WriteQ(pVal[i]);
                        }
                        return i;
                }
        };
 
        //*********************************************************************
 
        template <class TYPE = BYTE>
        class GRAYCORE_LINK cQueueRead : public cQueueBase
        {
 
        protected:
                TYPE* m_pData;                  
 
        public:
                cQueueRead(const TYPE* pData = nullptr, ITERATE_t iReadLast = 0, ITERATE_t iWriteLast = 0) noexcept
                        : cQueueBase(iReadLast, iWriteLast)
                        , m_pData(const_cast<TYPE*>(pData))
                {
                }
                ~cQueueRead()
                {
                        // NOT free m_pData memory.
                }
 
                // Peek into/read from the Queue's data.
                inline const TYPE* get_ReadPtr() const
                {
                        ASSERT(m_pData != nullptr);
                        return(m_pData + m_iReadLast);
                }
                void SetQueueRead(const TYPE* pData, ITERATE_t iReadLast = 0, ITERATE_t iWriteLast = 0)
                {
                        m_pData = const_cast<TYPE*>(pData);
                        InitQ(iReadLast, iWriteLast);
                }
 
                TYPE Read1(void)
                {
                        ASSERT(!isEmptyQ());
                        return m_pData[m_iReadLast++];
                }
                HRESULT ReadPeek(TYPE* pData, ITERATE_t iDataMaxQty)
                {
                        ITERATE_t iQtyAvail = get_ReadQty();
                        if (iDataMaxQty > iQtyAvail)
                                iDataMaxQty = iQtyAvail;
                        if (pData != nullptr)
                        {
                                CopyElements(pData, m_pData + m_iReadLast, iDataMaxQty);
                        }
                        return (HRESULT)iDataMaxQty;
                }
 
                HRESULT ReadQty(TYPE* pData, ITERATE_t iDataMaxQty)
                {
 
                        const ITERATE_t iQtyAvail = get_ReadQty();
                        if (iDataMaxQty > iQtyAvail)
                                iDataMaxQty = iQtyAvail;
                        if (pData != nullptr)
                        {
                                CopyElements(pData, m_pData + m_iReadLast, iDataMaxQty);
                        }
                        AdvanceRead(iDataMaxQty);               // advance m_iReadLast pointer.
                        return (HRESULT)iDataMaxQty;
                }
 
                void ReadCommitNow()
                {
                        if (this->m_iReadLast <= 0)                                     // next read is already at 0.
                                return;
                        ITERATE_t iSize = this->get_ReadQty();
                        if (iSize > 0)  // there is data to move ?
                        {
                                const TYPE* pTmp = this->m_pData + this->m_iReadLast;
                                cMem::CopyOverlap(this->m_pData, pTmp, iSize * sizeof(TYPE));
                        }
                        this->InitQ(0, iSize);
                }
        };
 
        //*********************************************************************
 
        template <class TYPE = BYTE>
        class GRAYCORE_LINK cQueueRW : public cQueueRead < TYPE >
        {
 
                typedef cQueueRead<TYPE> SUPER_t;
 
        protected:
                ITERATE_t m_iDataSizeAlloc;             
                ITERATE_t m_iAutoReadCommit;    
 
        public:
                cQueueRW() noexcept
                        : cQueueRead<TYPE>(nullptr, 0, 0)
                        , m_iDataSizeAlloc(0)
                        , m_iAutoReadCommit(0)
                {
                        // empty.
                }
                explicit cQueueRW(TYPE* pData, ITERATE_t iDataAlloc, ITERATE_t iReadLast, ITERATE_t iWriteLast, ITERATE_t iAutoReadCommit = 0)
                        : cQueueRead<TYPE>(pData, iReadLast, iWriteLast)
                        , m_iDataSizeAlloc(iDataAlloc)
                        , m_iAutoReadCommit(iAutoReadCommit)
                {
                        // Read / Write.
                }
                explicit cQueueRW(const TYPE* pData, ITERATE_t iDataMax)
                        : cQueueRead<TYPE>(const_cast<TYPE*>(pData), 0, iDataMax)
                        , m_iDataSizeAlloc(iDataMax)
                        , m_iAutoReadCommit(0)
                {
                        // Read Only iDataMax.
                }
                ~cQueueRW()
                {
                }
 
                //***************************************************
                // Reader functions.
 
                void ReadCommitCheck()
                {
                        if (m_iAutoReadCommit != 0 && this->m_iReadLast >= m_iAutoReadCommit) // (ITERATE_t) m_nGrowSizeChunk
                        {
                                this->ReadCommitNow();
                        }
                }
                ITERATE_t get_AutoReadCommit() const
                {
                        return m_iAutoReadCommit;
                }
                void put_AutoReadCommit(ITERATE_t iAutoReadCommit = 8 * 1024)
                {
                        m_iAutoReadCommit = iAutoReadCommit;
                        if (iAutoReadCommit != 0)
                        {
                                this->ReadCommitNow();
                        }
                }
 
                void put_ReadIndex(ITERATE_t iReadLo)
                {
                        ASSERT(iReadLo >= 0);
                        ASSERT(iReadLo <= this->m_iWriteLast);
                        this->m_iReadLast = iReadLo;
                        ReadCommitCheck();
                }
 
                // Act as a stream
                STREAM_SEEKRET_t SeekQ(STREAM_OFFSET_t iOffset, SEEK_ORIGIN_TYPE eSeekOrigin = SEEK_Set)
                {
                        SUPER_t::SeekQ(iOffset, eSeekOrigin);
                        ReadCommitCheck();
                        return this->m_iReadLast;
                }
 
                HRESULT ReadQty(TYPE* pData, ITERATE_t iDataMaxQty)
                {
                        HRESULT iReadQty = SUPER_t::ReadQty(pData, iDataMaxQty);
                        ReadCommitCheck();
                        return iReadQty;
                }
 
                HRESULT ReadX(void* pData, size_t nDataSize)
                {
                        HRESULT iReadQty = ReadQty((TYPE*)pData, (ITERATE_t)(nDataSize / sizeof(TYPE)));
                        return iReadQty * sizeof(TYPE);
                }
 
                //***************************************************
                // Writer functions.
 
                inline bool isFullQ() const
                {
                        // Cant fit any more. would have to grow buffer.
                        return(this->m_iWriteLast >= m_iDataSizeAlloc);
                }
 
                inline ITERATE_t get_WriteQty() const
                {
                        ASSERT(this->m_iWriteLast <= m_iDataSizeAlloc);
                        return(m_iDataSizeAlloc - this->m_iWriteLast);
                }
                inline TYPE* get_WritePtr() const
                {
                        ASSERT(this->m_pData != nullptr);
                        return(this->m_pData + this->m_iWriteLast);
                }
 
                HRESULT WriteQty(const TYPE* pData, ITERATE_t iQtyMax)
                {
 
                        ITERATE_t iWriteSpace = get_WriteQty();
                        if (iWriteSpace <= 0)
                                return 0;
                        if ((ITERATE_t)iQtyMax > iWriteSpace)
                                iQtyMax = iWriteSpace;
                        if (pData != nullptr)
                        {
                                WriteQN(pData, iQtyMax);
                        }
                        return (HRESULT)iQtyMax;
                }
 
                HRESULT WriteX(const void* pData, size_t nDataSize)
                {
                        HRESULT iReadQty = WriteQty((TYPE*)pData, (ITERATE_t)(nDataSize / sizeof(TYPE)));
                        return iReadQty * sizeof(TYPE);
                }
 
                inline void AdvanceWrite(ITERATE_t iCount = 1)
                {
                        ASSERT_N(iCount <= get_WriteQty());
                        this->m_iWriteLast += iCount;
                        ASSERT(m_iDataSizeAlloc >= this->m_iWriteLast);
                }
 
        protected:
                void WriteQN(const TYPE* pData, ITERATE_t iQtyMax)
                {
                        if (iQtyMax <= 0)
                                return;
                        ASSERT_N(this->m_iWriteLast + iQtyMax <= m_iDataSizeAlloc);
                        if (pData != nullptr)
                        {
                                CopyElements(this->m_pData + this->m_iWriteLast, pData, iQtyMax);
                        }
                        AdvanceWrite(iQtyMax);
                }
        };
 
        //*********************************************************************
 
        template<class TYPE = BYTE>
        class cQueueDyn : public cQueueRW < TYPE >
        {
 
                typedef cQueueRW<TYPE> SUPER_t;
 
        private:
                cArrayVal<TYPE> m_aData;                
 
        protected:
                ITERATE_t m_nGrowSizeChunk;             
                ITERATE_t m_nGrowSizeMax;               
 
        protected:
                bool AllocSizeMaxQ(ITERATE_t iDataAlloc)
                {
                        if (iDataAlloc > m_nGrowSizeMax)        // too big !
                        {
                                return false;
                        }
                        if (this->m_iDataSizeAlloc != iDataAlloc)
                        {
                                m_aData.SetSize(iDataAlloc);    // realloc
                                this->m_pData = m_aData.get_DataWork();
                                this->m_iDataSizeAlloc = iDataAlloc;
                        }
                        return true;
                }
 
        public:
                cQueueDyn(ITERATE_t nGrowSizeChunk = 128, ITERATE_t nGrowSizeMax = (cHeap::k_ALLOC_MAX / sizeof(TYPE))) noexcept
                        : m_nGrowSizeChunk(nGrowSizeChunk)
                        , m_nGrowSizeMax(nGrowSizeMax)
                {
 
                        ASSERT(m_nGrowSizeChunk >= 0);
                        ASSERT(m_nGrowSizeMax >= 0);
                        if (m_nGrowSizeMax > 0)
                        {
                                if (m_nGrowSizeChunk < 128)
                                        m_nGrowSizeChunk = 128;
                                if (m_nGrowSizeChunk > m_nGrowSizeMax)
                                        m_nGrowSizeMax = m_nGrowSizeChunk;
                        }
                        else
                        {
                                m_nGrowSizeChunk = 0;   // Must both be 0.
                        }
                        AllocSizeMaxQ(m_nGrowSizeChunk);
                        this->put_AutoReadCommit(m_nGrowSizeChunk / 2);         // default = half buffer.
                }
                ~cQueueDyn()
                {
                }
 
                void put_GrowSizeChunk(ITERATE_t nGrowSizeChunk) noexcept
                {
                        if (nGrowSizeChunk > m_nGrowSizeMax)    // Must not be greater!
                                m_nGrowSizeMax = nGrowSizeChunk;
                        m_nGrowSizeChunk = nGrowSizeChunk;
                }
                ITERATE_t get_GrowSizeChunk() const noexcept
                {
                        return m_nGrowSizeChunk;
                }
 
                bool MakeWritePrepared(ITERATE_t iDesiredCount = 1)
                {
                        ITERATE_t iRoom = this->get_WriteQty();
                        if (iRoom >= iDesiredCount)     // all set.
                                return true;
 
                        ITERATE_t iGrowRequest = iDesiredCount - iRoom; // how much MORE do i need?
                        ASSERT(iGrowRequest > 0);
                        ITERATE_t iChunksGrow = iGrowRequest / m_nGrowSizeChunk;
                        ITERATE_t iRem = iGrowRequest % m_nGrowSizeChunk;
                        if (iRem != 0)
                                iChunksGrow++;
 
                        ITERATE_t iTotalSize = this->m_iDataSizeAlloc + iChunksGrow * m_nGrowSizeChunk;
                        if (iTotalSize > m_nGrowSizeMax)        // too big !
                                iTotalSize = m_nGrowSizeMax;
 
                        if (iTotalSize - this->m_iWriteLast <= 0)               // can i get any?
                                return false;   // Got no more space. we must wait?
 
                        return AllocSizeMaxQ(iTotalSize);
                }
                TYPE* GetWritePrepared(ITERATE_t iDesiredCount = 1)
                {
                        if (!MakeWritePrepared(iDesiredCount))
                                return nullptr;
                        // ASSERT(get_WriteQty() >= iDesiredCount); except for m_nGrowSizeMax
                        return this->get_WritePtr();
                }
 
                bool WriteQ(TYPE val)
                {
                        if (this->m_iWriteLast >= this->m_iDataSizeAlloc)
                        {
                                if (!AllocSizeMaxQ(this->m_iDataSizeAlloc + m_nGrowSizeChunk))
                                {
                                        return false;
                                }
                        }
                        ITERATE_t iWrite = this->m_iWriteLast++;
                        m_aData[iWrite] = val;
                        return true;
                }
                HRESULT WriteQty(const TYPE* pVal, ITERATE_t iCount)
                {
                        if (!MakeWritePrepared(iCount))
                        {
                                return HRESULT_WIN32_C(ERROR_DATABASE_FULL);    // full!
                        }
                        ASSERT(this->get_WriteQty() >= iCount);
                        if (pVal != nullptr)
                        {
                                this->WriteQN(pVal, iCount);
                        }
                        return (HRESULT)iCount;
                }
 
                void WriteQ(cQueueRead<BYTE>& queue)
                {
                        WriteQty(queue.get_ReadPtr(), queue.get_ReadQty());
                        queue.EmptyQ();
                }
 
                HRESULT WriteX(const void* pData, size_t nDataSize)
                {
                        HRESULT hRes = this->WriteQty((const TYPE*)pData, (ITERATE_t)(nDataSize / sizeof(TYPE)));
                        if (FAILED(hRes))
                                return hRes;
                        return (HRESULT)nDataSize;      // hRes * sizeof(TYPE)
                }
        };
 
        //*********************************************************************
 
        class GRAYCORE_LINK cQueueBytes : public cQueueDyn < BYTE >
        {
 
                typedef cQueueDyn<BYTE> SUPER_t;
        public:
                explicit cQueueBytes(size_t nGrowSizeChunk = 8 * 1024, size_t nGrowSizeMax = cHeap::k_ALLOC_MAX) noexcept
                        : cQueueDyn<BYTE>((ITERATE_t)nGrowSizeChunk, (ITERATE_t)nGrowSizeMax)
                {
                }
                ~cQueueBytes()
                {
                        // Memory is freed
                }
 
                bool InsertDataHead(const BYTE* pDataSrc, size_t iLen)
                {
                        if (!MakeWritePrepared((ITERATE_t)iLen))
                                return false;
                        cMem::CopyOverlap(m_pData + m_iReadLast + iLen, m_pData + m_iReadLast, get_ReadQty());
                        cMem::Copy(m_pData + m_iReadLast, pDataSrc, iLen);
                        AdvanceWrite((ITERATE_t)iLen);
                        return true;
                }
                bool SetAllData(const BYTE* pData, size_t iLen)
                {
                        if (iLen > (size_t)m_iDataSizeAlloc)    // grow a little?
                        {
                                if (!AllocSizeMaxQ((ITERATE_t)iLen))
                                        return false;
                        }
                        cMem::CopyOverlap(m_pData, pData, iLen);        // may be from the same buffer!? use memmove to be safe.
                        InitQ(0, (ITERATE_t)iLen);
                        return true;
                }
        };
 
        //***********************************************************************
 
        template<class TYPE = BYTE>
        class cQueueChunked
        {
 
        public:
                class cQueueChunk : public cQueueDyn < TYPE >
                {
                public:
                        cQueueChunk* m_pNext;
                public:
                        cQueueChunk(ITERATE_t nGrowSizeChunk)
                                : cQueueDyn<TYPE>(nGrowSizeChunk)
                                , m_pNext(nullptr)
                        {}
                };
 
        private:
                const ITERATE_t m_nGrowSizeChunk;       
                ITERATE_t m_nTotalQty;                  
                cQueueChunk* m_pFirst;
                cQueueChunk* m_pLast;
 
        public:
                cQueueChunked(ITERATE_t nGrowSizeChunk)
                        : m_nGrowSizeChunk(nGrowSizeChunk)
                        , m_nTotalQty(0)
                        , m_pFirst(nullptr)
                        , m_pLast(nullptr)
                {
                }
                ~cQueueChunked()
                {
                        EmptyQ();
                }
 
                bool isEmptyQ() const
                {
                        return(m_nTotalQty == 0);
                }
                void EmptyQ()
                {
                        AdvanceRead(m_nTotalQty);
                        ASSERT(m_nTotalQty == 0);
                        ASSERT(m_pFirst == nullptr);
                        ASSERT(m_pLast == nullptr);
                }
 
                ITERATE_t get_ReadQtyT() const
                {
                        return m_nTotalQty;
                }
                ITERATE_t get_ReadQtyC() const
                {
                        if (m_pFirst == nullptr)
                                return 0;
                        return m_pFirst->get_ReadQty();
                }
                const TYPE* get_ReadPtrC() const
                {
                        ASSERT(!isEmptyQ());
                        ASSERT_N(m_pFirst != nullptr);
                        return m_pFirst->get_ReadPtr();
                }
                void AdvanceRead(ITERATE_t iCount = 1)
                {
                        ITERATE_t iCountLeft = iCount;
                        while (iCountLeft >= 0)
                        {
                                cQueueChunk* pCur = m_pFirst;
                                if (pCur == nullptr)
                                        break;
                                ITERATE_t iSize = pCur->get_ReadQty();
                                if (iCountLeft < iSize)
                                {
                                        pCur->AdvanceRead(iCountLeft);
                                        break;
                                }
                                pCur->AdvanceRead(iSize);
                                m_pFirst = pCur->m_pNext;
                                delete pCur;
                                iCountLeft -= iSize;
                        }
                        m_nTotalQty -= iCount;
                        ASSERT(m_nTotalQty >= 0);
                        if (m_pFirst == nullptr)
                        {
                                m_pLast = nullptr;
                        }
                }
                ITERATE_t get_WriteQty(void) const
                {
                        if (m_pLast == nullptr)
                        {
                                return m_nGrowSizeChunk;
                        }
                        return m_pLast->get_WriteQty();
                }
                TYPE* GetWritePrepared(ITERATE_t iDesiredCount = 1)
                {
                        cQueueChunk* pCur = m_pLast;
                        if (pCur == nullptr)
                        {
                                m_pFirst = m_pLast = new cQueueChunk(m_nGrowSizeChunk);
                        }
                        else if (m_pLast->isFullQ())
                        {
                                pCur->m_pNext = m_pLast = new cQueueChunk(m_nGrowSizeChunk);
                        }
                        return m_pLast->GetWritePrepared(iDesiredCount);
                }
                void AdvanceWrite(ITERATE_t iCount = 1)
                {
                        // iCount of TYPE
                        ASSERT(m_pLast != nullptr);
                        ASSERT(iCount <= get_WriteQty());
                        m_pLast->AdvanceWrite(iCount);
                        m_nTotalQty += iCount;
                }
 
                TYPE Read1(void)
                {
                        ASSERT(m_pFirst != nullptr);
                        const TYPE* pBuf = get_ReadPtrC();
                        TYPE val = *pBuf;
                        AdvanceRead(1);
                        return val;
                }
                ITERATE_t ReadQty(TYPE* pBuf, ITERATE_t nCountMax)
                {
                        ITERATE_t i = 0;
                        for (; !isEmptyQ() && i < nCountMax; i++)
                        {
                                pBuf[i] = Read1();
                        }
                        return i;
                }
                void WriteQ(TYPE val)
                {
                        TYPE* pBuf = GetWritePrepared(1);
                        *pBuf = val;
                        AdvanceWrite(1);
                }
                HRESULT WriteQty(const TYPE* pBuf, ITERATE_t nCount)
                {
                        ITERATE_t i = 0;
                        for (; i < nCount; i++)
                        {
                                WriteQ(pBuf[i]);
                        }
                        return (HRESULT)i;
                }
        };
 
#ifdef GRAY_DLL // force implementation/instantiate for DLL/SO.
        template class GRAYCORE_LINK cQueueRead < BYTE >;
        template class GRAYCORE_LINK cQueueRW < BYTE >;
#endif
 
}       // Gray
#endif // _INC_cQueue_H