workbench/libs/z/contrib/iostream2/zstream.h

   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$
  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