cStreamQueue.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cStreamQueue_H
#define _INC_cStreamQueue_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "cStream.h"
#include "cQueue.h"
#include "HResult.h"
 
namespace Gray
{
        class GRAYCORE_LINK cStreamQueue : public cStream, public cQueueBytes
        {
 
                typedef cQueueBytes SUPER_t;
 
        protected:
                cStreamQueue(const cStreamQueue& a) noexcept
                {
                        UNREFERENCED_REFERENCE(a);
                }
 
        public:
                cStreamQueue(size_t nGrowSizeChunk = 4 * 1024, size_t nGrowSizeMax = cHeap::k_ALLOC_MAX) noexcept
                        : cQueueBytes(nGrowSizeChunk, nGrowSizeMax)
                {
                }
                ~cStreamQueue()
                {
                }
 
                virtual HRESULT WriteX(const void* pData, size_t nDataSize) override
                {
                        return SUPER_t::WriteX(pData, nDataSize);
                }
                virtual HRESULT ReadX(void* pData, size_t nDataSize) override
                {
                        return SUPER_t::ReadX(pData, nDataSize);
                }
                virtual HRESULT ReadPeek(void* pData, size_t nDataSize) override
                {
                        return SUPER_t::ReadPeek((BYTE*)pData, (ITERATE_t)nDataSize);
                }
                virtual size_t SetSeekSizeMin(size_t nSizeMin = k_FILE_BLOCK_SIZE) override
                {
                        ITERATE_t iAutoReadCommit = this->get_AutoReadCommit();
                        this->put_AutoReadCommit((ITERATE_t)nSizeMin);
                        return (size_t)iAutoReadCommit;
                }
                virtual STREAM_SEEKRET_t Seek(STREAM_OFFSET_t offset, SEEK_ORIGIN_TYPE eSeekOrigin = SEEK_Set) override
                {
                        return SUPER_t::SeekQ(offset, eSeekOrigin);
                }
                virtual STREAM_POS_t GetLength() const override
                {
                        return this->get_WriteIndex();  // get_ReadQty()
                }
        };
 
        class GRAYCORE_LINK cStreamStatic : public cStream, public cQueueRW < BYTE >
        {
 
                typedef cQueueRW<BYTE> SUPER_t;
        public:
                explicit cStreamStatic()
                        : cQueueRW<BYTE>(nullptr, 0, 0, 0, 0)
                {
                }
                explicit cStreamStatic(void* pData, size_t iDataMax, size_t iReadLast, size_t iWriteLast, size_t iAutoReadCommit = 0)
                        : cQueueRW<BYTE>((BYTE*)pData, (ITERATE_t)iDataMax, (ITERATE_t)iReadLast, (ITERATE_t)iWriteLast, (ITERATE_t)iAutoReadCommit)
                {
                }
                explicit cStreamStatic(const void* pData, size_t iDataMax)
                        : cQueueRW<BYTE>((const BYTE*)pData, (ITERATE_t)iDataMax)
                {
                }
                explicit cStreamStatic(const cMemBlock& m)
                        : cQueueRW<BYTE>((const BYTE*)m.get_DataBytes(), (ITERATE_t)m.get_DataSize())
                {
                }
                cStreamStatic(const cStreamStatic& a)
                {
                        UNREFERENCED_REFERENCE(a);
                }
                ~cStreamStatic()
                {
                }
 
                virtual size_t SetSeekSizeMin(size_t nSizeMin) override
                {
                        UNREFERENCED_PARAMETER(nSizeMin);
                        return 0;       // Indicate this does nothing.
                }
                virtual STREAM_SEEKRET_t Seek(STREAM_OFFSET_t offset, SEEK_ORIGIN_TYPE eSeekOrigin = SEEK_Set) override
                {
                        return SUPER_t::SeekQ(offset, eSeekOrigin);
                }
                virtual STREAM_POS_t GetLength() const override
                {
                        return SUPER_t::get_WriteIndex();
                }
 
                virtual HRESULT WriteX(const void* pData, size_t nDataSize) override
                {
                        return SUPER_t::WriteX(pData, nDataSize);
                }
                virtual HRESULT ReadX(void* pData, size_t nDataSize) override
                {
                        return SUPER_t::ReadX(pData, nDataSize);
                }
                virtual HRESULT ReadPeek(void* pData, size_t nDataSize) override
                {
                        return SUPER_t::ReadPeek((BYTE*)pData, (ITERATE_t)nDataSize);
                }
        };
 
        class GRAYCORE_LINK cStreamStringA : public cStreamStatic
        {
                typedef cStreamStatic SUPER_t;
        private:
                char m_szVal[StrT::k_LEN_MAX];  
        public:
                cStreamStringA()
                        : cStreamStatic(m_szVal, STRMAX(m_szVal), 0, 0)
                {
                        // Read/Write
                        m_szVal[0] = '\0';
                }
                StrLen_t get_StrLen() const
                {
                        return (StrLen_t)SUPER_t::get_WriteIndex();
                }
                char* ref_StrA()
                {
                        // Terminate string.
                        StrLen_t nLen = get_StrLen();
                        m_szVal[nLen] = '\0';
                        return m_szVal;
                }
                operator char* ()
                {
                        return ref_StrA();
                }
        };
}
 
#endif  // _INC_cStreamQueue_H