BGI/SOAPsnp/gzstream.h

   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 <ostream>
  36 #include <zlib.h>
  37 #include <boost/iostreams/filtering_stream.hpp>
  38 #include <boost/iostreams/filter/gzip.hpp>
  39 #include <boost/iostreams/device/file.hpp>
  40
  41 #ifdef GZSTREAM_NAMESPACE
  42 namespace GZSTREAM_NAMESPACE {
  43 #endif
  44
  45 // ----------------------------------------------------------------------------
  46 // Internal classes to implement gzstream. See below for user classes.
  47 // ----------------------------------------------------------------------------
  48
  49 class gzstreambuf : public std::streambuf {
  50 private:
  51     static const int bufferSize = 47+256;    // size of data buff
  52     // totals 512 bytes under g++ for igzstream at the end.
  53
  54     gzFile           file;               // file handle for compressed file
  55     char             buffer[bufferSize]; // data buffer
  56     int             opened;             // open/close state of stream
  57     int              mode;               // I/O mode
  58
  59     int flush_buffer();
  60 public:
  61     gzstreambuf() : opened(0)
  62         {
  63         setp( buffer, buffer + (bufferSize-1));
  64         setg( buffer + 4,     // beginning of putback area
  65               buffer + 4,     // read position
  66               buffer + 4);    // end position
  67         // ASSERT: both input & output capabilities will not be used together
  68     }
  69    int is_open()
  70         {
  71                 return opened;
  72         }
  73     gzstreambuf* open( const char* name, int open_mode);
  74     gzstreambuf* close();
  75     ~gzstreambuf() { close(); }
  76
  77     virtual int     overflow( int c = EOF);
  78     virtual int     underflow();
  79     virtual int     sync();
  80         gzstreambuf& operator=(const gzstreambuf& gzs);
  81 };
  82
  83 class gzstreambase : virtual public std::ios
  84 {
  85 protected:
  86     gzstreambuf buf;
  87 public:
  88     gzstreambase()
  89         {
  90                 init(&buf);
  91         }
  92     gzstreambase( const char* name, int open_mode);
  93     ~gzstreambase();
  94         int is_open()
  95         {
  96                 return buf.is_open();
  97         }
  98     void open( const char* name, int open_mode);
  99     void close();
 100     gzstreambuf* rdbuf()
 101         {
 102                 return &buf;
 103         }
 104         gzstreambase& operator=(const gzstreambase& gzst);
 105 };
 106
 107 // ----------------------------------------------------------------------------
 108 // User classes. Use igzstream and ogzstream analogously to ifstream and
 109 // ofstream respectively. They read and write files based on the gz*
 110 // function interface of the zlib. Files are compatible with gzip compression.
 111 // ----------------------------------------------------------------------------
 112
 113 class igzstream : public gzstreambase, public std::istream
 114 {
 115 public:
 116     igzstream() : std::istream( &buf)
 117         {
 118                 /*gzstreambase::init(&buf);*/
 119         }
 120     igzstream( const char* name, int open_mode = std::ios::in)
 121         : gzstreambase( name, open_mode), std::istream( &buf)
 122         {
 123                 /*gzstreambase::init(&buf);*/
 124         }
 125     gzstreambuf* rdbuf() { return gzstreambase::rdbuf(); }
 126     void open( const char* name, int open_mode = std::ios::in)
 127         {
 128         gzstreambase::open( name, open_mode);
 129     }
 130 };
 131
 132 class ogzstream : public gzstreambase, public std::ostream
 133 {
 134 public:
 135     ogzstream() : std::ostream( &buf)
 136         {
 137                 /*gzstreambase::init(&buf);*/
 138         }
 139     ogzstream( const char* name, int mode = std::ios::out)
 140         : gzstreambase( name, mode), std::ostream( &buf)
 141         {
 142                 /*gzstreambase::init(&buf);*/
 143         }
 144     gzstreambuf* rdbuf()
 145         {
 146                 return gzstreambase::rdbuf();
 147         }
 148     void open( const char* name, int open_mode = std::ios::out)
 149         {
 150         gzstreambase::open( name, open_mode);
 151     }
 152         ogzstream& operator=(const ogzstream& ogzst);
 153 };
 154
 155
 156 class myfstream
 157 {
 158         public:
 159                 virtual void open(const char* name, int open_mode = std::ios::out) = 0;
 160                 virtual void close() = 0;
 161                 virtual void clear() = 0;
 162                 virtual bool good() =0;
 163                 virtual std::ostream& flush() =0;
 164                 virtual std::ostream& endl() =0;
 165                 virtual void write(const char* name, int streamsizecount) =0;
 166                 virtual int is_open() = 0;
 167                 virtual myfstream & operator<<(const double value) = 0;
 168                 virtual myfstream & operator<<(const char* value) = 0;
 169                 virtual myfstream & operator<<(const char value) = 0;
 170                 virtual myfstream & operator<<(const unsigned char value) = 0;
 171                 virtual myfstream & operator<<(const std::string & value) = 0;
 172                 virtual myfstream & operator<<(const int value) = 0;
 173                 virtual myfstream & operator<<(const int* value) = 0;
 174                 virtual myfstream & operator<<(const unsigned int value) = 0;
 175                 virtual myfstream & operator<<(const float value) = 0;
 176                 virtual int set_f(std::ios_base::fmtflags value) = 0;
 177                 //virtual ostream & operator<<(std::ostream& value) = 0;
 178                 //virtual myfstream & operator<< (std::ostream& (__cdecl *fun) (ostream& value)) =0;
 179
 180 };
 181
 182 /**
 183  * a class to use ofstream.
 184  *
 185  */
 186 class myofstream : public myfstream
 187 {
 188         private:
 189                 std::ofstream ogz;
 190         public:
 191                 myofstream() : ogz(){}
 192                 myofstream(const char * name, int mode = std::ios::out)
 193                        :ogz(name){}
 194                 virtual inline void open( const char* name, int open_mode = std::ios::out)
 195                 {
 196                         ogz.open(name);
 197                 }
 198                 virtual inline void close()
 199                 {
 200                         ogz.close();
 201                 }
 202                 virtual inline void write(const char* name, int streamsizecount )
 203                 {
 204                         ogz.write(name, streamsizecount);
 205                 }
 206                 virtual inline std::ostream& flush()
 207                 {
 208                         return ogz.flush();
 209                 }
 210                 virtual inline std::ostream& endl()
 211                 {
 212                         ogz << "\n";
 213                         return ogz.flush();
 214                 }
 215                 virtual inline void clear()
 216                 {
 217                         ogz.clear();
 218                 }
 219                 virtual inline bool good()
 220                 {
 221                         return ogz.good();
 222                 }
 223                 virtual inline int is_open()
 224                 {
 225                         return ogz.is_open();
 226                 }
 227
 228                 virtual inline myofstream & operator<<(const double value)
 229                 {
 230                         ogz << value;
 231                         return *this;
 232                 }
 233                 virtual inline myofstream & operator<<(const char * value)
 234                 {
 235                         ogz << value;
 236                         return *this;
 237                 }
 238                 virtual inline myofstream & operator<<(const int value)
 239                 {
 240                         ogz << value;
 241                         return *this;
 242                 }
 243                 virtual inline myofstream & operator<<(const int* value)
 244                 {
 245                         ogz << value;
 246                         return *this;
 247                 }
 248                 virtual inline myofstream & operator<<(const unsigned int value)
 249                 {
 250                         ogz << value;
 251                         return *this;
 252                 }
 253                 virtual inline myofstream & operator<<(const char value)
 254                 {
 255                         ogz << value;
 256                         return *this;
 257                 }
 258                 virtual inline myofstream & operator<<(const unsigned char value)
 259                 {
 260                         ogz << value;
 261                         return *this;
 262                 }
 263                 virtual inline myofstream & operator<<(const std::string & value)
 264                 {
 265                         ogz << value;
 266                         return *this;
 267                 }
 268                 virtual inline myofstream & operator<<(const float value)
 269                 {
 270                         ogz << value;
 271                         return *this;
 272                 }
 273                 virtual inline int set_f(std::ios_base::fmtflags value)
 274                 {
 275                         return ogz.setf(value);
 276                 }
 277                 /*virtual inline myofstream & operator<<(const std::ios& value)
 278                 {
 279                         ogz << value;
 280                         return *this;
 281                 }*/
 282                 /*virtual myofstream& operator<< (std::ostream& (__cdecl *fun)(ostream& value))
 283                 {
 284                         (*fun)(*this);
 285                         return *this;
 286                 }*/
 287
 288 };
 289
 290 /**
 291  * a class to use ogzstream.
 292  *
 293  */
 294 class myogzstream : public myfstream
 295 {
 296         private:
 297                 ogzstream ogz;
 298         public:
 299                 myogzstream() : ogz(){}
 300                 myogzstream(const char * name, int mode = std::ios::out)
 301                        :ogz(name, mode){}
 302                 virtual inline void open( const char* name, int open_mode = std::ios::out)
 303                 {
 304                         ogz.open(name, open_mode);
 305                 }
 306                 virtual inline void close()
 307                 {
 308                         ogz.close();
 309                 }
 310                 virtual inline bool good()
 311                 {
 312                         return ogz.good();
 313                 }
 314                 virtual inline void write(const char* name, int streamsizecount)
 315                 {
 316                         ogz.write(name,streamsizecount);
 317                 }
 318                 virtual inline void clear()
 319                 {
 320                         ogz.clear();
 321                 }
 322                 virtual std::ostream& flush()
 323                 {
 324                         return ogz.flush();
 325                 }
 326                 virtual std::ostream& endl()
 327                 {
 328                         ogz<<"\n";
 329                         return ogz.flush();
 330                 }
 331                 virtual inline int is_open()
 332                 {
 333                         return ogz.is_open();
 334                 }
 335
 336                 virtual inline myogzstream & operator<<(const double value)
 337                 {
 338                         ogz << value;
 339                         return *this;
 340                 }
 341                 virtual inline myogzstream & operator<<(const char * value)
 342                 {
 343                         ogz << value;
 344                         return *this;
 345                 }
 346                 virtual inline myogzstream & operator<<(const int value)
 347                 {
 348                         ogz << value;
 349                         return *this;
 350                 }
 351                 virtual inline myogzstream & operator<<(const int* value)
 352                 {
 353                         ogz << value;
 354                         return *this;
 355                 }
 356                 virtual inline myogzstream & operator<<(const unsigned int value)
 357                 {
 358                         ogz << value;
 359                         return *this;
 360                 }
 361                 virtual inline myogzstream & operator<<(const char value)
 362                 {
 363                         ogz << value;
 364                         return *this;
 365                 }
 366                 virtual inline myogzstream & operator<<(const unsigned char value)
 367                 {
 368                         ogz << value;
 369                         return *this;
 370                 }
 371                 virtual inline myogzstream & operator<<(const std::string & value)
 372                 {
 373                         ogz << value;
 374                         return *this;
 375                 }
 376                 virtual inline myogzstream & operator<<(const float value)
 377                 {
 378                         ogz << value;
 379                         return *this;
 380                 }
 381                 virtual inline int set_f(std::ios_base::fmtflags value)
 382                 {
 383                         return ogz.setf(value);
 384                 }
 385                 /*virtual inline myogzstream & operator<<(const std::ios& value)
 386                 {
 387                         ogz << value;
 388                         return *this;
 389                 }*/
 390                 /*virtual myogzstream& operator<< (std::ostream& (__cdecl *fun)(ostream& value))
 391                 {
 392                         (*fun)(*this);
 393                         return *this;
 394                 }*/
 395 };
 396
 397 #ifdef GZSTREAM_NAMESPACE
 398 } // namespace GZSTREAM_NAMESPACE
 399 #endif
 400
 401 #endif // GZSTREAM_H
 402 // ============================================================================
 403 // EOF //
 404
 405