1 

     2 #include "zfstream.h"

     3 

     4 gzfilebuf::gzfilebuf() :

     5   file(NULL),

     6   mode(0),

     7   own_file_descriptor(0)

     8 { }

     9 

    10 gzfilebuf::~gzfilebuf() {

    11 

    12   sync();

    13   if ( own_file_descriptor )

    14     close();

    15 

    16 }

    17 

    18 gzfilebuf *gzfilebuf::open( const char *name,

    19                             int io_mode ) {

    20 

    21   if ( is_open() )

    22     return NULL;

    23 

    24   char char_mode[10];

    25   char *p = char_mode;

    26 

    27   if ( io_mode & ios::in ) {

    28     mode = ios::in;

    29     *p++ = 'r';

    30   } else if ( io_mode & ios::app ) {

    31     mode = ios::app;

    32     *p++ = 'a';

    33   } else {

    34     mode = ios::out;

    35     *p++ = 'w';

    36   }

    37 

    38   if ( io_mode & ios::binary ) {

    39     mode |= ios::binary;

    40     *p++ = 'b';

    41   }

    42 

    43   // Hard code the compression level

    44   if ( io_mode & (ios::out|ios::app )) {

    45     *p++ = '9';

    46   }

    47 

    48   // Put the end-of-string indicator

    49   *p = '\0';

    50 

    51   if ( (file = gzopen(name, char_mode)) == NULL )

    52     return NULL;

    53 

    54   own_file_descriptor = 1;

    55 

    56   return this;

    57 

    58 }

    59 

    60 gzfilebuf *gzfilebuf::attach( int file_descriptor,

    61                               int io_mode ) {

    62 

    63   if ( is_open() )

    64     return NULL;

    65 

    66   char char_mode[10];

    67   char *p = char_mode;

    68 

    69   if ( io_mode & ios::in ) {

    70     mode = ios::in;

    71     *p++ = 'r';

    72   } else if ( io_mode & ios::app ) {

    73     mode = ios::app;

    74     *p++ = 'a';

    75   } else {

    76     mode = ios::out;

    77     *p++ = 'w';

    78   }

    79 

    80   if ( io_mode & ios::binary ) {

    81     mode |= ios::binary;

    82     *p++ = 'b';

    83   }

    84 

    85   // Hard code the compression level

    86   if ( io_mode & (ios::out|ios::app )) {

    87     *p++ = '9';

    88   }

    89 

    90   // Put the end-of-string indicator

    91   *p = '\0';

    92 

    93   if ( (file = gzdopen(file_descriptor, char_mode)) == NULL )

    94     return NULL;

    95 

    96   own_file_descriptor = 0;

    97 

    98   return this;

    99 

   100 }

   101 

   102 gzfilebuf *gzfilebuf::close() {

   103 

   104   if ( is_open() ) {

   105 

   106     sync();

   107     gzclose( file );

   108     file = NULL;

   109 

   110   }

   111 

   112   return this;

   113 

   114 }

   115 

   116 int gzfilebuf::setcompressionlevel( int comp_level ) {

   117 

   118   return gzsetparams(file, comp_level, -2);

   119 

   120 }

   121 

   122 int gzfilebuf::setcompressionstrategy( int comp_strategy ) {

   123 

   124   return gzsetparams(file, -2, comp_strategy);

   125 

   126 }

   127 

   128 

   129 streampos gzfilebuf::seekoff( streamoff off, ios::seek_dir dir, int which ) {

   130 

   131   return streampos(EOF);

   132 

   133 }

   134 

   135 int gzfilebuf::underflow() {

   136 

   137   // If the file hasn't been opened for reading, error.

   138   if ( !is_open() || !(mode & ios::in) )

   139     return EOF;

   140 

   141   // if a buffer doesn't exists, allocate one.

   142   if ( !base() ) {

   143 

   144     if ( (allocate()) == EOF )

   145       return EOF;

   146     setp(0,0);

   147 

   148   } else {

   149 

   150     if ( in_avail() )

   151       return (unsigned char) *gptr();

   152 

   153     if ( out_waiting() ) {

   154       if ( flushbuf() == EOF )

   155         return EOF;

   156     }

   157 

   158   }

   159 

   160   // Attempt to fill the buffer.

   161 

   162   int result = fillbuf();

   163   if ( result == EOF ) {

   164     // disable get area

   165     setg(0,0,0);

   166     return EOF;

   167   }

   168 

   169   return (unsigned char) *gptr();

   170 

   171 }

   172 

   173 int gzfilebuf::overflow( int c ) {

   174 

   175   if ( !is_open() || !(mode & ios::out) )

   176     return EOF;

   177 

   178   if ( !base() ) {

   179     if ( allocate() == EOF )

   180       return EOF;

   181     setg(0,0,0);

   182   } else {

   183     if (in_avail()) {

   184         return EOF;

   185     }

   186     if (out_waiting()) {

   187       if (flushbuf() == EOF)

   188         return EOF;

   189     }

   190   }

   191 

   192   int bl = blen();

   193   setp( base(), base() + bl);

   194 

   195   if ( c != EOF ) {

   196 

   197     *pptr() = c;

   198     pbump(1);

   199 

   200   }

   201 

   202   return 0;

   203 

   204 }

   205 

   206 int gzfilebuf::sync() {

   207 

   208   if ( !is_open() )

   209     return EOF;

   210 

   211   if ( out_waiting() )

   212     return flushbuf();

   213 

   214   return 0;

   215 

   216 }

   217 

   218 int gzfilebuf::flushbuf() {

   219 

   220   int n;

   221   char *q;

   222 

   223   q = pbase();

   224   n = pptr() - q;

   225 

   226   if ( gzwrite( file, q, n) < n )

   227     return EOF;

   228 

   229   setp(0,0);

   230 

   231   return 0;

   232 

   233 }

   234 

   235 int gzfilebuf::fillbuf() {

   236 

   237   int required;

   238   char *p;

   239 

   240   p = base();

   241 

   242   required = blen();

   243 

   244   int t = gzread( file, p, required );

   245 

   246   if ( t <= 0) return EOF;

   247 

   248   setg( base(), base(), base()+t);

   249 

   250   return t;

   251 

   252 }

   253 

   254 gzfilestream_common::gzfilestream_common() :

   255   ios( gzfilestream_common::rdbuf() )

   256 { }

   257 

   258 gzfilestream_common::~gzfilestream_common()

   259 { }

   260 

   261 void gzfilestream_common::attach( int fd, int io_mode ) {

   262 

   263   if ( !buffer.attach( fd, io_mode) )

   264     clear( ios::failbit | ios::badbit );

   265   else

   266     clear();

   267 

   268 }

   269 

   270 void gzfilestream_common::open( const char *name, int io_mode ) {

   271 

   272   if ( !buffer.open( name, io_mode ) )

   273     clear( ios::failbit | ios::badbit );

   274   else

   275     clear();

   276 

   277 }

   278 

   279 void gzfilestream_common::close() {

   280 

   281   if ( !buffer.close() )

   282     clear( ios::failbit | ios::badbit );

   283 

   284 }

   285 

   286 gzfilebuf *gzfilestream_common::rdbuf()

   287 {

   288   return &buffer;

   289 }

   290 

   291 gzifstream::gzifstream() :

   292   ios( gzfilestream_common::rdbuf() )

   293 {

   294   clear( ios::badbit );

   295 }

   296 

   297 gzifstream::gzifstream( const char *name, int io_mode ) :

   298   ios( gzfilestream_common::rdbuf() )

   299 {

   300   gzfilestream_common::open( name, io_mode );

   301 }

   302 

   303 gzifstream::gzifstream( int fd, int io_mode ) :

   304   ios( gzfilestream_common::rdbuf() )

   305 {

   306   gzfilestream_common::attach( fd, io_mode );

   307 }

   308 

   309 gzifstream::~gzifstream() { }

   310 

   311 gzofstream::gzofstream() :

   312   ios( gzfilestream_common::rdbuf() )

   313 {

   314   clear( ios::badbit );

   315 }

   316 

   317 gzofstream::gzofstream( const char *name, int io_mode ) :

   318   ios( gzfilestream_common::rdbuf() )

   319 {

   320   gzfilestream_common::open( name, io_mode );

   321 }

   322 

   323 gzofstream::gzofstream( int fd, int io_mode ) :

   324   ios( gzfilestream_common::rdbuf() )

   325 {

   326   gzfilestream_common::attach( fd, io_mode );

   327 }

   328 

   329 gzofstream::~gzofstream() { }