|
5269
|
1 /* |
|
|
2 |
|
|
3 Copyright (C) 2005 Ludwig Schwardt, Kevin Ruland |
|
|
4 |
|
|
5 |
|
|
6 This file is part of Octave. |
|
|
7 |
|
|
8 Octave is free software; you can redistribute it and/or modify it |
|
|
9 under the terms of the GNU General Public License as published by the |
|
7016
|
10 Free Software Foundation; either version 3 of the License, or (at your |
|
|
11 option) any later version. |
|
5269
|
12 |
|
|
13 Octave is distributed in the hope that it will be useful, but WITHOUT |
|
|
14 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
|
|
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
|
|
16 for more details. |
|
|
17 |
|
|
18 You should have received a copy of the GNU General Public License |
|
7016
|
19 along with Octave; see the file COPYING. If not, see |
|
|
20 <http://www.gnu.org/licenses/>. |
|
5269
|
21 |
|
|
22 */ |
|
|
23 |
|
|
24 /* |
|
|
25 |
|
|
26 This file is adapted from the zlib 1.2.2 contrib/iostream3 code, |
|
|
27 written by |
|
|
28 |
|
|
29 Ludwig Schwardt <schwardt@sun.ac.za> |
|
|
30 original version by Kevin Ruland <kevin@rodin.wustl.edu> |
|
|
31 |
|
|
32 */ |
|
|
33 |
|
|
34 #include "zfstream.h" |
|
|
35 |
|
|
36 #ifdef HAVE_ZLIB |
|
|
37 |
|
|
38 #include <cstring> // for strcpy, strcat, strlen (mode strings) |
|
|
39 #include <cstdio> // for BUFSIZ |
|
|
40 |
|
|
41 // Internal buffer sizes (default and "unbuffered" versions) |
|
6783
|
42 #define STASHED_CHARACTERS 16 |
|
|
43 #define BIGBUFSIZE (256 * 1024 + STASHED_CHARACTERS) |
|
5269
|
44 #define SMALLBUFSIZE 1 |
|
|
45 |
|
|
46 /*****************************************************************************/ |
|
|
47 |
|
|
48 // Default constructor |
|
|
49 gzfilebuf::gzfilebuf() |
|
|
50 : file(NULL), io_mode(std::ios_base::openmode(0)), own_fd(false), |
|
|
51 buffer(NULL), buffer_size(BIGBUFSIZE), own_buffer(true) |
|
|
52 { |
|
|
53 // No buffers to start with |
|
|
54 this->disable_buffer(); |
|
|
55 } |
|
|
56 |
|
|
57 // Destructor |
|
|
58 gzfilebuf::~gzfilebuf() |
|
|
59 { |
|
|
60 // Sync output buffer and close only if responsible for file |
|
|
61 // (i.e. attached streams should be left open at this stage) |
|
|
62 this->sync(); |
|
|
63 if (own_fd) |
|
|
64 this->close(); |
|
|
65 // Make sure internal buffer is deallocated |
|
|
66 this->disable_buffer(); |
|
|
67 } |
|
|
68 |
|
|
69 // Set compression level and strategy |
|
|
70 int |
|
|
71 gzfilebuf::setcompression(int comp_level, |
|
|
72 int comp_strategy) |
|
|
73 { |
|
|
74 return gzsetparams(file, comp_level, comp_strategy); |
|
|
75 } |
|
|
76 |
|
|
77 // Open gzipped file |
|
|
78 gzfilebuf* |
|
|
79 gzfilebuf::open(const char *name, |
|
|
80 std::ios_base::openmode mode) |
|
|
81 { |
|
|
82 // Fail if file already open |
|
|
83 if (this->is_open()) |
|
|
84 return NULL; |
|
|
85 // Don't support simultaneous read/write access (yet) |
|
|
86 if ((mode & std::ios_base::in) && (mode & std::ios_base::out)) |
|
|
87 return NULL; |
|
|
88 |
|
|
89 // Build mode string for gzopen and check it [27.8.1.3.2] |
|
|
90 char char_mode[6] = "\0\0\0\0\0"; |
|
|
91 if (!this->open_mode(mode, char_mode)) |
|
|
92 return NULL; |
|
|
93 |
|
|
94 // Attempt to open file |
|
|
95 if ((file = gzopen(name, char_mode)) == NULL) |
|
|
96 return NULL; |
|
|
97 |
|
|
98 // On success, allocate internal buffer and set flags |
|
|
99 this->enable_buffer(); |
|
|
100 io_mode = mode; |
|
|
101 own_fd = true; |
|
|
102 return this; |
|
|
103 } |
|
|
104 |
|
|
105 // Attach to gzipped file |
|
|
106 gzfilebuf* |
|
|
107 gzfilebuf::attach(int fd, |
|
|
108 std::ios_base::openmode mode) |
|
|
109 { |
|
|
110 // Fail if file already open |
|
|
111 if (this->is_open()) |
|
|
112 return NULL; |
|
|
113 // Don't support simultaneous read/write access (yet) |
|
|
114 if ((mode & std::ios_base::in) && (mode & std::ios_base::out)) |
|
|
115 return NULL; |
|
|
116 |
|
|
117 // Build mode string for gzdopen and check it [27.8.1.3.2] |
|
|
118 char char_mode[6] = "\0\0\0\0\0"; |
|
|
119 if (!this->open_mode(mode, char_mode)) |
|
|
120 return NULL; |
|
|
121 |
|
|
122 // Attempt to attach to file |
|
|
123 if ((file = gzdopen(fd, char_mode)) == NULL) |
|
|
124 return NULL; |
|
|
125 |
|
|
126 // On success, allocate internal buffer and set flags |
|
|
127 this->enable_buffer(); |
|
|
128 io_mode = mode; |
|
|
129 own_fd = false; |
|
|
130 return this; |
|
|
131 } |
|
|
132 |
|
|
133 // Close gzipped file |
|
|
134 gzfilebuf* |
|
|
135 gzfilebuf::close() |
|
|
136 { |
|
|
137 // Fail immediately if no file is open |
|
|
138 if (!this->is_open()) |
|
|
139 return NULL; |
|
|
140 // Assume success |
|
|
141 gzfilebuf* retval = this; |
|
|
142 // Attempt to sync and close gzipped file |
|
|
143 if (this->sync() == -1) |
|
|
144 retval = NULL; |
|
|
145 if (gzclose(file) < 0) |
|
|
146 retval = NULL; |
|
|
147 // File is now gone anyway (postcondition [27.8.1.3.8]) |
|
|
148 file = NULL; |
|
|
149 own_fd = false; |
|
|
150 // Destroy internal buffer if it exists |
|
|
151 this->disable_buffer(); |
|
|
152 return retval; |
|
|
153 } |
|
|
154 |
|
|
155 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ |
|
|
156 |
|
|
157 // Convert int open mode to mode string |
|
|
158 bool |
|
|
159 gzfilebuf::open_mode(std::ios_base::openmode mode, |
|
|
160 char* c_mode) const |
|
|
161 { |
|
6959
|
162 // FIXME -- do we need testb? |
|
|
163 // bool testb = mode & std::ios_base::binary; |
|
5269
|
164 bool testi = mode & std::ios_base::in; |
|
|
165 bool testo = mode & std::ios_base::out; |
|
|
166 bool testt = mode & std::ios_base::trunc; |
|
|
167 bool testa = mode & std::ios_base::app; |
|
|
168 |
|
|
169 // Check for valid flag combinations - see [27.8.1.3.2] (Table 92) |
|
|
170 // Original zfstream hardcoded the compression level to maximum here... |
|
|
171 // Double the time for less than 1% size improvement seems |
|
|
172 // excessive though - keeping it at the default level |
|
|
173 // To change back, just append "9" to the next three mode strings |
|
|
174 if (!testi && testo && !testt && !testa) |
|
|
175 strcpy(c_mode, "w"); |
|
|
176 if (!testi && testo && !testt && testa) |
|
|
177 strcpy(c_mode, "a"); |
|
|
178 if (!testi && testo && testt && !testa) |
|
|
179 strcpy(c_mode, "w"); |
|
|
180 if (testi && !testo && !testt && !testa) |
|
|
181 strcpy(c_mode, "r"); |
|
|
182 // No read/write mode yet |
|
|
183 // if (testi && testo && !testt && !testa) |
|
|
184 // strcpy(c_mode, "r+"); |
|
|
185 // if (testi && testo && testt && !testa) |
|
|
186 // strcpy(c_mode, "w+"); |
|
|
187 |
|
|
188 // Mode string should be empty for invalid combination of flags |
|
|
189 if (strlen(c_mode) == 0) |
|
|
190 return false; |
|
6275
|
191 |
|
|
192 strcat(c_mode, "b"); |
|
|
193 |
|
5269
|
194 return true; |
|
|
195 } |
|
|
196 |
|
|
197 // Determine number of characters in internal get buffer |
|
|
198 std::streamsize |
|
|
199 gzfilebuf::showmanyc() |
|
|
200 { |
|
|
201 // Calls to underflow will fail if file not opened for reading |
|
|
202 if (!this->is_open() || !(io_mode & std::ios_base::in)) |
|
|
203 return -1; |
|
|
204 // Make sure get area is in use |
|
|
205 if (this->gptr() && (this->gptr() < this->egptr())) |
|
|
206 return std::streamsize(this->egptr() - this->gptr()); |
|
|
207 else |
|
|
208 return 0; |
|
|
209 } |
|
|
210 |
|
6777
|
211 // Puts back a character to the stream in two cases. Firstly, when there |
|
|
212 // is no putback position available, and secondly when the character putback |
|
|
213 // differs from the one in the file. We can only support the first case |
|
|
214 // with gzipped files. |
|
|
215 gzfilebuf::int_type |
|
|
216 gzfilebuf::pbackfail (gzfilebuf::int_type c) |
|
|
217 { |
|
|
218 if (this->is_open()) |
|
|
219 { |
|
|
220 if (gzseek (file, this->gptr() - this->egptr() - 1, SEEK_CUR) < 0) |
|
|
221 return traits_type::eof(); |
|
|
222 |
|
|
223 // Invalidates contents of the buffer |
|
|
224 enable_buffer (); |
|
|
225 |
|
|
226 // Attempt to fill internal buffer from gzipped file |
|
|
227 // (buffer must be guaranteed to exist...) |
|
|
228 int bytes_read = gzread(file, buffer, buffer_size); |
|
|
229 // Indicates error or EOF |
|
|
230 if (bytes_read <= 0) |
|
|
231 { |
|
|
232 // Reset get area |
|
|
233 this->setg(buffer, buffer, buffer); |
|
|
234 return traits_type::eof(); |
|
|
235 } |
|
|
236 |
|
|
237 // Make all bytes read from file available as get area |
|
|
238 this->setg(buffer, buffer, buffer + bytes_read); |
|
|
239 |
|
|
240 // If next character in get area differs from putback character |
|
|
241 // flag a failure |
|
|
242 gzfilebuf::int_type ret = traits_type::to_int_type(*(this->gptr())); |
|
|
243 if (ret != c) |
|
|
244 return traits_type::eof(); |
|
|
245 else |
|
|
246 return ret; |
|
|
247 } |
|
|
248 else |
|
|
249 return traits_type::eof(); |
|
|
250 } |
|
|
251 |
|
5269
|
252 // Fill get area from gzipped file |
|
|
253 gzfilebuf::int_type |
|
|
254 gzfilebuf::underflow() |
|
|
255 { |
|
|
256 // If something is left in the get area by chance, return it |
|
|
257 // (this shouldn't normally happen, as underflow is only supposed |
|
|
258 // to be called when gptr >= egptr, but it serves as error check) |
|
|
259 if (this->gptr() && (this->gptr() < this->egptr())) |
|
|
260 return traits_type::to_int_type(*(this->gptr())); |
|
|
261 |
|
|
262 // If the file hasn't been opened for reading, produce error |
|
|
263 if (!this->is_open() || !(io_mode & std::ios_base::in)) |
|
|
264 return traits_type::eof(); |
|
|
265 |
|
6783
|
266 // Copy the final characters to the front of the buffer |
|
|
267 int stash = 0; |
|
|
268 if (this->eback() && buffer && buffer_size > STASHED_CHARACTERS) |
|
|
269 { |
|
|
270 char_type *ptr1 = buffer; |
|
|
271 char_type *ptr2 = this->egptr() - STASHED_CHARACTERS + 1; |
|
|
272 if (ptr2 > this->eback()) |
|
|
273 while (stash++ <= STASHED_CHARACTERS) |
|
|
274 *ptr1++ = *ptr2++; |
|
|
275 } |
|
|
276 |
|
5269
|
277 // Attempt to fill internal buffer from gzipped file |
|
|
278 // (buffer must be guaranteed to exist...) |
|
6783
|
279 int bytes_read = gzread(file, buffer + stash, buffer_size - stash); |
|
|
280 |
|
5269
|
281 // Indicates error or EOF |
|
|
282 if (bytes_read <= 0) |
|
|
283 { |
|
|
284 // Reset get area |
|
|
285 this->setg(buffer, buffer, buffer); |
|
|
286 return traits_type::eof(); |
|
|
287 } |
|
6783
|
288 // Make all bytes read from file plus the stash available as get area |
|
|
289 this->setg(buffer, buffer + stash, buffer + bytes_read + stash); |
|
5269
|
290 |
|
|
291 // Return next character in get area |
|
|
292 return traits_type::to_int_type(*(this->gptr())); |
|
|
293 } |
|
|
294 |
|
|
295 // Write put area to gzipped file |
|
|
296 gzfilebuf::int_type |
|
|
297 gzfilebuf::overflow(int_type c) |
|
|
298 { |
|
|
299 // Determine whether put area is in use |
|
|
300 if (this->pbase()) |
|
|
301 { |
|
|
302 // Double-check pointer range |
|
|
303 if (this->pptr() > this->epptr() || this->pptr() < this->pbase()) |
|
|
304 return traits_type::eof(); |
|
|
305 // Add extra character to buffer if not EOF |
|
|
306 if (!traits_type::eq_int_type(c, traits_type::eof())) |
|
|
307 { |
|
|
308 *(this->pptr()) = traits_type::to_char_type(c); |
|
|
309 this->pbump(1); |
|
|
310 } |
|
|
311 // Number of characters to write to file |
|
|
312 int bytes_to_write = this->pptr() - this->pbase(); |
|
|
313 // Overflow doesn't fail if nothing is to be written |
|
|
314 if (bytes_to_write > 0) |
|
|
315 { |
|
|
316 // If the file hasn't been opened for writing, produce error |
|
|
317 if (!this->is_open() || !(io_mode & std::ios_base::out)) |
|
|
318 return traits_type::eof(); |
|
|
319 // If gzipped file won't accept all bytes written to it, fail |
|
|
320 if (gzwrite(file, this->pbase(), bytes_to_write) != bytes_to_write) |
|
|
321 return traits_type::eof(); |
|
|
322 // Reset next pointer to point to pbase on success |
|
|
323 this->pbump(-bytes_to_write); |
|
|
324 } |
|
|
325 } |
|
|
326 // Write extra character to file if not EOF |
|
|
327 else if (!traits_type::eq_int_type(c, traits_type::eof())) |
|
|
328 { |
|
|
329 // If the file hasn't been opened for writing, produce error |
|
|
330 if (!this->is_open() || !(io_mode & std::ios_base::out)) |
|
|
331 return traits_type::eof(); |
|
|
332 // Impromptu char buffer (allows "unbuffered" output) |
|
|
333 char_type last_char = traits_type::to_char_type(c); |
|
|
334 // If gzipped file won't accept this character, fail |
|
|
335 if (gzwrite(file, &last_char, 1) != 1) |
|
|
336 return traits_type::eof(); |
|
|
337 } |
|
|
338 |
|
|
339 // If you got here, you have succeeded (even if c was EOF) |
|
|
340 // The return value should therefore be non-EOF |
|
|
341 if (traits_type::eq_int_type(c, traits_type::eof())) |
|
|
342 return traits_type::not_eof(c); |
|
|
343 else |
|
|
344 return c; |
|
|
345 } |
|
|
346 |
|
|
347 // Assign new buffer |
|
|
348 std::streambuf* |
|
|
349 gzfilebuf::setbuf(char_type* p, |
|
|
350 std::streamsize n) |
|
|
351 { |
|
|
352 // First make sure stuff is sync'ed, for safety |
|
|
353 if (this->sync() == -1) |
|
|
354 return NULL; |
|
|
355 // If buffering is turned off on purpose via setbuf(0,0), still allocate one... |
|
|
356 // "Unbuffered" only really refers to put [27.8.1.4.10], while get needs at |
|
|
357 // least a buffer of size 1 (very inefficient though, therefore make it bigger?) |
|
|
358 // This follows from [27.5.2.4.3]/12 (gptr needs to point at something, it seems) |
|
|
359 if (!p || !n) |
|
|
360 { |
|
|
361 // Replace existing buffer (if any) with small internal buffer |
|
|
362 this->disable_buffer(); |
|
|
363 buffer = NULL; |
|
|
364 buffer_size = 0; |
|
|
365 own_buffer = true; |
|
|
366 this->enable_buffer(); |
|
|
367 } |
|
|
368 else |
|
|
369 { |
|
|
370 // Replace existing buffer (if any) with external buffer |
|
|
371 this->disable_buffer(); |
|
|
372 buffer = p; |
|
|
373 buffer_size = n; |
|
|
374 own_buffer = false; |
|
|
375 this->enable_buffer(); |
|
|
376 } |
|
|
377 return this; |
|
|
378 } |
|
|
379 |
|
|
380 // Write put area to gzipped file (i.e. ensures that put area is empty) |
|
|
381 int |
|
|
382 gzfilebuf::sync() |
|
|
383 { |
|
|
384 return traits_type::eq_int_type(this->overflow(), traits_type::eof()) ? -1 : 0; |
|
|
385 } |
|
|
386 |
|
|
387 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ |
|
|
388 |
|
|
389 // Allocate internal buffer |
|
|
390 void |
|
|
391 gzfilebuf::enable_buffer() |
|
|
392 { |
|
|
393 // If internal buffer required, allocate one |
|
|
394 if (own_buffer && !buffer) |
|
|
395 { |
|
|
396 // Check for buffered vs. "unbuffered" |
|
|
397 if (buffer_size > 0) |
|
|
398 { |
|
|
399 // Allocate internal buffer |
|
|
400 buffer = new char_type[buffer_size]; |
|
|
401 // Get area starts empty and will be expanded by underflow as need arises |
|
|
402 this->setg(buffer, buffer, buffer); |
|
|
403 // Setup entire internal buffer as put area. |
|
|
404 // The one-past-end pointer actually points to the last element of the buffer, |
|
|
405 // so that overflow(c) can safely add the extra character c to the sequence. |
|
|
406 // These pointers remain in place for the duration of the buffer |
|
|
407 this->setp(buffer, buffer + buffer_size - 1); |
|
|
408 } |
|
|
409 else |
|
|
410 { |
|
|
411 // Even in "unbuffered" case, (small?) get buffer is still required |
|
|
412 buffer_size = SMALLBUFSIZE; |
|
|
413 buffer = new char_type[buffer_size]; |
|
|
414 this->setg(buffer, buffer, buffer); |
|
|
415 // "Unbuffered" means no put buffer |
|
|
416 this->setp(0, 0); |
|
|
417 } |
|
|
418 } |
|
|
419 else |
|
|
420 { |
|
|
421 // If buffer already allocated, reset buffer pointers just to make sure no |
|
|
422 // stale chars are lying around |
|
|
423 this->setg(buffer, buffer, buffer); |
|
|
424 this->setp(buffer, buffer + buffer_size - 1); |
|
|
425 } |
|
|
426 } |
|
|
427 |
|
|
428 // Destroy internal buffer |
|
|
429 void |
|
|
430 gzfilebuf::disable_buffer() |
|
|
431 { |
|
|
432 // If internal buffer exists, deallocate it |
|
|
433 if (own_buffer && buffer) |
|
|
434 { |
|
|
435 // Preserve unbuffered status by zeroing size |
|
|
436 if (!this->pbase()) |
|
|
437 buffer_size = 0; |
|
|
438 delete[] buffer; |
|
|
439 buffer = NULL; |
|
|
440 this->setg(0, 0, 0); |
|
|
441 this->setp(0, 0); |
|
|
442 } |
|
|
443 else |
|
|
444 { |
|
|
445 // Reset buffer pointers to initial state if external buffer exists |
|
|
446 this->setg(buffer, buffer, buffer); |
|
|
447 if (buffer) |
|
|
448 this->setp(buffer, buffer + buffer_size - 1); |
|
|
449 else |
|
|
450 this->setp(0, 0); |
|
|
451 } |
|
|
452 } |
|
|
453 |
|
|
454 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ |
|
|
455 |
|
|
456 // Seek functions |
|
|
457 gzfilebuf::pos_type |
|
|
458 gzfilebuf::seekoff(off_type off, std::ios_base::seekdir way, |
|
|
459 std::ios_base::openmode) |
|
|
460 { |
|
|
461 pos_type ret = pos_type (off_type (-1)); |
|
|
462 |
|
|
463 if (this->is_open()) |
|
|
464 { |
|
|
465 off_type computed_off = off; |
|
|
466 |
|
|
467 if ((io_mode & std::ios_base::in) && way == std::ios_base::cur) |
|
|
468 computed_off += this->gptr() - this->egptr(); |
|
|
469 |
|
|
470 if (way == std::ios_base::beg) |
|
|
471 ret = pos_type (gzseek (file, computed_off, SEEK_SET)); |
|
|
472 else if (way == std::ios_base::cur) |
|
|
473 ret = pos_type (gzseek (file, computed_off, SEEK_CUR)); |
|
|
474 else |
|
|
475 // Can't seek from end of a gzipped file, so this will give -1 |
|
|
476 ret = pos_type (gzseek (file, computed_off, SEEK_END)); |
|
|
477 |
|
|
478 if (io_mode & std::ios_base::in) |
|
|
479 // Invalidates contents of the buffer |
|
|
480 enable_buffer (); |
|
|
481 else |
|
|
482 // flush contents of buffer to file |
|
|
483 overflow (); |
|
|
484 } |
|
|
485 |
|
|
486 return ret; |
|
|
487 } |
|
|
488 |
|
|
489 gzfilebuf::pos_type |
|
|
490 gzfilebuf::seekpos(pos_type sp, std::ios_base::openmode) |
|
|
491 { |
|
|
492 pos_type ret = pos_type (off_type (-1)); |
|
|
493 |
|
|
494 if (this->is_open ()) |
|
|
495 { |
|
|
496 ret = pos_type (gzseek (file, sp, SEEK_SET)); |
|
|
497 |
|
|
498 if (io_mode & std::ios_base::in) |
|
|
499 // Invalidates contents of the buffer |
|
|
500 enable_buffer (); |
|
|
501 else |
|
|
502 // flush contents of buffer to file |
|
|
503 overflow (); |
|
|
504 } |
|
|
505 |
|
|
506 return ret; |
|
|
507 } |
|
|
508 |
|
|
509 /*****************************************************************************/ |
|
|
510 |
|
|
511 // Default constructor initializes stream buffer |
|
|
512 gzifstream::gzifstream() |
|
|
513 : std::istream(NULL), sb() |
|
|
514 { this->init(&sb); } |
|
|
515 |
|
|
516 // Initialize stream buffer and open file |
|
|
517 gzifstream::gzifstream(const char* name, |
|
|
518 std::ios_base::openmode mode) |
|
|
519 : std::istream(NULL), sb() |
|
|
520 { |
|
|
521 this->init(&sb); |
|
|
522 this->open(name, mode); |
|
|
523 } |
|
|
524 |
|
|
525 // Initialize stream buffer and attach to file |
|
|
526 gzifstream::gzifstream(int fd, |
|
|
527 std::ios_base::openmode mode) |
|
|
528 : std::istream(NULL), sb() |
|
|
529 { |
|
|
530 this->init(&sb); |
|
|
531 this->attach(fd, mode); |
|
|
532 } |
|
|
533 |
|
|
534 // Open file and go into fail() state if unsuccessful |
|
|
535 void |
|
|
536 gzifstream::open(const char* name, |
|
|
537 std::ios_base::openmode mode) |
|
|
538 { |
|
|
539 if (!sb.open(name, mode | std::ios_base::in)) |
|
|
540 this->setstate(std::ios_base::failbit); |
|
|
541 else |
|
|
542 this->clear(); |
|
|
543 } |
|
|
544 |
|
|
545 // Attach to file and go into fail() state if unsuccessful |
|
|
546 void |
|
|
547 gzifstream::attach(int fd, |
|
|
548 std::ios_base::openmode mode) |
|
|
549 { |
|
|
550 if (!sb.attach(fd, mode | std::ios_base::in)) |
|
|
551 this->setstate(std::ios_base::failbit); |
|
|
552 else |
|
|
553 this->clear(); |
|
|
554 } |
|
|
555 |
|
|
556 // Close file |
|
|
557 void |
|
|
558 gzifstream::close() |
|
|
559 { |
|
|
560 if (!sb.close()) |
|
|
561 this->setstate(std::ios_base::failbit); |
|
|
562 } |
|
|
563 |
|
|
564 /*****************************************************************************/ |
|
|
565 |
|
|
566 // Default constructor initializes stream buffer |
|
|
567 gzofstream::gzofstream() |
|
|
568 : std::ostream(NULL), sb() |
|
|
569 { this->init(&sb); } |
|
|
570 |
|
|
571 // Initialize stream buffer and open file |
|
|
572 gzofstream::gzofstream(const char* name, |
|
|
573 std::ios_base::openmode mode) |
|
|
574 : std::ostream(NULL), sb() |
|
|
575 { |
|
|
576 this->init(&sb); |
|
|
577 this->open(name, mode); |
|
|
578 } |
|
|
579 |
|
|
580 // Initialize stream buffer and attach to file |
|
|
581 gzofstream::gzofstream(int fd, |
|
|
582 std::ios_base::openmode mode) |
|
|
583 : std::ostream(NULL), sb() |
|
|
584 { |
|
|
585 this->init(&sb); |
|
|
586 this->attach(fd, mode); |
|
|
587 } |
|
|
588 |
|
|
589 // Open file and go into fail() state if unsuccessful |
|
|
590 void |
|
|
591 gzofstream::open(const char* name, |
|
|
592 std::ios_base::openmode mode) |
|
|
593 { |
|
|
594 if (!sb.open(name, mode | std::ios_base::out)) |
|
|
595 this->setstate(std::ios_base::failbit); |
|
|
596 else |
|
|
597 this->clear(); |
|
|
598 } |
|
|
599 |
|
|
600 // Attach to file and go into fail() state if unsuccessful |
|
|
601 void |
|
|
602 gzofstream::attach(int fd, |
|
|
603 std::ios_base::openmode mode) |
|
|
604 { |
|
|
605 if (!sb.attach(fd, mode | std::ios_base::out)) |
|
|
606 this->setstate(std::ios_base::failbit); |
|
|
607 else |
|
|
608 this->clear(); |
|
|
609 } |
|
|
610 |
|
|
611 // Close file |
|
|
612 void |
|
|
613 gzofstream::close() |
|
|
614 { |
|
|
615 if (!sb.close()) |
|
|
616 this->setstate(std::ios_base::failbit); |
|
|
617 } |
|
|
618 |
|
|
619 #endif // HAVE_ZLIB |
|
|
620 |
|
|
621 /* |
|
|
622 ;;; Local Variables: *** |
|
|
623 ;;; mode: C++ *** |
|
|
624 ;;; End: *** |
|
|
625 */ |
