home *** CD-ROM | disk | FTP | other *** search
/ Freelog 11 / Freelog011.iso / Bas / Compression / ZLib / contrib / iostream2 / zstream.h < prev   
C/C++ Source or Header  |  1998-01-19  |  10KB  |  308 lines
  1. /*
  2.  *
  3.  * Copyright (c) 1997
  4.  * Christian Michelsen Research AS
  5.  * Advanced Computing
  6.  * Fantoftvegen 38, 5036 BERGEN, Norway
  7.  * http://www.cmr.no
  8.  *
  9.  * Permission to use, copy, modify, distribute and sell this software
  10.  * and its documentation for any purpose is hereby granted without fee,
  11.  * provided that the above copyright notice appear in all copies and
  12.  * that both that copyright notice and this permission notice appear
  13.  * in supporting documentation.  Christian Michelsen Research AS makes no
  14.  * representations about the suitability of this software for any
  15.  * purpose.  It is provided "as is" without express or implied warranty.
  16.  *
  17.  */
  18.  
  19. #ifndef ZSTREAM__H
  20. #define ZSTREAM__H
  21.  
  22. /*
  23.  * zstream.h - C++ interface to the 'zlib' general purpose compression library
  24.  * $Id: zstream.h 1.1 1997-06-25 12:00:56+02 tyge Exp tyge $
  25.  */
  26.  
  27. #include <strstream.h>
  28. #include <string.h>
  29. #include <stdio.h>
  30. #include "zlib.h"
  31.  
  32. #if defined(_WIN32)
  33. #   include <fcntl.h>
  34. #   include <io.h>
  35. #   define SET_BINARY_MODE(file) setmode(fileno(file), O_BINARY)
  36. #else
  37. #   define SET_BINARY_MODE(file)
  38. #endif
  39.  
  40. class zstringlen {
  41. public:
  42.     zstringlen(class izstream&);
  43.     zstringlen(class ozstream&, const char*);
  44.     size_t value() const { return val.word; }
  45. private:
  46.     struct Val { unsigned char byte; size_t word; } val;
  47. };
  48.  
  49. //  ----------------------------- izstream -----------------------------
  50.  
  51. class izstream
  52. {
  53.     public:
  54.         izstream() : m_fp(0) {}
  55.         izstream(FILE* fp) : m_fp(0) { open(fp); }
  56.         izstream(const char* name) : m_fp(0) { open(name); }
  57.         ~izstream() { close(); }
  58.  
  59.         /* Opens a gzip (.gz) file for reading.
  60.          * open() can be used to read a file which is not in gzip format;
  61.          * in this case read() will directly read from the file without
  62.          * decompression. errno can be checked to distinguish two error
  63.          * cases (if errno is zero, the zlib error is Z_MEM_ERROR).
  64.          */
  65.         void open(const char* name) {
  66.             if (m_fp) close();
  67.             m_fp = ::gzopen(name, "rb");
  68.         }
  69.  
  70.         void open(FILE* fp) {
  71.             SET_BINARY_MODE(fp);
  72.             if (m_fp) close();
  73.             m_fp = ::gzdopen(fileno(fp), "rb");
  74.         }
  75.  
  76.         /* Flushes all pending input if necessary, closes the compressed file
  77.          * and deallocates all the (de)compression state. The return value is
  78.          * the zlib error number (see function error() below).
  79.          */
  80.         int close() {
  81.             int r = ::gzclose(m_fp);
  82.             m_fp = 0; return r;
  83.         }
  84.  
  85.         /* Binary read the given number of bytes from the compressed file.
  86.          */
  87.         int read(void* buf, size_t len) {
  88.             return ::gzread(m_fp, buf, len);
  89.         }
  90.  
  91.         /* Returns the error message for the last error which occurred on the
  92.          * given compressed file. errnum is set to zlib error number. If an
  93.          * error occurred in the file system and not in the compression library,
  94.          * errnum is set to Z_ERRNO and the application may consult errno
  95.          * to get the exact error code.
  96.          */
  97.         const char* error(int* errnum) {
  98.             return ::gzerror(m_fp, errnum);
  99.         }
  100.  
  101.         gzFile fp() { return m_fp; }
  102.  
  103.     private:
  104.         gzFile m_fp;
  105. };
  106.  
  107. /*
  108.  * Binary read the given (array of) object(s) from the compressed file.
  109.  * If the input file was not in gzip format, read() copies the objects number
  110.  * of bytes into the buffer.
  111.  * returns the number of uncompressed bytes actually read
  112.  * (0 for end of file, -1 for error).
  113.  */
  114. template <class T, class Items>
  115. inline int read(izstream& zs, T* x, Items items) {
  116.     return ::gzread(zs.fp(), x, items*sizeof(T));
  117. }
  118.  
  119. /*
  120.  * Binary input with the '>' operator.
  121.  */
  122. template <class T>
  123. inline izstream& operator>(izstream& zs, T& x) {
  124.     ::gzread(zs.fp(), &x, sizeof(T));
  125.     return zs;
  126. }
  127.  
  128.  
  129. inline zstringlen::zstringlen(izstream& zs) {
  130.     zs > val.byte;
  131.     if (val.byte == 255) zs > val.word;
  132.     else val.word = val.byte;
  133. }
  134.  
  135. /*
  136.  * Read length of string + the string with the '>' operator.
  137.  */
  138. inline izstream& operator>(izstream& zs, char* x) {
  139.     zstringlen len(zs);
  140.     ::gzread(zs.fp(), x, len.value());
  141.     x[len.value()] = '\0';
  142.     return zs;
  143. }
  144.  
  145. inline char* read_string(izstream& zs) {
  146.     zstringlen len(zs);
  147.     char* x = new char[len.value()+1];
  148.     ::gzread(zs.fp(), x, len.value());
  149.     x[len.value()] = '\0';
  150.     return x;
  151. }
  152.  
  153. // ----------------------------- ozstream -----------------------------
  154.  
  155. class ozstream
  156. {
  157.     public:
  158.         ozstream() : m_fp(0), m_os(0) {
  159.         }
  160.         ozstream(FILE* fp, int level = Z_DEFAULT_COMPRESSION)
  161.             : m_fp(0), m_os(0) {
  162.             open(fp, level);
  163.         }
  164.         ozstream(const char* name, int level = Z_DEFAULT_COMPRESSION)
  165.             : m_fp(0), m_os(0) {
  166.             open(name, level);
  167.         }
  168.         ~ozstream() {
  169.             close();
  170.         }
  171.  
  172.         /* Opens a gzip (.gz) file for writing.
  173.          * The compression level parameter should be in 0..9
  174.          * errno can be checked to distinguish two error cases
  175.          * (if errno is zero, the zlib error is Z_MEM_ERROR).
  176.          */
  177.         void open(const char* name, int level = Z_DEFAULT_COMPRESSION) {
  178.             char mode[4] = "wb\0";
  179.             if (level != Z_DEFAULT_COMPRESSION) mode[2] = '0'+level;
  180.             if (m_fp) close();
  181.             m_fp = ::gzopen(name, mode);
  182.         }
  183.  
  184.         /* open from a FILE pointer.
  185.          */
  186.         void open(FILE* fp, int level = Z_DEFAULT_COMPRESSION) {
  187.             SET_BINARY_MODE(fp);
  188.             char mode[4] = "wb\0";
  189.             if (level != Z_DEFAULT_COMPRESSION) mode[2] = '0'+level;
  190.             if (m_fp) close();
  191.             m_fp = ::gzdopen(fileno(fp), mode);
  192.         }
  193.  
  194.         /* Flushes all pending output if necessary, closes the compressed file
  195.          * and deallocates all the (de)compression state. The return value is
  196.          * the zlib error number (see function error() below).
  197.          */
  198.         int close() {
  199.             if (m_os) {
  200.                 ::gzwrite(m_fp, m_os->str(), m_os->pcount());
  201.                 delete[] m_os->str(); delete m_os; m_os = 0;
  202.             }
  203.             int r = ::gzclose(m_fp); m_fp = 0; return r;
  204.         }
  205.  
  206.         /* Binary write the given number of bytes into the compressed file.
  207.          */
  208.         int write(const void* buf, size_t len) {
  209.             return ::gzwrite(m_fp, (voidp) buf, len);
  210.         }
  211.  
  212.         /* Flushes all pending output into the compressed file. The parameter
  213.          * _flush is as in the deflate() function. The return value is the zlib
  214.          * error number (see function gzerror below). flush() returns Z_OK if
  215.          * the flush_ parameter is Z_FINISH and all output could be flushed.
  216.          * flush() should be called only when strictly necessary because it can
  217.          * degrade compression.
  218.          */
  219.         int flush(int _flush) {
  220.             os_flush();
  221.             return ::gzflush(m_fp, _flush);
  222.         }
  223.  
  224.         /* Returns the error message for the last error which occurred on the
  225.          * given compressed file. errnum is set to zlib error number. If an
  226.          * error occurred in the file system and not in the compression library,
  227.          * errnum is set to Z_ERRNO and the application may consult errno
  228.          * to get the exact error code.
  229.          */
  230.         const char* error(int* errnum) {
  231.             return ::gzerror(m_fp, errnum);
  232.         }
  233.  
  234.         gzFile fp() { return m_fp; }
  235.  
  236.         ostream& os() {
  237.             if (m_os == 0) m_os = new ostrstream;
  238.             return *m_os;
  239.         }
  240.  
  241.         void os_flush() {
  242.             if (m_os && m_os->pcount()>0) {
  243.                 ostrstream* oss = new ostrstream;
  244.                 oss->fill(m_os->fill());
  245.                 oss->flags(m_os->flags());
  246.                 oss->precision(m_os->precision());
  247.                 oss->width(m_os->width());
  248.                 ::gzwrite(m_fp, m_os->str(), m_os->pcount());
  249.                 delete[] m_os->str(); delete m_os; m_os = oss;
  250.             }
  251.         }
  252.  
  253.     private:
  254.         gzFile m_fp;
  255.         ostrstream* m_os;
  256. };
  257.  
  258. /*
  259.  * Binary write the given (array of) object(s) into the compressed file.
  260.  * returns the number of uncompressed bytes actually written
  261.  * (0 in case of error).
  262.  */
  263. template <class T, class Items>
  264. inline int write(ozstream& zs, const T* x, Items items) {
  265.     return ::gzwrite(zs.fp(), (voidp) x, items*sizeof(T));
  266. }
  267.  
  268. /*
  269.  * Binary output with the '<' operator.
  270.  */
  271. template <class T>
  272. inline ozstream& operator<(ozstream& zs, const T& x) {
  273.     ::gzwrite(zs.fp(), (voidp) &x, sizeof(T));
  274.     return zs;
  275. }
  276.  
  277. inline zstringlen::zstringlen(ozstream& zs, const char* x) {
  278.     val.byte = 255;  val.word = ::strlen(x);
  279.     if (val.word < 255) zs < (val.byte = val.word);
  280.     else zs < val;
  281. }
  282.  
  283. /*
  284.  * Write length of string + the string with the '<' operator.
  285.  */
  286. inline ozstream& operator<(ozstream& zs, const char* x) {
  287.     zstringlen len(zs, x);
  288.     ::gzwrite(zs.fp(), (voidp) x, len.value());
  289.     return zs;
  290. }
  291.  
  292. #ifdef _MSC_VER
  293. inline ozstream& operator<(ozstream& zs, char* const& x) {
  294.     return zs < (const char*) x;
  295. }
  296. #endif
  297.  
  298. /*
  299.  * Ascii write with the << operator;
  300.  */
  301. template <class T>
  302. inline ostream& operator<<(ozstream& zs, const T& x) {
  303.     zs.os_flush();
  304.     return zs.os() << x;
  305. }
  306.  
  307. #endif
  308.