p6gzip.h

Go to the documentation of this file.

#ifndef P6GZIP_H__
#define P6GZIP_H__ 1

#include "p6datastream.h"
#include "p6iohandler.h"

#ifdef __cplusplus
namespace P6R {
extern "C" {
#endif

   typedef P6UINT32 P6GZSTREAMFLAGS;
   static const P6GZSTREAMFLAGS     P6GZSTREAM_NOFLAGS      = 0x00000000;
   static const P6GZSTREAMFLAGS     P6GZSTREAM_COMPRESSMASK = 0x000f0000;  
   static const P6GZSTREAMFLAGS     P6GZSTREAM_COMPRESS     = 0x00000000;  
   static const P6GZSTREAMFLAGS     P6GZSTREAM_DECOMPRESS   = 0x00010000;  
   #define P6GZCOMPRESSTYPE(f)      ((f) & P6GZSTREAM_COMPRESSMASK)
   #define P6GZCOMPRESSING(f)       (P6GZSTREAM_COMPRESS    == P6GZCOMPRESSTYPE((f)) ? P6TRUE : P6FALSE)
   #define P6GZDECOMPRESSING(f)     (P6GZSTREAM_DECOMPRESS  == P6GZCOMPRESSTYPE((f)) ? P6TRUE : P6FALSE)

   static const P6GZSTREAMFLAGS     P6GZSTREAM_WRAPPERMASK  = 0x0000000f;
   static const P6GZSTREAMFLAGS     P6GZSTREAM_WRAPNONE     = 0x00000000;  
   static const P6GZSTREAMFLAGS     P6GZSTREAM_WRAPZLIB     = 0x00000001;  
   static const P6GZSTREAMFLAGS     P6GZSTREAM_WRAPGZIP     = 0x00000002;  
   #define P6GZWRAPPERTYPE(f)       ((f) & P6GZSTREAM_WRAPPERMASK)
   #define P6GZ_WRAPISGZIP(f)       (P6GZWRAPPERTYPE((f)) == P6GZSTREAM_WRAPGZIP ? P6TRUE : P6FALSE)
   #define P6GZ_WRAPISZLIB(f)       (P6GZWRAPPERTYPE((f)) == P6GZSTREAM_WRAPZLIB ? P6TRUE : P6FALSE)
   #define P6GZ_WRAPISNONE(f)       (P6GZWRAPPERTYPE((f)) == P6GZSTREAM_WRAPNONE ? P6TRUE : P6FALSE)

   static const P6GZSTREAMFLAGS     P6GZSTREAM_STRATEGYMASK = 0x000000f0;
   static const P6GZSTREAMFLAGS     P6GZSTREAM_STRATDEF     = 0x00000000;  
   static const P6GZSTREAMFLAGS     P6GZSTREAM_STRATFILTERED= 0x00000010;  
   static const P6GZSTREAMFLAGS     P6GZSTREAM_STRATHUFFMAN = 0x00000020;  
   static const P6GZSTREAMFLAGS     P6GZSTREAM_STRATRLE     = 0x00000040;  
   static const P6GZSTREAMFLAGS     P6GZSTREAM_STRATFIXED   = 0x00000080;  
   #define P6GZSTRATEGYTYPE(f)      ((f) & P6GZSTREAM_STRATEGYMASK)

   static const P6GZSTREAMFLAGS     P6GZSTREAM_FLUSHMASK    = 0x0000ff00;  
   static const P6GZSTREAMFLAGS     P6GZSTREAM_FLUSHDEFAULT = 0x00000000;  
   static const P6GZSTREAMFLAGS     P6GZSTREAM_FLUSHNONE    = 0x00000100;  
   static const P6GZSTREAMFLAGS     P6GZSTREAM_FLUSHPARTIAL = 0x00000200;  
   static const P6GZSTREAMFLAGS     P6GZSTREAM_FLUSHSYNC    = 0x00000400;  
   static const P6GZSTREAMFLAGS     P6GZSTREAM_FLUSHFULL    = 0x00000800;  
   static const P6GZSTREAMFLAGS     P6GZSTREAM_FLUSHFINISH  = 0x00001000;  
   static const P6GZSTREAMFLAGS     P6GZSTREAM_FLUSHBLOCK   = 0x00002000;  
   static const P6GZSTREAMFLAGS     P6GZSTREAM_FLUSHTREES   = 0x00004000;  
   #define P6GZFLUSHTYPE(f)         ((f) & P6GZSTREAM_FLUSHMASK)

   typedef P6INT32 P6GZCOMPRESSLEVEL;
   static const P6GZCOMPRESSLEVEL   P6GZCL_MIN              P6PURE;
   static const P6GZCOMPRESSLEVEL   P6GZCL_MAX              = 9;
   static const P6GZCOMPRESSLEVEL   P6GZCL_DEFAULT          = 6;


   #undef INTERFACE
   #define INTERFACE p6IZlibSSH
   P6DECLAREIF_(p6IZlibSSH,p6ICom)
   {
      P6DECLAREICOM
      P6DECLCOMMETHOD(initialize)(P6THIS_ P6GZSTREAMFLAGS fFlags,P6UINT32 nLevel) P6PURE;

      P6DECLCOMMETHOD(process)(P6THIS_ const P6VOID *pInputData,
                               P6SIZE cbInputData,
                               P6VOID *pOutputData,
                               P6SIZE cbOutputData,
                               P6SIZE *pcbOutput,
                               P6BOOL bLast) P6PURE;

      P6DECLCOMMETHOD(close)(P6THIS) P6PURE;
   };

   // {2AD59EEB-F169-4472-B235-968244ADE914}
   #define IF_p6IZlibSSH   {0x2AD59EEB,0xF169,0x4472,{0xB2,0x35,0x96,0x82,0x44,0xAD,0xE9,0x14}}

   // {C20335D0-7C72-467F-BDE9-C0825F07FD47}
   #define COMP_p6ZlibSSH  {0xC20335D0,0x7C72,0x467F,{0xBD,0xE9,0xC0,0x82,0x5F,0x07,0xFD,0x47}}



   typedef P6UINT32 P6GZIOFLAGS;
   static const P6GZIOFLAGS   P6GZIOF_NOFLAGS   = 0x00000000;  
   static const P6GZIOFLAGS   P6GZIOF_NOHEADER  = 0x00000001;  
   #undef INTERFACE
   #define INTERFACE p6IGzipInflateToStream
   P6DECLAREIF_(p6IGzipInflateToStream,p6ICom)
   {
      P6DECLAREICOM
      P6DECLCOMMETHOD(initialize)(P6THIS_ p6IDataStream *pOutStream,P6GZIOFLAGS fFlags) P6PURE;

      P6DECLCOMMETHOD(process)(P6THIS_ P6VOID *pSource,P6SIZE cbSource) P6PURE;

      P6DECLCOMMETHOD(end)(P6THIS) P6PURE;
   };

   /*{D23B9240-4923-34C9-B3FE-C4B18263FCE5}*/
   #define IF_p6IGzipInflateToStream {0xD23B9240,0x4923,0x34C9,{0xB3,0xFE,0xC4,0xB1,0x82,0x63,0xFC,0xE5}}

   /*{187AA4D2-475C-3167-32AD-A48361B3F818}*/
   #define COMP_p6GzipInflateToStream {0x187AA4D2,0x475C,0x3167,{0x32,0xAD,0xA4,0x83,0x61,0xB3,0xF8,0x18}}


   #undef INTERFACE
   #define INTERFACE p6IGzipDeflateToStream
   P6DECLAREIF_(p6IGzipDeflateToStream,p6ICom)
   {
      P6DECLAREICOM
      P6DECLCOMMETHOD(initialize)(P6THIS_ p6IDataStream *pOutStream,P6GZIOFLAGS fFlags) P6PURE;

      P6DECLCOMMETHOD(process)(P6THIS_ P6VOID *pBuffer,P6SIZE cbBuffer) P6PURE;

      P6DECLCOMMETHOD(end)(P6THIS) P6PURE;
   };

   /*{E0408340-4DE1-3292-611B-1CB2F30DB592}*/
   #define IF_p6IGzipDeflateToStream  {0xE0408340,0x4DE1,0x3292,{0x61,0x1B,0x1C,0xB2,0xF3,0x0D,0xB5,0x92}}

   /*{19B5F73C-100A-4514-8E66-266AAC9CBFA0}*/
   #define COMP_p6GzipDeflateToStream {0x19B5F73C,0x100A,0x4514,{0x8E,0x66,0x26,0x6A,0xAC,0x9C,0xBF,0xA0}}


   #undef INTERFACE
   #define INTERFACE p6IGzipInflateFromHandler
   P6DECLAREIF_(p6IGzipInflateFromHandler,p6ICom)
   {
      P6DECLAREICOM
      P6DECLCOMMETHOD(initialize)(P6THIS_ p6IIoReadHandler *pIo,P6GZIOFLAGS fFlags) P6PURE;

      P6DECLCOMMETHOD(read)(P6THIS_ P6VOID *pBuffer,P6SIZE cbBuffer,P6SIZE *pcbRead) P6PURE;

      P6DECLCOMMETHOD(end)(P6THIS) P6PURE;
   };

   /*{566626EB-44F9-A909-6C18-CAB536293EC1}*/
   #define IF_p6IGzipInflateFromHandler   {0x566626EB,0x44F9,0xA909,{0x6C,0x18,0xCA,0xB5,0x36,0x29,0x3E,0xC1}}

   /*{0BD83415-4965-1E5F-D65E-DF8416EAC298}*/
   #define COMP_p6GzipInflateFromHandler  {0x0BD83415,0x4965,0x1E5F,{0xD6,0x5E,0xDF,0x84,0x16,0xEA,0xC2,0x98}}


   #undef INTERFACE
   #define INTERFACE p6IGzipDeflateToHandler
   P6DECLAREIF_(p6IGzipDeflateToHandler,p6ICom)
   {
      P6DECLAREICOM
      P6DECLCOMMETHOD(initialize)(P6THIS_ p6IIoWriteHandler *pIo,P6GZIOFLAGS fFlags) P6PURE;

      P6DECLCOMMETHOD(write)(P6THIS_ P6VOID *pBuffer,P6SIZE cbBuffer) P6PURE;

      P6DECLCOMMETHOD(end)(P6THIS) P6PURE;
   };

   /*{D8F57EA1-FC0D-4EF3-99C8-B076289F907E}*/
   #define IF_p6IGzipDeflateToHandler    {0xD8F57EA1,0xFC0D,0x4EF3,{0x99,0xC8,0xB0,0x76,0x28,0x9F,0x90,0x7E}}

   /*{33A7D609-14AB-4522-B97E-435419C8E9DC}*/
   #define COMP_p6GzipDeflateToHandler   {0x33A7D609,0x14AB,0x4522,{0xB9,0x7E,0x43,0x54,0x19,0xC8,0xE9,0xDC}}


   #undef INTERFACE
   #define INTERFACE p6IGzipInflateBuffer
   P6DECLAREIF_(p6IGzipInflateBuffer,p6ICom)
   {
      P6DECLAREICOM
      P6DECLCOMMETHOD(initialize)(P6THIS_ P6VOID *pBuffer,P6SIZE cbBuffer,P6GZIOFLAGS fFlags) P6PURE;

      P6DECLCOMMETHOD(inflate)(P6THIS_ P6VOID *pBuffer,P6SIZE cbBuffer,P6SIZE *pcbInflated) P6PURE;
   };

   /*{F94DA9AB-CBD6-4E05-847E-37D8E78A8508}*/
   #define IF_p6IGzipInflateBuffer {0xF94DA9AB,0xCBD6,0x4E05,{0x84,0x7E,0x37,0xD8,0xE7,0x8A,0x85,0x08}}

   /*{C125EDDE-F846-47D7-8E62-709F54B0205D}*/
   #define COMP_p6GzipInflateBuffer {0xC125EDDE,0xF846,0x47D7,{0x8E,0x62,0x70,0x9F,0x54,0xB0,0x20,0x5D}}


   #undef INTERFACE
   #define INTERFACE p6IGzipDeflateBuffer
   P6DECLAREIF_(p6IGzipDeflateBuffer,p6ICom)
   {
      P6DECLAREICOM
      P6DECLCOMMETHOD(initialize)(P6THIS_ P6VOID *pBuffer,P6SIZE cbBuffer,P6INT nLevel,P6GZIOFLAGS fFlags) P6PURE;

      P6DECLCOMMETHOD(deflate)(P6THIS_ P6VOID *pBuffer,P6SIZE cbBuffer,P6SIZE *pcbDeflated) P6PURE;
   };

   /*{6A947420-833E-4EF5-9D7B-3E80F0F3C631}*/
   #define IF_p6IGzipDeflateBuffer     {0x6A947420,0x833E,0x4EF5,{0x9D,0x7B,0x3E,0x80,0xF0,0xF3,0xC6,0x31}}

   /*{94A8B513-5AD4-4917-A8E5-06CC6A32BC4D}*/
   #define COMP_p6GzipDeflateBuffer   {0x94A8B513,0x5AD4,0x4917,{0xA8,0xE5,0x06,0xCC,0x6A,0x32,0xBC,0x4D}}

#ifdef __cplusplus
} /* extern "C" */
} //namespace
#endif

#endif