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/README | 16 +-- contrib/iostream3/TODO | 2 +- contrib/iostream3/test.cc | 8 +- contrib/iostream3/zfstream.cc | 132 ++++++++++---------- contrib/iostream3/zfstream.h | 274 +++++++++++++++++++++--------------------- 5 files changed, 216 insertions(+), 216 deletions(-) (limited to 'contrib/iostream3') diff --git a/contrib/iostream3/README b/contrib/iostream3/README index 6f73d58..f7b319a 100644 --- a/contrib/iostream3/README +++ b/contrib/iostream3/README @@ -3,19 +3,19 @@ to do things like: gzofstream outf("blah.gz"); outf << "These go into the gzip file " << 123 << endl; - + It does this by deriving a specialized stream buffer for gzipped files, which is -the way Stroustrup would have done it. :-> +the way Stroustrup would have done it. :-> The gzifstream and gzofstream classes were originally written by Kevin Ruland and made available in the zlib contrib/iostream directory. The older version still -compiles under gcc 2.xx, but not under gcc 3.xx, which sparked the development of +compiles under gcc 2.xx, but not under gcc 3.xx, which sparked the development of this version. -The new classes are as standard-compliant as possible, closely following the -approach of the standard library's fstream classes. It compiles under gcc versions -3.2 and 3.3, but not under gcc 2.xx. This is mainly due to changes in the standard -library naming scheme. The new version of gzifstream/gzofstream/gzfilebuf differs +The new classes are as standard-compliant as possible, closely following the +approach of the standard library's fstream classes. It compiles under gcc versions +3.2 and 3.3, but not under gcc 2.xx. This is mainly due to changes in the standard +library naming scheme. The new version of gzifstream/gzofstream/gzfilebuf differs from the previous one in the following respects: - added showmanyc - added setbuf, with support for unbuffered output via setbuf(0,0) @@ -23,7 +23,7 @@ from the previous one in the following respects: - gzipped output file opened with default compression level instead of maximum level - setcompressionlevel()/strategy() members replaced by single setcompression() -The code is provided "as is", with the permission to use, copy, modify, distribute +The code is provided "as is", with the permission to use, copy, modify, distribute and sell it for any purpose without fee. Ludwig Schwardt diff --git a/contrib/iostream3/TODO b/contrib/iostream3/TODO index 4578326..7032f97 100644 --- a/contrib/iostream3/TODO +++ b/contrib/iostream3/TODO @@ -13,5 +13,5 @@ Possible upgrades to gzfilebuf: - Check public interface to see which calls give problems (due to dependence on library internals) -- Override operator<<(ostream&, gzfilebuf*) to allow direct copying +- Override operator<<(ostream&, gzfilebuf*) to allow direct copying of stream buffer to stream ( i.e. os << is.rdbuf(); ) diff --git a/contrib/iostream3/test.cc b/contrib/iostream3/test.cc index 9ffa8be..9423533 100644 --- a/contrib/iostream3/test.cc +++ b/contrib/iostream3/test.cc @@ -1,6 +1,6 @@ /* * Test program for gzifstream and gzofstream - * + * * by Ludwig Schwardt * original version by Kevin Ruland */ @@ -13,15 +13,15 @@ int main() { gzofstream outf; gzifstream inf; char buf[80]; - + outf.open("test1.txt.gz"); - outf << "The quick brown fox sidestepped the lazy canine\n" + outf << "The quick brown fox sidestepped the lazy canine\n" << 1.3 << "\nPlan " << 9 << std::endl; outf.close(); std::cout << "Wrote the following message to 'test1.txt.gz' (check with zcat or zless):\n" << "The quick brown fox sidestepped the lazy canine\n" << 1.3 << "\nPlan " << 9 << std::endl; - + std::cout << "\nReading 'test1.txt.gz' (buffered) produces:\n"; inf.open("test1.txt.gz"); while (inf.getline(buf,80,'\n')) { diff --git a/contrib/iostream3/zfstream.cc b/contrib/iostream3/zfstream.cc index 24d15fa..94eb933 100644 --- a/contrib/iostream3/zfstream.cc +++ b/contrib/iostream3/zfstream.cc @@ -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. */ @@ -18,8 +18,8 @@ /*****************************************************************************/ // Default constructor -gzfilebuf::gzfilebuf() -: file(NULL), io_mode(std::ios_base::openmode(0)), own_fd(false), +gzfilebuf::gzfilebuf() +: file(NULL), io_mode(std::ios_base::openmode(0)), own_fd(false), buffer(NULL), buffer_size(BIGBUFSIZE), own_buffer(true) { // No buffers to start with @@ -27,12 +27,12 @@ gzfilebuf::gzfilebuf() } // Destructor -gzfilebuf::~gzfilebuf() +gzfilebuf::~gzfilebuf() { // Sync output buffer and close only if responsible for file // (i.e. attached streams should be left open at this stage) this->sync(); - if (own_fd) + if (own_fd) this->close(); // Make sure internal buffer is deallocated this->disable_buffer(); @@ -41,30 +41,30 @@ gzfilebuf::~gzfilebuf() // Set compression level and strategy int gzfilebuf::setcompression(int comp_level, - int comp_strategy) + int comp_strategy) { return gzsetparams(file, comp_level, comp_strategy); } // Open gzipped file -gzfilebuf* -gzfilebuf::open(const char *name, - std::ios_base::openmode mode) +gzfilebuf* +gzfilebuf::open(const char *name, + std::ios_base::openmode mode) { // Fail if file already open - if (this->is_open()) + if (this->is_open()) return NULL; // Don't support simultaneous read/write access (yet) - if ((mode & std::ios_base::in) && (mode & std::ios_base::out)) + if ((mode & std::ios_base::in) && (mode & std::ios_base::out)) return NULL; - + // Build mode string for gzopen and check it [27.8.1.3.2] char char_mode[6] = "\0\0\0\0\0"; if (!this->open_mode(mode, char_mode)) return NULL; - + // Attempt to open file - if ((file = gzopen(name, char_mode)) == NULL) + if ((file = gzopen(name, char_mode)) == NULL) return NULL; // On success, allocate internal buffer and set flags @@ -77,24 +77,24 @@ gzfilebuf::open(const char *name, // Attach to gzipped file gzfilebuf* gzfilebuf::attach(int fd, - std::ios_base::openmode mode) + std::ios_base::openmode mode) { // Fail if file already open - if (this->is_open()) + if (this->is_open()) return NULL; // Don't support simultaneous read/write access (yet) - if ((mode & std::ios_base::in) && (mode & std::ios_base::out)) + if ((mode & std::ios_base::in) && (mode & std::ios_base::out)) return NULL; - + // Build mode string for gzdopen and check it [27.8.1.3.2] char char_mode[6] = "\0\0\0\0\0"; if (!this->open_mode(mode, char_mode)) return NULL; - + // Attempt to attach to file if ((file = gzdopen(fd, char_mode)) == NULL) return NULL; - + // On success, allocate internal buffer and set flags this->enable_buffer(); io_mode = mode; @@ -104,7 +104,7 @@ gzfilebuf::attach(int fd, // Close gzipped file gzfilebuf* -gzfilebuf::close() +gzfilebuf::close() { // Fail immediately if no file is open if (!this->is_open()) @@ -127,16 +127,16 @@ gzfilebuf::close() /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ // Convert int open mode to mode string -bool -gzfilebuf::open_mode(std::ios_base::openmode mode, - char* c_mode) const +bool +gzfilebuf::open_mode(std::ios_base::openmode mode, + char* c_mode) const { bool testb = mode & std::ios_base::binary; bool testi = mode & std::ios_base::in; bool testo = mode & std::ios_base::out; bool testt = mode & std::ios_base::trunc; bool testa = mode & std::ios_base::app; - + // Check for valid flag combinations - see [27.8.1.3.2] (Table 92) // Original zfstream hardcoded the compression level to maximum here... // Double the time for less than 1% size improvement seems @@ -156,7 +156,7 @@ gzfilebuf::open_mode(std::ios_base::openmode mode, // if (testi && testo && testt && !testa) // strcpy(c_mode, "w+"); - // Mode string should be empty for invalid combination of flags + // Mode string should be empty for invalid combination of flags if (strlen(c_mode) == 0) return false; if (testb) @@ -165,7 +165,7 @@ gzfilebuf::open_mode(std::ios_base::openmode mode, } // Determine number of characters in internal get buffer -std::streamsize +std::streamsize gzfilebuf::showmanyc() { // Calls to underflow will fail if file not opened for reading @@ -180,10 +180,10 @@ gzfilebuf::showmanyc() // Fill get area from gzipped file gzfilebuf::int_type -gzfilebuf::underflow() +gzfilebuf::underflow() { // If something is left in the get area by chance, return it - // (this shouldn't normally happen, as underflow is only supposed + // (this shouldn't normally happen, as underflow is only supposed // to be called when gptr >= egptr, but it serves as error check) if (this->gptr() && (this->gptr() < this->egptr())) return traits_type::to_int_type(*(this->gptr())); @@ -204,14 +204,14 @@ gzfilebuf::underflow() } // Make all bytes read from file available as get area this->setg(buffer, buffer, buffer + bytes_read); - + // Return next character in get area return traits_type::to_int_type(*(this->gptr())); } // Write put area to gzipped file gzfilebuf::int_type -gzfilebuf::overflow(int_type c) +gzfilebuf::overflow(int_type c) { // Determine whether put area is in use if (this->pbase()) @@ -232,10 +232,10 @@ gzfilebuf::overflow(int_type c) { // If the file hasn't been opened for writing, produce error if (!this->is_open() || !(io_mode & std::ios_base::out)) - return traits_type::eof(); + return traits_type::eof(); // If gzipped file won't accept all bytes written to it, fail if (gzwrite(file, this->pbase(), bytes_to_write) != bytes_to_write) - return traits_type::eof(); + return traits_type::eof(); // Reset next pointer to point to pbase on success this->pbump(-bytes_to_write); } @@ -250,7 +250,7 @@ gzfilebuf::overflow(int_type c) char_type last_char = traits_type::to_char_type(c); // If gzipped file won't accept this character, fail if (gzwrite(file, &last_char, 1) != 1) - return traits_type::eof(); + return traits_type::eof(); } // If you got here, you have succeeded (even if c was EOF) @@ -262,9 +262,9 @@ gzfilebuf::overflow(int_type c) } // Assign new buffer -std::streambuf* +std::streambuf* gzfilebuf::setbuf(char_type* p, - std::streamsize n) + std::streamsize n) { // First make sure stuff is sync'ed, for safety if (this->sync() == -1) @@ -295,8 +295,8 @@ gzfilebuf::setbuf(char_type* p, } // Write put area to gzipped file (i.e. ensures that put area is empty) -int -gzfilebuf::sync() +int +gzfilebuf::sync() { return traits_type::eq_int_type(this->overflow(), traits_type::eof()) ? -1 : 0; } @@ -304,11 +304,11 @@ gzfilebuf::sync() /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ // Allocate internal buffer -void -gzfilebuf::enable_buffer() +void +gzfilebuf::enable_buffer() { // If internal buffer required, allocate one - if (own_buffer && !buffer) + if (own_buffer && !buffer) { // Check for buffered vs. "unbuffered" if (buffer_size > 0) @@ -335,16 +335,16 @@ gzfilebuf::enable_buffer() } else { - // If buffer already allocated, reset buffer pointers just to make sure no + // If buffer already allocated, reset buffer pointers just to make sure no // stale chars are lying around this->setg(buffer, buffer, buffer); this->setp(buffer, buffer + buffer_size - 1); - } + } } // Destroy internal buffer -void -gzfilebuf::disable_buffer() +void +gzfilebuf::disable_buffer() { // If internal buffer exists, deallocate it if (own_buffer && buffer) @@ -371,13 +371,13 @@ gzfilebuf::disable_buffer() /*****************************************************************************/ // Default constructor initializes stream buffer -gzifstream::gzifstream() +gzifstream::gzifstream() : std::istream(NULL), sb() { this->init(&sb); } // Initialize stream buffer and open file gzifstream::gzifstream(const char* name, - std::ios_base::openmode mode) + std::ios_base::openmode mode) : std::istream(NULL), sb() { this->init(&sb); @@ -386,7 +386,7 @@ gzifstream::gzifstream(const char* name, // Initialize stream buffer and attach to file gzifstream::gzifstream(int fd, - std::ios_base::openmode mode) + std::ios_base::openmode mode) : std::istream(NULL), sb() { this->init(&sb); @@ -394,9 +394,9 @@ gzifstream::gzifstream(int fd, } // Open file and go into fail() state if unsuccessful -void -gzifstream::open(const char* name, - std::ios_base::openmode mode) +void +gzifstream::open(const char* name, + std::ios_base::openmode mode) { if (!sb.open(name, mode | std::ios_base::in)) this->setstate(std::ios_base::failbit); @@ -405,9 +405,9 @@ gzifstream::open(const char* name, } // Attach to file and go into fail() state if unsuccessful -void -gzifstream::attach(int fd, - std::ios_base::openmode mode) +void +gzifstream::attach(int fd, + std::ios_base::openmode mode) { if (!sb.attach(fd, mode | std::ios_base::in)) this->setstate(std::ios_base::failbit); @@ -416,7 +416,7 @@ gzifstream::attach(int fd, } // Close file -void +void gzifstream::close() { if (!sb.close()) @@ -426,13 +426,13 @@ gzifstream::close() /*****************************************************************************/ // Default constructor initializes stream buffer -gzofstream::gzofstream() +gzofstream::gzofstream() : std::ostream(NULL), sb() { this->init(&sb); } // Initialize stream buffer and open file gzofstream::gzofstream(const char* name, - std::ios_base::openmode mode) + std::ios_base::openmode mode) : std::ostream(NULL), sb() { this->init(&sb); @@ -441,7 +441,7 @@ gzofstream::gzofstream(const char* name, // Initialize stream buffer and attach to file gzofstream::gzofstream(int fd, - std::ios_base::openmode mode) + std::ios_base::openmode mode) : std::ostream(NULL), sb() { this->init(&sb); @@ -449,9 +449,9 @@ gzofstream::gzofstream(int fd, } // Open file and go into fail() state if unsuccessful -void -gzofstream::open(const char* name, - std::ios_base::openmode mode) +void +gzofstream::open(const char* name, + std::ios_base::openmode mode) { if (!sb.open(name, mode | std::ios_base::out)) this->setstate(std::ios_base::failbit); @@ -460,9 +460,9 @@ gzofstream::open(const char* name, } // Attach to file and go into fail() state if unsuccessful -void -gzofstream::attach(int fd, - std::ios_base::openmode mode) +void +gzofstream::attach(int fd, + std::ios_base::openmode mode) { if (!sb.attach(fd, mode | std::ios_base::out)) this->setstate(std::ios_base::failbit); @@ -471,7 +471,7 @@ gzofstream::attach(int fd, } // Close file -void +void gzofstream::close() { if (!sb.close()) 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