1 // ============================================================================ 2 // gzstream, C++ iostream classes wrapping the zlib compression library. 3 // Copyright (C) 2001 Deepak Bandyopadhyay, Lutz Kettner 4 // 5 // This library is free software; you can redistribute it and/or 6 // modify it under the terms of the GNU Lesser General Public 7 // License as published by the Free Software Foundation; either 8 // version 2.1 of the License, or (at your option) any later version. 9 // 10 // This library is distributed in the hope that it will be useful, 11 // but WITHOUT ANY WARRANTY; without even the implied warranty of 12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 13 // Lesser General Public License for more details. 14 // 15 // You should have received a copy of the GNU Lesser General Public 16 // License along with this library; if not, write to the Free Software 17 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 18 // ============================================================================ 19 // 20 // File : gzstream.h 21 // Revision : $Revision: 1.5 $ 22 // Revision_date : $Date: 2002/04/26 23:30:15 $ 23 // Author(s) : Deepak Bandyopadhyay, Lutz Kettner 24 // 25 // Standard streambuf implementation following Nicolai Josuttis, "The 26 // Standard C++ Library". 27 // ============================================================================ 28 29 #ifndef GZSTREAM_H 30 #define GZSTREAM_H 1 31 32 // standard C++ with new header file names and std:: namespace 33 #include <iostream> 34 #include <fstream> 35 #include <zlib.h> 36 37 #ifdef GZSTREAM_NAMESPACE 38 namespace GZSTREAM_NAMESPACE { 39 #endif 40 41 // ---------------------------------------------------------------------------- 42 // Internal classes to implement gzstream. See below for user classes. 43 // ---------------------------------------------------------------------------- 44 45 class gzstreambuf : public std::streambuf { 46 private: 47 static const int bufferSize = 47+256; // size of data buff 48 // totals 512 bytes under g++ for igzstream at the end. 49 50 gzFile file; // file handle for compressed file 51 char buffer[bufferSize]; // data buffer 52 char opened; // open/close state of stream 53 int mode; // I/O mode 54 55 int flush_buffer(); 56 public: gzstreambuf()57 gzstreambuf() : opened(0) { 58 setp( buffer, buffer + (bufferSize-1)); 59 setg( buffer + 4, // beginning of putback area 60 buffer + 4, // read position 61 buffer + 4); // end position 62 // ASSERT: both input & output capabilities will not be used together 63 } is_open()64 int is_open() { return opened; } 65 gzstreambuf* open( const char* name, int open_mode); 66 gzstreambuf* close(); ~gzstreambuf()67 ~gzstreambuf() { close(); } 68 69 virtual int overflow( int c = EOF); 70 virtual int underflow(); 71 virtual int sync(); 72 }; 73 74 class gzstreambase : virtual public std::ios { 75 protected: 76 gzstreambuf buf; 77 public: gzstreambase()78 gzstreambase() { init(&buf); } 79 gzstreambase( const char* name, int open_mode); 80 ~gzstreambase(); 81 void open( const char* name, int open_mode); 82 void close(); rdbuf()83 gzstreambuf* rdbuf() { return &buf; } is_open()84 int is_open() { return buf.is_open(); } 85 }; 86 87 // ---------------------------------------------------------------------------- 88 // User classes. Use igzstream and ogzstream analogously to ifstream and 89 // ofstream respectively. They read and write files based on the gz* 90 // function interface of the zlib. Files are compatible with gzip compression. 91 // ---------------------------------------------------------------------------- 92 93 class igzstream : public gzstreambase, public std::istream { 94 public: igzstream()95 igzstream() : std::istream( &buf) {} 96 igzstream( const char* name, int open_mode = std::ios::in) gzstreambase(name,open_mode)97 : gzstreambase( name, open_mode), std::istream( &buf) {} 98 igzstream( std::basic_string<char> name, int open_mode = std::ios::in) 99 : gzstreambase( name.c_str(), open_mode), std::istream( &buf) {} rdbuf()100 gzstreambuf* rdbuf() { return gzstreambase::rdbuf(); } 101 void open( const char* name, int open_mode = std::ios::in) { 102 gzstreambase::open( name, open_mode); 103 } 104 void open( std::string name, int open_mode = std::ios::in) { 105 gzstreambase::open( name.c_str(), open_mode); 106 } 107 }; 108 109 class ogzstream : public gzstreambase, public std::ostream { 110 public: ogzstream()111 ogzstream() : std::ostream( &buf) {} 112 ogzstream( const char* name, int mode = std::ios::out) gzstreambase(name,mode)113 : gzstreambase( name, mode), std::ostream( &buf) {} 114 ogzstream( std::string name, int mode = std::ios::out) 115 : gzstreambase( name.c_str(), mode), std::ostream( &buf) {} rdbuf()116 gzstreambuf* rdbuf() { return gzstreambase::rdbuf(); } 117 void open( const char* name, int open_mode = std::ios::out) { 118 gzstreambase::open( name, open_mode); 119 } 120 void open( std::string name, int open_mode = std::ios::out) { 121 gzstreambase::open( name.c_str(), open_mode); 122 } 123 }; 124 125 #ifdef GZSTREAM_NAMESPACE 126 } // namespace GZSTREAM_NAMESPACE 127 #endif 128 129 #endif // GZSTREAM_H 130 // ============================================================================ 131 // EOF // 132 133