cStreamBZ2.h

Go to the documentation of this file.

//
//
#ifndef _INC_cStreamBZ2_H
#define _INC_cStreamBZ2_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "../GrayLibBase.h"
 
#ifdef USE_BZIP2
#include "GrayCore/include/cStreamStack.h"
#include "GrayCore/include/cUnitTestDecl.h"
 
namespace GrayLib
{
        class GRAYLIB_LINK cStreamBZ2Base
        {
 
        protected:
                typedef int ZRET_t;
                void* m_pzstm; 
                // #define m_PZSTM ((bz_stream*)m_pzstm)        // Cast to non opaque structure locally.
 
        private:
                static void* __cdecl bzalloc(void* pThis, int iSize, int iQty);
                static void __cdecl bzfree(void* pThis, void* pData);
 
        protected:
                void InitializeInt();
                void CleanupInt();
 
        public:
                cStreamBZ2Base();
                virtual ~cStreamBZ2Base();
                virtual HRESULT FlushX() = 0;
 
                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(cStreamBZ2Base);
        };
 
        //*************************************************************
 
        class GRAYLIB_LINK cStreamBZ2Compress
                : public cStreamBZ2Base
                , public cStreamStackOut
        {
                typedef cStreamBZ2Base SUPER_t;
 
        protected:
                ZRET_t InitializeInt(int nWorkLevel);
                HRESULT AdvanceCompressInt(int iAction);
                HRESULT CleanupInt();
 
        public:
                cStreamBZ2Compress(size_t nSizeBuffer = 100000 + 100, cStreamOutput* pOut = nullptr)
                        : cStreamStackOut(pOut, nSizeBuffer)
                {
                }
                virtual ~cStreamBZ2Compress()
                {
                        FlushX();
                }
 
                HRESULT Initialize(cStreamOutput* pOut, int nWorkLevel = 1);
                virtual HRESULT FlushX() override;
                virtual HRESULT WriteX(const void* pData, size_t nDataSize) override; // cStreamOutput
        };
 
        class GRAYLIB_LINK cStreamBZ2Decompress
                : public cStreamBZ2Base
                , public cStreamStackInp
        {
                typedef cStreamBZ2Base SUPER_t;
 
        protected:
                ZRET_t InitializeInt(int nWorkLevel);
                HRESULT CleanupInt();
 
        public:
                cStreamBZ2Decompress(size_t nSizeBuffer = 100000 + 100, cStreamInput* pInp = nullptr)
                        : cStreamStackInp(pInp, nSizeBuffer)
                {
                }
                virtual ~cStreamBZ2Decompress()
                {
                        FlushX();
                }
 
                HRESULT Initialize(cStreamInput* pInp, int iSmall = 0);
                virtual HRESULT FlushX() override;
                virtual HRESULT ReadX(void* pData, size_t nDataSize) override;  // cStreamInput override
        };
}
 
#endif  // USE_BZIP2
#endif  // _INC_cStreamBZ2_H