PageRenderTime 66ms CodeModel.GetById 13ms app.highlight 49ms RepoModel.GetById 1ms app.codeStats 0ms

/StormLib/stormlib/zlib/contrib/iostream/zfstream.cpp

http://ghostcb.googlecode.com/
C++ | 329 lines | 216 code | 105 blank | 8 comment | 51 complexity | a73c28679044fdf0a8057c5193db8da0 MD5 | raw file
  1
  2#include "zfstream.h"
  3
  4gzfilebuf::gzfilebuf() :
  5  file(NULL),
  6  mode(0),
  7  own_file_descriptor(0)
  8{ }
  9
 10gzfilebuf::~gzfilebuf() {
 11
 12  sync();
 13  if ( own_file_descriptor )
 14    close();
 15
 16}
 17
 18gzfilebuf *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
 60gzfilebuf *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
102gzfilebuf *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
116int gzfilebuf::setcompressionlevel( int comp_level ) {
117
118  return gzsetparams(file, comp_level, -2);
119
120}
121
122int gzfilebuf::setcompressionstrategy( int comp_strategy ) {
123
124  return gzsetparams(file, -2, comp_strategy);
125
126}
127
128
129streampos gzfilebuf::seekoff( streamoff off, ios::seek_dir dir, int which ) {
130
131  return streampos(EOF);
132
133}
134
135int 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
173int 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
206int 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
218int 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
235int 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
254gzfilestream_common::gzfilestream_common() :
255  ios( gzfilestream_common::rdbuf() )
256{ }
257
258gzfilestream_common::~gzfilestream_common()
259{ }
260
261void 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
270void 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
279void gzfilestream_common::close() {
280
281  if ( !buffer.close() )
282    clear( ios::failbit | ios::badbit );
283
284}
285
286gzfilebuf *gzfilestream_common::rdbuf()
287{
288  return &buffer;
289}
290
291gzifstream::gzifstream() :
292  ios( gzfilestream_common::rdbuf() )
293{
294  clear( ios::badbit );
295}
296
297gzifstream::gzifstream( const char *name, int io_mode ) :
298  ios( gzfilestream_common::rdbuf() )
299{
300  gzfilestream_common::open( name, io_mode );
301}
302
303gzifstream::gzifstream( int fd, int io_mode ) :
304  ios( gzfilestream_common::rdbuf() )
305{
306  gzfilestream_common::attach( fd, io_mode );
307}
308
309gzifstream::~gzifstream() { }
310
311gzofstream::gzofstream() :
312  ios( gzfilestream_common::rdbuf() )
313{
314  clear( ios::badbit );
315}
316
317gzofstream::gzofstream( const char *name, int io_mode ) :
318  ios( gzfilestream_common::rdbuf() )
319{
320  gzfilestream_common::open( name, io_mode );
321}
322
323gzofstream::gzofstream( int fd, int io_mode ) :
324  ios( gzfilestream_common::rdbuf() )
325{
326  gzfilestream_common::attach( fd, io_mode );
327}
328
329gzofstream::~gzofstream() { }