cStreamZLib.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cStreamZLib_H
#define _INC_cStreamZLib_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "../GrayLibBase.h"
 
#ifdef USE_ZLIB
#include "GrayCore/include/cStreamStack.h"
#include "GrayCore/include/cUnitTestDecl.h"
 
struct z_stream_s;      // zlib internal/opaque structure in global namespace.
 
namespace GrayLib
{
        enum ZIP_COMPLEV_TYPE
        {
                ZIP_COMPLEV_DirStub = -2,       
                ZIP_COMPLEV_Def = -1,           
                ZIP_COMPLEV_None = 0,           
                ZIP_COMPLEV_Fast = 1,           
                ZIP_COMPLEV_2 = 2,
                ZIP_COMPLEV_6 = 6,
                ZIP_COMPLEV_8 = 8,
                ZIP_COMPLEV_Slow = 9,           
                ZIP_COMPLEV_QTY
        };
 
        class GRAYLIB_LINK cStreamZLibBase
        {
 
        public:
                typedef int ZRET_t;
        public:
                struct z_stream_s* m_pzstm; 
 
        protected:
                void InitializeInt();
                void CleanupInt();
 
        public:
                cStreamZLibBase();
                virtual ~cStreamZLibBase();
 
                virtual HRESULT FlushX() = 0;
                int get_DataTypeCode() const;   
 
                static HRESULT GRAYCALL GetHResultFrom(ZRET_t izRet);
                static HRESULT GRAYCALL Compress1(BYTE* pDest, size_t nDestSizeMax, const void* pSrc, size_t nSrcSize);
                static HRESULT GRAYCALL Decompress1(void* pDest, size_t nDestSizeMax, const BYTE* pSrc, size_t nSrcSize);
 
                UNITTEST_FRIEND(cStreamZLib);
        };
 
        //*************************************************************
 
        class GRAYLIB_LINK cStreamZLibCompress
                : public cStreamZLibBase
                , public cStreamStackOut
        {
 
                typedef cStreamZLibBase SUPER_t;
 
        protected:
                ZRET_t InitializeInt(ZIP_COMPLEV_TYPE nCompLevel = ZIP_COMPLEV_Slow);
                HRESULT AdvanceCompressInt(int action);
                HRESULT CleanupInt();
 
        public:
                cStreamZLibCompress(size_t nSizeMax = cStream::k_FILE_BLOCK_SIZE, cStreamOutput* pStreamOut = nullptr)
                        : cStreamStackOut(pStreamOut, nSizeMax)
                {
                }
                virtual ~cStreamZLibCompress()
                {
                        FlushX();
                }
 
                HRESULT Initialize(cStreamOutput* pOut, ZIP_COMPLEV_TYPE nCompLevel = ZIP_COMPLEV_Slow);
                virtual HRESULT FlushX() override;
                virtual HRESULT WriteX(const void* pData, size_t nDataSize) override; // cStreamOutput
        };
 
        class GRAYLIB_LINK cStreamZLibDecompress
                : public cStreamZLibBase
                , public cStreamStackInp
        {
                typedef cStreamZLibBase SUPER_t;
 
        protected:
                ZRET_t InitializeInt(bool bWeb);
                HRESULT CleanupInt();
 
        public:
                cStreamZLibDecompress(size_t nSizeMax = cStream::k_FILE_BLOCK_SIZE, cStreamInput* pInp = nullptr)
                        : cStreamStackInp(pInp, nSizeMax)
                {
                }
                virtual ~cStreamZLibDecompress()
                {
                        FlushX();
                }
 
                HRESULT Initialize(cStreamInput* pInp, bool bWeb);
                virtual HRESULT FlushX() override;
                virtual HRESULT ReadX(void* pData, size_t nDataSize) override;  // cStreamInput override
        };
};
 
#endif // USE_ZLIB
#endif //_INC_cStreamZLib_H