cStream.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cStream_H
#define _INC_cStream_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "StrT.h"
#include "cStreamProgress.h"
#include "cTimeSys.h"
#include "cMem.h"
#include "cHeap.h"
#include "HResult.h"
#include "cUnitTestDecl.h"
 
namespace Gray
{
#ifdef _WIN32
#define FILE_EOL        STR_CRLF        
#else
#define FILE_EOL        STR_NL          
#endif
 
        class cStreamInput;
 
        class GRAYCORE_LINK cStreamStat
        {
 
        public:
                STREAM_POS_t m_nCount;          
                cTimeSys m_tLast;               
 
        public:
                cStreamStat() noexcept
                        : m_nCount(0)
                        , m_tLast(cTimeSys::k_CLEAR)
                {
                }
                void ResetStat() noexcept
                {
                        m_nCount = 0;           
                        m_tLast.InitTime();
                }
                void UpdateStat(size_t n) noexcept
                {
                        m_nCount += n;
                        m_tLast.InitTimeNow();
                }
                void Add(const cStreamStat& n) noexcept
                {
                        m_nCount += n.m_nCount;
                        if (n.m_tLast.get_TimeSys() > m_tLast.get_TimeSys())
                        {
                                m_tLast = n.m_tLast;
                        }
                }
        };
 
        class GRAYCORE_LINK cStreamStats
        {
 
        public:
                cStreamStat m_StatOut;
                cStreamStat m_StatInp;
 
        public:
                void Add(const cStreamStats& n)
                {
                        m_StatOut.Add(n.m_StatOut);
                        m_StatInp.Add(n.m_StatInp);
                }
        };
 
        class GRAYCORE_LINK cStreamBase
        {
 
        public:
                static const BYTE k_SIZE_MASK = 0x80;           
                static const size_t k_FILE_BLOCK_SIZE = (32 * 1024);    
 
        public:
                virtual ~cStreamBase()
                {
                }
                virtual STREAM_SEEKRET_t Seek(STREAM_OFFSET_t iOffset, SEEK_ORIGIN_TYPE eSeekOrigin = SEEK_Set)
                {
                        UNREFERENCED_PARAMETER(iOffset);
                        UNREFERENCED_PARAMETER(eSeekOrigin);
                        return (STREAM_SEEKRET_t)E_NOTIMPL;     // It doesn't work on this type of stream!
                }
 
                void SeekToBegin()
                {
                        Seek(0, SEEK_Set);
                }
                STREAM_POS_t SeekToEnd()
                {
                        return((STREAM_POS_t)Seek(0, SEEK_End));
                }
 
                virtual STREAM_POS_t GetPosition() const;
                virtual STREAM_POS_t GetLength() const;
        };
 
        class GRAYCORE_LINK cStreamOutput : public cStreamBase
        {
 
        public:
                cStreamOutput() noexcept
                {
                }
                virtual ~cStreamOutput()
                {
                }
 
                virtual HRESULT WriteX(const void* pData, size_t nDataSize) // = 0;
                {
                        ASSERT(0);      // should never get called. (should always be overloaded)
                        UNREFERENCED_PARAMETER(pData);
                        UNREFERENCED_PARAMETER(nDataSize);
                        return HRESULT_WIN32_C(ERROR_WRITE_FAULT);
                }
 
                HRESULT WriteT(const void* pVal, size_t nDataSize)
                {
                        HRESULT hRes = WriteX(pVal, nDataSize);
                        if (SUCCEEDED(hRes) && hRes != (HRESULT)nDataSize)
                                return HRESULT_WIN32_C(ERROR_WRITE_FAULT); // STG_WRITEFAULT
                        return hRes;
                }
 
                // Support the base types directly.
                template< typename TYPE >
                HRESULT WriteT(TYPE val);
 
                HRESULT WriteSize(size_t nSize);
                HRESULT WriteHashCode(HASHCODE_t nHashCode)
                {
                        return WriteSize(nHashCode);
                }
 
                HRESULT WriteN(const void* pBuffer, size_t nSize)
                {
                        HRESULT hRes = WriteSize(nSize);
                        if (FAILED(hRes))
                                return hRes;
                        if (nSize == 0)
                                return S_OK;
                        return WriteT(pBuffer, nSize);
                }
 
                template< typename _CH >
                HRESULT WriteStringN(const _CH* pszStr)
                {
                        return WriteN(pszStr, (pszStr == nullptr) ? 0 : (StrT::Len(pszStr) * sizeof(_CH)));
                }
                template< typename _CH >
                HRESULT WriteCharRepeat(_CH nChar, int nCount = 1)
                {
                        ASSERT(nCount >= 0);
                        _CH szTmp[2];
                        szTmp[0] = nChar;
                        szTmp[1] = '\0';
                        for (; nCount-- > 0;)
                        {
                                HRESULT hRes = WriteString(szTmp);
                                if (FAILED(hRes))
                                        return hRes;
                        }
                        return S_OK;
                }
 
                virtual HRESULT WriteString(const char* pszStr)
                {
                        if (pszStr == nullptr)
                                return 0;       // write nothing = S_OK.
                        StrLen_t iLen = StrT::Len(pszStr);
                        return WriteT(pszStr, iLen * sizeof(char));
                }
                virtual HRESULT WriteString(const wchar_t* pszStr)
                {
                        if (pszStr == nullptr)
                                return 0;       // write nothing = S_OK.
                        StrLen_t iLen = StrT::Len(pszStr);
                        HRESULT hRes = WriteT(pszStr, iLen * sizeof(wchar_t));
                        if (FAILED(hRes))
                                return hRes;
                        return(hRes / sizeof(wchar_t));
                }
 
                StrLen_t VPrintf(const char* pszFormat, va_list args)
                {
                        ASSERT(pszFormat != nullptr);
                        char szTemp[StrT::k_LEN_MAX];
                        StrLen_t iLenRet = StrT::vsprintfN(szTemp, STRMAX(szTemp), pszFormat, args);
                        UNREFERENCED_PARAMETER(iLenRet);
                        return WriteString(szTemp);
                }
                StrLen_t VPrintf(const wchar_t* pszFormat, va_list args)
                {
                        ASSERT(pszFormat != nullptr);
                        wchar_t szTemp[StrT::k_LEN_MAX];
                        StrLen_t iLenRet = StrT::vsprintfN(szTemp, STRMAX(szTemp), pszFormat, args);
                        UNREFERENCED_PARAMETER(iLenRet);
                        return WriteString(szTemp);
                }
                StrLen_t _cdecl Printf(const char* pszFormat, ...)
                {
                        ASSERT(pszFormat != nullptr);
                        va_list vargs;
                        va_start(vargs, pszFormat);
                        StrLen_t iLenRet = VPrintf(pszFormat, vargs);
                        va_end(vargs);
                        return iLenRet;
                }
                StrLen_t _cdecl Printf(const wchar_t* pszFormat, ...)
                {
                        ASSERT(pszFormat != nullptr);
                        va_list vargs;
                        va_start(vargs, pszFormat);
                        StrLen_t iLenRet = VPrintf(pszFormat, vargs);
                        va_end(vargs);
                        return iLenRet;
                }
 
                HRESULT WriteStream(cStreamInput& sInp, STREAM_POS_t nSizeMax = k_FILE_BLOCK_SIZE, IStreamProgressCallback* pProgress = nullptr, TIMESYSD_t nTimeout = 0);
 
                virtual HRESULT FlushX()
                {
                        return S_OK;
                }
        };
 
        // Write all my types bool, char, int, float, double, _int64. (short, long, signed, unsigned)
#define CTYPE_DEF(a,_TYPE,c,d,e,f,g,h) template<> inline HRESULT cStreamOutput::WriteT<_TYPE>( _TYPE val ) { return WriteT(&val,sizeof(val)); }
#include "cTypes.tbl"
#undef CTYPE_DEF
 
        class GRAYCORE_LINK cStreamInput : public cStreamBase
        {
        public:
                cStreamInput() noexcept
                {
                }
                virtual ~cStreamInput()
                {
                }
 
                virtual size_t SetSeekSizeMin(size_t nSizeMin = k_FILE_BLOCK_SIZE)
                {
 
                        UNREFERENCED_PARAMETER(nSizeMin);
                        ASSERT(false);  // Must implement this ?
                        return 0;       // Previous commit size.
                }
 
                virtual HRESULT ReadX(OUT void* pData, size_t nDataSize)
                {
                        UNREFERENCED_PARAMETER(pData);
                        UNREFERENCED_PARAMETER(nDataSize);
                        return 0;
                }
 
                HRESULT ReadAll(OUT cHeapBlock& block, size_t nSizeExtra = 0)
                {
                        STREAM_POS_t nLengthStream = this->GetLength();
                        size_t nLengthAlloc = (size_t)nLengthStream;
                        if (!block.Alloc(nLengthAlloc + nSizeExtra))
                                return E_OUTOFMEMORY;
                        return ReadT(block.get_Data(), nLengthAlloc);   // must get all.
                }
 
                virtual HRESULT ReadStringLine(OUT char* pszBuffer, StrLen_t iSizeMax);
                virtual HRESULT ReadStringLine(OUT wchar_t* pszBuffer, StrLen_t iSizeMax);
 
                // Support the base types directly.
                HRESULT ReadT(OUT void* pVal, size_t nSize)
                {
 
                        HRESULT hRes = ReadX(pVal, nSize);
                        if (SUCCEEDED(hRes) && hRes != (HRESULT)nSize)
                        {
                                return HRESULT_WIN32_C(ERROR_IO_INCOMPLETE);    // maybe HRESULT_WIN32_C(ERROR_HANDLE_EOF) ?
                        }
                        return hRes;
                }
                template< typename TYPE >
                HRESULT ReadT(OUT TYPE& val);
 
                template< typename TYPE >
                HRESULT ReadTN(OUT TYPE& val)
                {
                        HRESULT hRes = ReadT(val);
                        if (FAILED(hRes))
                                return hRes;
                        val = cMemT::NtoH(val);
                        return hRes;
                }
 
                HRESULT ReadSize(OUT size_t& nSize);
 
                template< typename TYPE >
                HRESULT ReadSizeT(OUT TYPE& n)
                {
                        // cast size_t to some other type.
                        size_t nSize = 0;
                        HRESULT hRes = ReadSize(nSize);
                        n = (TYPE)nSize;
                        return hRes;
                }
 
                HRESULT ReadHashCode(OUT UINT32& nHashCode)
                {
                        return ReadSizeT<UINT32>(nHashCode);
                }
#ifdef USE_INT64
                HRESULT ReadHashCode(OUT UINT64& nHashCode)
                {
                        return ReadSizeT<UINT64>(nHashCode);
                }
#endif
                HRESULT ReadN(OUT BYTE* pBuffer, size_t nSizeMax)
                {
                        size_t nSize;
                        HRESULT hRes = ReadSize(nSize);
                        if (FAILED(hRes))
                                return hRes;
                        if (nSize > nSizeMax)
                        {
                                // ASSERT(0);
                                return HRESULT_WIN32_C(ERROR_FILE_CORRUPT);     // corrupt data.
                        }
                        return ReadT(pBuffer, nSize);
                }
 
                template< typename _CH >
                HRESULT ReadStringN(OUT _CH* pszStr, StrLen_t iSizeMax)
                {
 
                        HRESULT hResRead = ReadN((BYTE*)pszStr, (size_t)(iSizeMax - 1) * sizeof(_CH));
                        if (FAILED(hResRead))
                                return hResRead;
                        StrLen_t nSizeRead = hResRead / sizeof(_CH);
                        ASSERT(nSizeRead < iSizeMax);
                        pszStr[nSizeRead] = '\0';
                        return nSizeRead + 1;
                }
 
                virtual HRESULT ReadPeek(void* pData, size_t nDataSize);
        };
 
        // Read all my types bool, char, int, float, double, _int64. (short, long, signed, unsigned)
#define CTYPE_DEF(a,_TYPE,c,d,e,f,g,h) template<> inline HRESULT cStreamInput::ReadT<_TYPE>( OUT _TYPE& rval ) { return ReadT(&rval,sizeof(rval)); }
#include "cTypes.tbl"
#undef CTYPE_DEF
 
        class GRAYCORE_LINK cStream
                : public cStreamInput
                , public cStreamOutput
        {
 
        public:
                virtual STREAM_SEEKRET_t Seek(STREAM_OFFSET_t iOffset, SEEK_ORIGIN_TYPE eSeekOrigin = SEEK_Set) override
                {
                        return cStreamInput::Seek(iOffset, eSeekOrigin);
                }
                virtual STREAM_POS_t GetPosition() const override
                {
                        return cStreamInput::GetPosition();
                }
                virtual STREAM_POS_t GetLength() const override
                {
                        return cStreamInput::GetLength();
                }
                void SeekToBegin()
                {
                        cStreamInput::SeekToBegin();
                }
                STREAM_POS_t SeekToEnd()
                {
                        return cStreamInput::SeekToEnd();
                }
 
                UNITTEST_FRIEND(cStream);
        };
 
        class GRAYCORE_LINK cStreamTransaction
        {
 
        public:
                cStreamInput* m_pInp;           
                STREAM_SEEKRET_t m_lPosStart;
                size_t m_nSeekSizeMinPrev;      
 
        protected:
                HRESULT TransactionRollback()
                {
                        // Roll back to m_lPosStart
                        ASSERT(isTransactionActive());
                        STREAM_SEEKRET_t lPosRet = m_pInp->Seek(m_lPosStart, SEEK_Set);
                        if (lPosRet == m_lPosStart)
                                return S_OK;
                        ASSERT(lPosRet == m_lPosStart);
                        return HResult::GetDef((HRESULT)lPosRet, HRESULT_WIN32_C(ERROR_READ_FAULT));
                }
 
        public:
                cStreamTransaction(cStreamInput* pInp)
                        : m_pInp(pInp)
                {
                        ASSERT(m_pInp != nullptr);
                        m_lPosStart = m_pInp->GetPosition();
                        ASSERT(m_lPosStart >= 0 && m_lPosStart <= (STREAM_SEEKRET_t)cHeap::k_ALLOC_MAX);
                        m_nSeekSizeMinPrev = m_pInp->SetSeekSizeMin(0); // Don't use AutoReadCommit inside cStreamTransaction.
                        ASSERT(m_nSeekSizeMinPrev >= 0 && m_nSeekSizeMinPrev <= cHeap::k_ALLOC_MAX);
                        ASSERT(isTransactionActive());
                }
                ~cStreamTransaction()
                {
                        if (m_pInp == nullptr)
                                return;
                        if (isTransactionActive())      // We failed ! didn't call SetTransactionComplete or SetTransactionFailed()
                        {
                                TransactionRollback();
                        }
                        // Restore commit ability
                        m_pInp->SetSeekSizeMin(m_nSeekSizeMinPrev);     // Complete. we can now commit reads. e.g. toss data we have declared read.
                }
 
                bool isTransactionActive() const
                {
                        return m_lPosStart != ((STREAM_SEEKRET_t)-1);
                }
                void SetTransactionComplete()
                {
                        ASSERT(isTransactionActive());
                        m_lPosStart = ((STREAM_SEEKRET_t)-1);
                        ASSERT(!isTransactionActive());
                }
                void SetTransactionCompleteN(size_t nSize)
                {
                        // I got a partial success. I used some of the data. maybe not all.
                        ASSERT(isTransactionActive());
                        m_lPosStart += nSize;   // roll back to here.
                }
                void SetTransactionFailed()
                {
                        if (m_pInp == nullptr)
                                return;
                        m_pInp = nullptr;
                }
                void SetTransactionRollback()
                {
                        ASSERT(isTransactionActive());
                }
        };
 
        class GRAYCORE_LINK cStreamNull : public cStream
        {
 
        public:
                virtual HRESULT WriteX(const void* pData, size_t nDataSize) override // = 0;
                {
                        UNREFERENCED_PARAMETER(pData);
                        return (HRESULT)nDataSize;
                }
        };
};
 
#endif // _INC_cStream_H