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*);
value()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:
izstream()54         izstream() : m_fp(0) {}
izstream(FILE * fp)55         izstream(FILE* fp) : m_fp(0) { open(fp); }
izstream(const char * name)56         izstream(const char* name) : m_fp(0) { open(name); }
~izstream()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          */
open(const char * name)65         void open(const char* name) {
66             if (m_fp) close();
67             m_fp = ::gzopen(name, "rb");
68         }
69 
open(FILE * fp)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          */
close()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          */
read(void * buf,size_t len)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          */
error(int * errnum)97         const char* error(int* errnum) {
98             return ::gzerror(m_fp, errnum);
99         }
100 
fp()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>
read(izstream & zs,T * x,Items 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 
zstringlen(izstream & zs)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 
read_string(izstream & zs)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:
ozstream()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         }
~ozstream()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          */
close()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          */
write(const void * buf,size_t len)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          */
flush(int _flush)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          */
error(int * errnum)230         const char* error(int* errnum) {
231             return ::gzerror(m_fp, errnum);
232         }
233 
fp()234         gzFile fp() { return m_fp; }
235 
os()236         ostream& os() {
237             if (m_os == 0) m_os = new ostrstream;
238             return *m_os;
239         }
240 
os_flush()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>
write(ozstream & zs,const T * x,Items 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 
zstringlen(ozstream & zs,const char * x)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