contrib/iostream2/zstream.h

/*
 *
 * Copyright (c) 1997
 * Christian Michelsen Research AS
 * Advanced Computing
 * Fantoftvegen 38, 5036 BERGEN, Norway
 * http://www.cmr.no
 *
 * Permission to use, copy, modify, distribute and sell this software
 * and its documentation for any purpose is hereby granted without fee,
 * provided that the above copyright notice appear in all copies and
 * that both that copyright notice and this permission notice appear
 * in supporting documentation.  Christian Michelsen Research AS makes no
 * representations about the suitability of this software for any
 * purpose.  It is provided "as is" without express or implied warranty.
 *
 */

#ifndef ZSTREAM__H
#define ZSTREAM__H

/*
 * zstream.h - C++ interface to the 'zlib' general purpose compression library
 * $Id: zstream.h 1.1 1997-06-25 12:00:56+02 tyge Exp tyge $
 */

#include <strstream.h>
#include <string.h>
#include <stdio.h>
#include "zlib.h"

#if defined(_WIN32)
#   include <fcntl.h>
#   include <io.h>
#   define SET_BINARY_MODE(file) setmode(fileno(file), O_BINARY)
#else
#   define SET_BINARY_MODE(file)
#endif

class zstringlen {
public:
    zstringlen(class izstream&);
    zstringlen(class ozstream&, const char*);
    size_t value() const { return val.word; }
private:
    struct Val { unsigned char byte; size_t word; } val;
};

//  ----------------------------- izstream -----------------------------

class izstream
{
    public:
        izstream() : m_fp(0) {}
        izstream(FILE* fp) : m_fp(0) { open(fp); }
        izstream(const char* name) : m_fp(0) { open(name); }
        ~izstream() { close(); }

        /* Opens a gzip (.gz) file for reading.
         * open() can be used to read a file which is not in gzip format;
         * in this case read() will directly read from the file without
         * decompression. errno can be checked to distinguish two error
         * cases (if errno is zero, the zlib error is Z_MEM_ERROR).
         */
        void open(const char* name) {
            if (m_fp) close();
            m_fp = ::gzopen(name, "rb");
        }

        void open(FILE* fp) {
            SET_BINARY_MODE(fp);
            if (m_fp) close();
            m_fp = ::gzdopen(fileno(fp), "rb");
        }

        /* Flushes all pending input if necessary, closes the compressed file
         * and deallocates all the (de)compression state. The return value is
         * the zlib error number (see function error() below).
         */
        int close() {
            int r = ::gzclose(m_fp);
            m_fp = 0; return r;
        }

        /* Binary read the given number of bytes from the compressed file.
         */
        int read(void* buf, size_t len) {
            return ::gzread(m_fp, buf, len);
        }

        /* Returns the error message for the last error which occurred on the
         * given compressed file. errnum is set to zlib error number. If an
         * error occurred in the file system and not in the compression library,
         * errnum is set to Z_ERRNO and the application may consult errno
         * to get the exact error code.
         */
        const char* error(int* errnum) {
            return ::gzerror(m_fp, errnum);
        }

        gzFile fp() { return m_fp; }

    private:
        gzFile m_fp;
};

/*
 * Binary read the given (array of) object(s) from the compressed file.
 * If the input file was not in gzip format, read() copies the objects number
 * of bytes into the buffer.
 * returns the number of uncompressed bytes actually read
 * (0 for end of file, -1 for error).
 */
template <class T, class Items>
inline int read(izstream& zs, T* x, Items items) {
    return ::gzread(zs.fp(), x, items*sizeof(T));
}

/*
 * Binary input with the '>' operator.
 */
template <class T>
inline izstream& operator>(izstream& zs, T& x) {
    ::gzread(zs.fp(), &x, sizeof(T));
    return zs;
}


inline zstringlen::zstringlen(izstream& zs) {
    zs > val.byte;
    if (val.byte == 255) zs > val.word;
    else val.word = val.byte;
}

/*
 * Read length of string + the string with the '>' operator.
 */
inline izstream& operator>(izstream& zs, char* x) {
    zstringlen len(zs);
    ::gzread(zs.fp(), x, len.value());
    x[len.value()] = '\0';
    return zs;
}

inline char* read_string(izstream& zs) {
    zstringlen len(zs);
    char* x = new char[len.value()+1];
    ::gzread(zs.fp(), x, len.value());
    x[len.value()] = '\0';
    return x;
}

// ----------------------------- ozstream -----------------------------

class ozstream
{
    public:
        ozstream() : m_fp(0), m_os(0) {
        }
        ozstream(FILE* fp, int level = Z_DEFAULT_COMPRESSION)
            : m_fp(0), m_os(0) {
            open(fp, level);
        }
        ozstream(const char* name, int level = Z_DEFAULT_COMPRESSION)
            : m_fp(0), m_os(0) {
            open(name, level);
        }
        ~ozstream() {
            close();
        }

        /* Opens a gzip (.gz) file for writing.
         * The compression level parameter should be in 0..9
         * errno can be checked to distinguish two error cases
         * (if errno is zero, the zlib error is Z_MEM_ERROR).
         */
        void open(const char* name, int level = Z_DEFAULT_COMPRESSION) {
            char mode[4] = "wb\0";
            if (level != Z_DEFAULT_COMPRESSION) mode[2] = '0'+level;
            if (m_fp) close();
            m_fp = ::gzopen(name, mode);
        }

        /* open from a FILE pointer.
         */
        void open(FILE* fp, int level = Z_DEFAULT_COMPRESSION) {
            SET_BINARY_MODE(fp);
            char mode[4] = "wb\0";
            if (level != Z_DEFAULT_COMPRESSION) mode[2] = '0'+level;
            if (m_fp) close();
            m_fp = ::gzdopen(fileno(fp), mode);
        }

        /* Flushes all pending output if necessary, closes the compressed file
         * and deallocates all the (de)compression state. The return value is
         * the zlib error number (see function error() below).
         */
        int close() {
            if (m_os) {
                ::gzwrite(m_fp, m_os->str(), m_os->pcount());
                delete[] m_os->str(); delete m_os; m_os = 0;
            }
            int r = ::gzclose(m_fp); m_fp = 0; return r;
        }

        /* Binary write the given number of bytes into the compressed file.
         */
        int write(const void* buf, size_t len) {
            return ::gzwrite(m_fp, (voidp) buf, len);
        }

        /* Flushes all pending output into the compressed file. The parameter
         * _flush is as in the deflate() function. The return value is the zlib
         * error number (see function gzerror below). flush() returns Z_OK if
         * the flush_ parameter is Z_FINISH and all output could be flushed.
         * flush() should be called only when strictly necessary because it can
         * degrade compression.
         */
        int flush(int _flush) {
            os_flush();
            return ::gzflush(m_fp, _flush);
        }

        /* Returns the error message for the last error which occurred on the
         * given compressed file. errnum is set to zlib error number. If an
         * error occurred in the file system and not in the compression library,
         * errnum is set to Z_ERRNO and the application may consult errno
         * to get the exact error code.
         */
        const char* error(int* errnum) {
            return ::gzerror(m_fp, errnum);
        }

        gzFile fp() { return m_fp; }

        ostream& os() {
            if (m_os == 0) m_os = new ostrstream;
            return *m_os;
        }

        void os_flush() {
            if (m_os && m_os->pcount()>0) {
                ostrstream* oss = new ostrstream;
                oss->fill(m_os->fill());
                oss->flags(m_os->flags());
                oss->precision(m_os->precision());
                oss->width(m_os->width());
                ::gzwrite(m_fp, m_os->str(), m_os->pcount());
                delete[] m_os->str(); delete m_os; m_os = oss;
            }
        }

    private:
        gzFile m_fp;
        ostrstream* m_os;
};

/*
 * Binary write the given (array of) object(s) into the compressed file.
 * returns the number of uncompressed bytes actually written
 * (0 in case of error).
 */
template <class T, class Items>
inline int write(ozstream& zs, const T* x, Items items) {
    return ::gzwrite(zs.fp(), (voidp) x, items*sizeof(T));
}

/*
 * Binary output with the '<' operator.
 */
template <class T>
inline ozstream& operator<(ozstream& zs, const T& x) {
    ::gzwrite(zs.fp(), (voidp) &x, sizeof(T));
    return zs;
}

inline zstringlen::zstringlen(ozstream& zs, const char* x) {
    val.byte = 255;  val.word = ::strlen(x);
    if (val.word < 255) zs < (val.byte = val.word);
    else zs < val;
}

/*
 * Write length of string + the string with the '<' operator.
 */
inline ozstream& operator<(ozstream& zs, const char* x) {
    zstringlen len(zs, x);
    ::gzwrite(zs.fp(), (voidp) x, len.value());
    return zs;
}

#ifdef _MSC_VER
inline ozstream& operator<(ozstream& zs, char* const& x) {
    return zs < (const char*) x;
}
#endif

/*
 * Ascii write with the << operator;
 */
template <class T>
inline ostream& operator<<(ozstream& zs, const T& x) {
    zs.os_flush();
    return zs.os() << x;
}

#endif
Revision:	1096
Committed:	Sat Dec 30 14:40:33 2017 UTC (7 years, 10 months ago) by s10k
Content type:	text/x-chdr
File size:	9283 byte(s)
Log Message:	Added zlib, quazip, basicxmlsyntaxhighlighter, conditionalsemaphore and linenumberdisplay libraries. zlib and quazip are pre-compiled, but you can compile them yourself, just delete the dll files (or equivalent binary files to your OS)
#	Content
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