From 4b5a43a219d51066c01ff2ab86af18b967f2d0dd Mon Sep 17 00:00:00 2001 From: Mark Adler Date: Fri, 9 Sep 2011 23:22:37 -0700 Subject: zlib 1.2.0.5 --- contrib/iostream3/zfstream.h | 274 +++++++++++++++++++++---------------------- 1 file changed, 137 insertions(+), 137 deletions(-) (limited to 'contrib/iostream3/zfstream.h') diff --git a/contrib/iostream3/zfstream.h b/contrib/iostream3/zfstream.h index ad76e8b..8574479 100644 --- a/contrib/iostream3/zfstream.h +++ b/contrib/iostream3/zfstream.h @@ -1,9 +1,9 @@ /* * A C++ I/O streams interface to the zlib gz* functions - * + * * by Ludwig Schwardt * original version by Kevin Ruland - * + * * This version is standard-compliant and compatible with gcc 3.x. */ @@ -20,204 +20,204 @@ * @brief Gzipped file stream buffer class. * * This class implements basic_filebuf for gzipped files. It doesn't yet support - * seeking (allowed by zlib but slow/limited), putback and read/write access - * (tricky). Otherwise, it attempts to be a drop-in replacement for the standard + * seeking (allowed by zlib but slow/limited), putback and read/write access + * (tricky). Otherwise, it attempts to be a drop-in replacement for the standard * file streambuf. */ -class gzfilebuf : public std::streambuf +class gzfilebuf : public std::streambuf { -public: +public: // Default constructor. gzfilebuf(); - + // Destructor. - virtual + virtual ~gzfilebuf(); /** * @brief Set compression level and strategy on the fly. - * @param comp_level Compression level (see zlib.h for allowed values) - * @param comp_strategy Compression strategy (see zlib.h for allowed values) + * @param comp_level Compression level (see zlib.h for allowed values) + * @param comp_strategy Compression strategy (see zlib.h for allowed values) * @return Z_OK on success, Z_STREAM_ERROR otherwise. - * + * * Unfortunately, these parameters cannot be modified separately, as the * previous zfstream version assumed. Since the strategy is seldom changed, * it can default and setcompression(level) then becomes like the old * setcompressionlevel(level). */ - int - setcompression(int comp_level, - int comp_strategy = Z_DEFAULT_STRATEGY); - + int + setcompression(int comp_level, + int comp_strategy = Z_DEFAULT_STRATEGY); + /** * @brief Check if file is open. * @return True if file is open. */ - bool + bool is_open() const { return (file != NULL); } - + /** * @brief Open gzipped file. * @param name File name. * @param mode Open mode flags. * @return @c this on success, NULL on failure. */ - gzfilebuf* - open(const char* name, + gzfilebuf* + open(const char* name, std::ios_base::openmode mode); - + /** * @brief Attach to already open gzipped file. * @param fd File descriptor. * @param mode Open mode flags. * @return @c this on success, NULL on failure. */ - gzfilebuf* - attach(int fd, - std::ios_base::openmode mode); - + gzfilebuf* + attach(int fd, + std::ios_base::openmode mode); + /** * @brief Close gzipped file. * @return @c this on success, NULL on failure. */ - gzfilebuf* + gzfilebuf* close(); - + protected: /** * @brief Convert ios open mode int to mode string used by zlib. * @return True if valid mode flag combination. */ - bool - open_mode(std::ios_base::openmode mode, - char* c_mode) const; - + bool + open_mode(std::ios_base::openmode mode, + char* c_mode) const; + /** * @brief Number of characters available in stream buffer. * @return Number of characters. - * + * * This indicates number of characters in get area of stream buffer. * These characters can be read without accessing the gzipped file. */ virtual std::streamsize showmanyc(); - + /** * @brief Fill get area from gzipped file. * @return First character in get area on success, EOF on error. - * + * * This actually reads characters from gzipped file to stream * buffer. Always buffered. */ virtual int_type underflow(); - + /** * @brief Write put area to gzipped file. * @param c Extra character to add to buffer contents. * @return Non-EOF on success, EOF on error. - * - * This actually writes characters in stream buffer to - * gzipped file. With unbuffered output this is done one + * + * This actually writes characters in stream buffer to + * gzipped file. With unbuffered output this is done one * character at a time. - */ - virtual int_type + */ + virtual int_type overflow(int_type c = traits_type::eof()); - + /** * @brief Installs external stream buffer. * @param p Pointer to char buffer. * @param n Size of external buffer. * @return @c this on success, NULL on failure. - * + * * Call setbuf(0,0) to enable unbuffered output. */ - virtual std::streambuf* - setbuf(char_type* p, - std::streamsize n); + virtual std::streambuf* + setbuf(char_type* p, + std::streamsize n); /** * @brief Flush stream buffer to file. * @return 0 on success, -1 on error. - * + * * This calls underflow(EOF) to do the job. */ - virtual int + virtual int sync(); - + // // Some future enhancements -// +// // virtual int_type uflow(); // virtual int_type pbackfail(int_type c = traits_type::eof()); -// virtual pos_type -// seekoff(off_type off, -// std::ios_base::seekdir way, -// std::ios_base::openmode mode = std::ios_base::in|std::ios_base::out); -// virtual pos_type -// seekpos(pos_type sp, -// std::ios_base::openmode mode = std::ios_base::in|std::ios_base::out); - +// virtual pos_type +// seekoff(off_type off, +// std::ios_base::seekdir way, +// std::ios_base::openmode mode = std::ios_base::in|std::ios_base::out); +// virtual pos_type +// seekpos(pos_type sp, +// std::ios_base::openmode mode = std::ios_base::in|std::ios_base::out); + private: /** * @brief Allocate internal buffer. - * + * * This function is safe to call multiple times. It will ensure * that a proper internal buffer exists if it is required. If the * buffer already exists or is external, the buffer pointers will be * reset to their original state. */ - void + void enable_buffer(); - + /** * @brief Destroy internal buffer. - * + * * This function is safe to call multiple times. It will ensure * that the internal buffer is deallocated if it exists. In any * case, it will also reset the buffer pointers. */ - void + void disable_buffer(); - + /** * Underlying file pointer. */ gzFile file; - + /** * Mode in which file was opened. */ std::ios_base::openmode io_mode; - + /** * @brief True if this object owns file descriptor. * - * This makes the class responsible for closing the file + * This makes the class responsible for closing the file * upon destruction. */ bool own_fd; - + /** * @brief Stream buffer. - * - * For simplicity this remains allocated on the free store for the + * + * For simplicity this remains allocated on the free store for the * entire life span of the gzfilebuf object, unless replaced by setbuf. */ char_type* buffer; - + /** * @brief Stream buffer size. - * + * * Defaults to system default buffer size (typically 8192 bytes). * Modified by setbuf. */ std::streamsize buffer_size; - + /** * @brief True if this object owns stream buffer. * - * This makes the class responsible for deleting the buffer + * This makes the class responsible for deleting the buffer * upon destruction. */ bool own_buffer; @@ -231,49 +231,49 @@ private: * This class implements ifstream for gzipped files. Seeking and putback * is not supported yet. */ -class gzifstream : public std::istream +class gzifstream : public std::istream { public: // Default constructor gzifstream(); - + /** * @brief Construct stream on gzipped file to be opened. * @param name File name. * @param mode Open mode flags (forced to contain ios::in). */ explicit - gzifstream(const char* name, - std::ios_base::openmode mode = std::ios_base::in); - + gzifstream(const char* name, + std::ios_base::openmode mode = std::ios_base::in); + /** * @brief Construct stream on already open gzipped file. * @param fd File descriptor. * @param mode Open mode flags (forced to contain ios::in). */ - explicit - gzifstream(int fd, - std::ios_base::openmode mode = std::ios_base::in); + explicit + gzifstream(int fd, + std::ios_base::openmode mode = std::ios_base::in); /** * Obtain underlying stream buffer. - */ - gzfilebuf* + */ + gzfilebuf* rdbuf() const - { return const_cast(&sb); } + { return const_cast(&sb); } /** * @brief Check if file is open. * @return True if file is open. */ - bool + bool is_open() { return sb.is_open(); } - + /** * @brief Open gzipped file. * @param name File name. * @param mode Open mode flags (forced to contain ios::in). - * + * * Stream will be in state good() if file opens successfully; * otherwise in state fail(). This differs from the behavior of * ifstream, which never sets the state to good() and therefore @@ -281,34 +281,34 @@ public: * you manually clear() the state. The choice is a matter of * convenience. */ - void - open(const char* name, + void + open(const char* name, std::ios_base::openmode mode = std::ios_base::in); /** * @brief Attach to already open gzipped file. * @param fd File descriptor. * @param mode Open mode flags (forced to contain ios::in). - * + * * Stream will be in state good() if attach succeeded; otherwise * in state fail(). */ - void - attach(int fd, - std::ios_base::openmode mode = std::ios_base::in); + void + attach(int fd, + std::ios_base::openmode mode = std::ios_base::in); /** * @brief Close gzipped file. - * + * * Stream will be in state fail() if close failed. */ - void + void close(); - + private: /** * Underlying stream buffer. - */ + */ gzfilebuf sb; }; @@ -325,44 +325,44 @@ class gzofstream : public std::ostream public: // Default constructor gzofstream(); - + /** * @brief Construct stream on gzipped file to be opened. * @param name File name. * @param mode Open mode flags (forced to contain ios::out). */ explicit - gzofstream(const char* name, - std::ios_base::openmode mode = std::ios_base::out); - + gzofstream(const char* name, + std::ios_base::openmode mode = std::ios_base::out); + /** * @brief Construct stream on already open gzipped file. * @param fd File descriptor. * @param mode Open mode flags (forced to contain ios::out). */ - explicit - gzofstream(int fd, - std::ios_base::openmode mode = std::ios_base::out); + explicit + gzofstream(int fd, + std::ios_base::openmode mode = std::ios_base::out); /** * Obtain underlying stream buffer. - */ - gzfilebuf* + */ + gzfilebuf* rdbuf() const - { return const_cast(&sb); } + { return const_cast(&sb); } /** * @brief Check if file is open. * @return True if file is open. */ - bool + bool is_open() { return sb.is_open(); } - + /** * @brief Open gzipped file. * @param name File name. * @param mode Open mode flags (forced to contain ios::out). - * + * * Stream will be in state good() if file opens successfully; * otherwise in state fail(). This differs from the behavior of * ofstream, which never sets the state to good() and therefore @@ -370,39 +370,39 @@ public: * you manually clear() the state. The choice is a matter of * convenience. */ - void - open(const char* name, + void + open(const char* name, std::ios_base::openmode mode = std::ios_base::out); /** * @brief Attach to already open gzipped file. * @param fd File descriptor. * @param mode Open mode flags (forced to contain ios::out). - * + * * Stream will be in state good() if attach succeeded; otherwise * in state fail(). */ - void - attach(int fd, - std::ios_base::openmode mode = std::ios_base::out); + void + attach(int fd, + std::ios_base::openmode mode = std::ios_base::out); /** * @brief Close gzipped file. - * + * * Stream will be in state fail() if close failed. */ - void + void close(); - + private: /** * Underlying stream buffer. - */ + */ gzfilebuf sb; }; /*****************************************************************************/ - + /** * @brief Gzipped file output stream manipulator class. * @@ -415,28 +415,28 @@ template public: // Allows insertor to peek at internals template - friend gzofstream& - operator<<(gzofstream&, - const gzomanip2&); - + friend gzofstream& + operator<<(gzofstream&, + const gzomanip2&); + // Constructor gzomanip2(gzofstream& (*f)(gzofstream&, T1, T2), - T1 v1, - T2 v2); + T1 v1, + T2 v2); private: // Underlying manipulator function gzofstream& (*func)(gzofstream&, T1, T2); - - // Arguments for manipulator function + + // Arguments for manipulator function T1 val1; T2 val2; }; /*****************************************************************************/ - + // Manipulator function thunks through to stream buffer -inline gzofstream& +inline gzofstream& setcompression(gzofstream &gzs, int l, int s = Z_DEFAULT_STRATEGY) { (gzs.rdbuf())->setcompression(l, s); @@ -445,22 +445,22 @@ setcompression(gzofstream &gzs, int l, int s = Z_DEFAULT_STRATEGY) // Manipulator constructor stores arguments template - inline + inline gzomanip2::gzomanip2(gzofstream &(*f)(gzofstream &, T1, T2), - T1 v1, - T2 v2) + T1 v1, + T2 v2) : func(f), val1(v1), val2(v2) { } // Insertor applies underlying manipulator function to stream template - inline gzofstream& - operator<<(gzofstream& s, const gzomanip2& m) + inline gzofstream& + operator<<(gzofstream& s, const gzomanip2& m) { return (*m.func)(s, m.val1, m.val2); } // Insert this onto stream to simplify setting of compression level -inline gzomanip2 -setcompression(int l, int s = Z_DEFAULT_STRATEGY) +inline gzomanip2 +setcompression(int l, int s = Z_DEFAULT_STRATEGY) { return gzomanip2(&setcompression, l, s); } #endif // ZFSTREAM_H -- cgit v1.2.3-55-g6feb