Mercurial > octave-nkf
annotate libinterp/corefcn/zfstream.h @ 20654:b65888ec820e draft default tip gccjit
dmalcom gcc jit import
| author | Stefan Mahr <dac922@gmx.de> |
|---|---|
| date | Fri, 27 Feb 2015 16:59:36 +0100 |
| parents | 19755f4fc851 |
| children |
| rev | line source |
|---|---|
| 5269 | 1 /* |
| 2 | |
|
19731
4197fc428c7d
maint: Update copyright notices for 2015.
John W. Eaton <jwe@octave.org>
parents:
17787
diff
changeset
|
3 Copyright (C) 2005-2015 Ludwig Schwardt, Kevin Ruland |
| 5269 | 4 |
| 5 This file is part of Octave. | |
| 6 | |
| 7 Octave is free software; you can redistribute it and/or modify it | |
| 8 under the terms of the GNU General Public License as published by the | |
| 7016 | 9 Free Software Foundation; either version 3 of the License, or (at your |
| 10 option) any later version. | |
| 5269 | 11 |
| 12 Octave is distributed in the hope that it will be useful, but WITHOUT | |
| 13 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 15 for more details. | |
| 16 | |
| 17 You should have received a copy of the GNU General Public License | |
| 7016 | 18 along with Octave; see the file COPYING. If not, see |
| 19 <http://www.gnu.org/licenses/>. | |
| 5269 | 20 |
| 21 */ | |
| 22 | |
| 23 /* | |
| 24 | |
| 25 This file is adapted from the zlib 1.2.2 contrib/iostream3 code, | |
| 26 written by | |
| 27 | |
| 28 Ludwig Schwardt <schwardt@sun.ac.za> | |
| 29 original version by Kevin Ruland <kevin@rodin.wustl.edu> | |
| 30 | |
| 31 */ | |
| 32 | |
| 33 #ifndef ZFSTREAM_H | |
| 34 #define ZFSTREAM_H | |
| 35 | |
| 36 #ifdef HAVE_ZLIB | |
| 37 | |
|
8950
d865363208d6
include <iosfwd> instead of <iostream> in header files
John W. Eaton <jwe@octave.org>
parents:
8920
diff
changeset
|
38 #include <iosfwd> |
|
d865363208d6
include <iosfwd> instead of <iostream> in header files
John W. Eaton <jwe@octave.org>
parents:
8920
diff
changeset
|
39 |
| 5269 | 40 #include "zlib.h" |
| 41 | |
| 42 /*****************************************************************************/ | |
| 43 | |
| 44 /** | |
| 45 * @brief Gzipped file stream buffer class. | |
| 46 * | |
|
17787
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
47 * This class implements basic_filebuf for gzipped files. It doesn't yet |
|
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
48 * support seeking (allowed by zlib but slow/limited), putback and read/write |
|
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
49 * access * (tricky). Otherwise, it attempts to be a drop-in replacement for |
|
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
50 * the standard file streambuf. |
| 5269 | 51 */ |
| 52 class gzfilebuf : public std::streambuf | |
| 53 { | |
| 54 public: | |
| 55 // Default constructor. | |
|
14846
460a3c6d8bf1
maint: Use Octave coding convention for cuddled parenthis in function calls with empty argument lists.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
56 gzfilebuf (); |
| 5269 | 57 |
| 58 // Destructor. | |
| 59 virtual | |
|
14846
460a3c6d8bf1
maint: Use Octave coding convention for cuddled parenthis in function calls with empty argument lists.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
60 ~gzfilebuf (); |
| 5269 | 61 |
| 62 /** | |
| 63 * @brief Set compression level and strategy on the fly. | |
| 64 * @param comp_level Compression level (see zlib.h for allowed values) | |
| 65 * @param comp_strategy Compression strategy (see zlib.h for allowed values) | |
| 66 * @return Z_OK on success, Z_STREAM_ERROR otherwise. | |
| 67 * | |
| 68 * Unfortunately, these parameters cannot be modified separately, as the | |
| 69 * previous zfstream version assumed. Since the strategy is seldom changed, | |
| 70 * it can default and setcompression(level) then becomes like the old | |
| 71 * setcompressionlevel(level). | |
| 72 */ | |
| 73 int | |
|
14861
f7afecdd87ef
maint: Use Octave coding conventions for cuddling parentheses in src/ directory
Rik <octave@nomad.inbox5.com>
parents:
14846
diff
changeset
|
74 setcompression (int comp_level, |
|
f7afecdd87ef
maint: Use Octave coding conventions for cuddling parentheses in src/ directory
Rik <octave@nomad.inbox5.com>
parents:
14846
diff
changeset
|
75 int comp_strategy = Z_DEFAULT_STRATEGY); |
| 5269 | 76 |
| 77 /** | |
| 78 * @brief Check if file is open. | |
| 79 * @return True if file is open. | |
| 80 */ | |
| 81 bool | |
|
14846
460a3c6d8bf1
maint: Use Octave coding convention for cuddled parenthis in function calls with empty argument lists.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
82 is_open () const { return (file != 0); } |
| 5269 | 83 |
| 84 /** | |
| 85 * @brief Open gzipped file. | |
| 86 * @param name File name. | |
| 87 * @param mode Open mode flags. | |
| 88 * @return @c this on success, NULL on failure. | |
| 89 */ | |
| 90 gzfilebuf* | |
|
14861
f7afecdd87ef
maint: Use Octave coding conventions for cuddling parentheses in src/ directory
Rik <octave@nomad.inbox5.com>
parents:
14846
diff
changeset
|
91 open (const char* name, |
|
f7afecdd87ef
maint: Use Octave coding conventions for cuddling parentheses in src/ directory
Rik <octave@nomad.inbox5.com>
parents:
14846
diff
changeset
|
92 std::ios_base::openmode mode); |
| 5269 | 93 |
| 94 /** | |
| 95 * @brief Attach to already open gzipped file. | |
| 96 * @param fd File descriptor. | |
| 97 * @param mode Open mode flags. | |
| 98 * @return @c this on success, NULL on failure. | |
| 99 */ | |
| 100 gzfilebuf* | |
|
14861
f7afecdd87ef
maint: Use Octave coding conventions for cuddling parentheses in src/ directory
Rik <octave@nomad.inbox5.com>
parents:
14846
diff
changeset
|
101 attach (int fd, |
|
f7afecdd87ef
maint: Use Octave coding conventions for cuddling parentheses in src/ directory
Rik <octave@nomad.inbox5.com>
parents:
14846
diff
changeset
|
102 std::ios_base::openmode mode); |
| 5269 | 103 |
| 104 /** | |
| 105 * @brief Close gzipped file. | |
| 106 * @return @c this on success, NULL on failure. | |
| 107 */ | |
| 108 gzfilebuf* | |
|
14846
460a3c6d8bf1
maint: Use Octave coding convention for cuddled parenthis in function calls with empty argument lists.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
109 close (); |
| 5269 | 110 |
| 111 protected: | |
| 112 /** | |
| 113 * @brief Convert ios open mode int to mode string used by zlib. | |
| 114 * @return True if valid mode flag combination. | |
| 115 */ | |
| 116 bool | |
|
14861
f7afecdd87ef
maint: Use Octave coding conventions for cuddling parentheses in src/ directory
Rik <octave@nomad.inbox5.com>
parents:
14846
diff
changeset
|
117 open_mode (std::ios_base::openmode mode, |
|
f7afecdd87ef
maint: Use Octave coding conventions for cuddling parentheses in src/ directory
Rik <octave@nomad.inbox5.com>
parents:
14846
diff
changeset
|
118 char* c_mode) const; |
| 5269 | 119 |
| 120 /** | |
| 121 * @brief Number of characters available in stream buffer. | |
| 122 * @return Number of characters. | |
| 123 * | |
| 124 * This indicates number of characters in get area of stream buffer. | |
| 125 * These characters can be read without accessing the gzipped file. | |
| 126 */ | |
| 127 virtual std::streamsize | |
|
14846
460a3c6d8bf1
maint: Use Octave coding convention for cuddled parenthis in function calls with empty argument lists.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
128 showmanyc (); |
| 5269 | 129 |
| 130 /** | |
| 131 * @brief Fill get area from gzipped file. | |
| 132 * @return First character in get area on success, EOF on error. | |
| 133 * | |
| 134 * This actually reads characters from gzipped file to stream | |
| 135 * buffer. Always buffered. | |
| 136 */ | |
| 137 virtual int_type | |
|
14846
460a3c6d8bf1
maint: Use Octave coding convention for cuddled parenthis in function calls with empty argument lists.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
138 underflow (); |
| 5269 | 139 |
| 140 /** | |
| 141 * @brief Write put area to gzipped file. | |
| 142 * @param c Extra character to add to buffer contents. | |
| 143 * @return Non-EOF on success, EOF on error. | |
| 144 * | |
| 145 * This actually writes characters in stream buffer to | |
| 146 * gzipped file. With unbuffered output this is done one | |
| 147 * character at a time. | |
| 148 */ | |
| 149 virtual int_type | |
|
14861
f7afecdd87ef
maint: Use Octave coding conventions for cuddling parentheses in src/ directory
Rik <octave@nomad.inbox5.com>
parents:
14846
diff
changeset
|
150 overflow (int_type c = traits_type::eof ()); |
| 5269 | 151 |
| 152 /** | |
| 153 * @brief Installs external stream buffer. | |
| 154 * @param p Pointer to char buffer. | |
| 155 * @param n Size of external buffer. | |
| 156 * @return @c this on success, NULL on failure. | |
| 157 * | |
| 158 * Call setbuf(0,0) to enable unbuffered output. | |
| 159 */ | |
| 160 virtual std::streambuf* | |
|
14861
f7afecdd87ef
maint: Use Octave coding conventions for cuddling parentheses in src/ directory
Rik <octave@nomad.inbox5.com>
parents:
14846
diff
changeset
|
161 setbuf (char_type* p, |
|
f7afecdd87ef
maint: Use Octave coding conventions for cuddling parentheses in src/ directory
Rik <octave@nomad.inbox5.com>
parents:
14846
diff
changeset
|
162 std::streamsize n); |
| 5269 | 163 |
| 164 /** | |
| 165 * @brief Flush stream buffer to file. | |
| 166 * @return 0 on success, -1 on error. | |
| 167 * | |
| 168 * This calls underflow(EOF) to do the job. | |
| 169 */ | |
| 170 virtual int | |
|
14846
460a3c6d8bf1
maint: Use Octave coding convention for cuddled parenthis in function calls with empty argument lists.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
171 sync (); |
| 5269 | 172 |
| 173 /** | |
| 174 * @brief Alters the stream positions. | |
| 175 * | |
| 176 * Each derived class provides its own appropriate behavior. | |
| 177 */ | |
| 178 virtual pos_type | |
|
14861
f7afecdd87ef
maint: Use Octave coding conventions for cuddling parentheses in src/ directory
Rik <octave@nomad.inbox5.com>
parents:
14846
diff
changeset
|
179 seekoff (off_type off, std::ios_base::seekdir way, |
|
f7afecdd87ef
maint: Use Octave coding conventions for cuddling parentheses in src/ directory
Rik <octave@nomad.inbox5.com>
parents:
14846
diff
changeset
|
180 std::ios_base::openmode mode = |
|
19895
19755f4fc851
maint: Cleanup C++ code to follow Octave coding conventions.
Rik <rik@octave.org>
parents:
19731
diff
changeset
|
181 std::ios_base::in|std::ios_base::out); |
| 5269 | 182 |
| 183 /** | |
| 184 * @brief Alters the stream positions. | |
| 185 * | |
| 186 * Each derived class provides its own appropriate behavior. | |
| 187 */ | |
| 188 virtual pos_type | |
|
14861
f7afecdd87ef
maint: Use Octave coding conventions for cuddling parentheses in src/ directory
Rik <octave@nomad.inbox5.com>
parents:
14846
diff
changeset
|
189 seekpos (pos_type sp, std::ios_base::openmode mode = |
|
19895
19755f4fc851
maint: Cleanup C++ code to follow Octave coding conventions.
Rik <rik@octave.org>
parents:
19731
diff
changeset
|
190 std::ios_base::in|std::ios_base::out); |
| 5269 | 191 |
| 6777 | 192 virtual int_type |
|
14846
460a3c6d8bf1
maint: Use Octave coding convention for cuddled parenthis in function calls with empty argument lists.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
193 pbackfail (int_type c = traits_type::eof ()); |
| 6777 | 194 |
| 5269 | 195 // |
| 196 // Some future enhancements | |
| 197 // | |
| 198 // virtual int_type uflow(); | |
| 199 // virtual int_type pbackfail(int_type c = traits_type::eof()); | |
| 200 | |
| 201 private: | |
|
12122
f4689107dd8c
Explicitly disallow copying in some classes.
Pascal Dupuis <Pascal.Dupuis@uclouvain.be>
parents:
11586
diff
changeset
|
202 |
|
f4689107dd8c
Explicitly disallow copying in some classes.
Pascal Dupuis <Pascal.Dupuis@uclouvain.be>
parents:
11586
diff
changeset
|
203 // No copying! |
|
f4689107dd8c
Explicitly disallow copying in some classes.
Pascal Dupuis <Pascal.Dupuis@uclouvain.be>
parents:
11586
diff
changeset
|
204 |
|
f4689107dd8c
Explicitly disallow copying in some classes.
Pascal Dupuis <Pascal.Dupuis@uclouvain.be>
parents:
11586
diff
changeset
|
205 gzfilebuf (const gzfilebuf&); |
|
f4689107dd8c
Explicitly disallow copying in some classes.
Pascal Dupuis <Pascal.Dupuis@uclouvain.be>
parents:
11586
diff
changeset
|
206 |
|
f4689107dd8c
Explicitly disallow copying in some classes.
Pascal Dupuis <Pascal.Dupuis@uclouvain.be>
parents:
11586
diff
changeset
|
207 gzfilebuf& operator = (const gzfilebuf&); |
|
f4689107dd8c
Explicitly disallow copying in some classes.
Pascal Dupuis <Pascal.Dupuis@uclouvain.be>
parents:
11586
diff
changeset
|
208 |
| 5269 | 209 /** |
| 210 * @brief Allocate internal buffer. | |
| 211 * | |
| 212 * This function is safe to call multiple times. It will ensure | |
| 213 * that a proper internal buffer exists if it is required. If the | |
| 214 * buffer already exists or is external, the buffer pointers will be | |
| 215 * reset to their original state. | |
| 216 */ | |
| 217 void | |
|
14846
460a3c6d8bf1
maint: Use Octave coding convention for cuddled parenthis in function calls with empty argument lists.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
218 enable_buffer (); |
| 5269 | 219 |
| 220 /** | |
| 221 * @brief Destroy internal buffer. | |
| 222 * | |
| 223 * This function is safe to call multiple times. It will ensure | |
| 224 * that the internal buffer is deallocated if it exists. In any | |
| 225 * case, it will also reset the buffer pointers. | |
| 226 */ | |
| 227 void | |
|
14846
460a3c6d8bf1
maint: Use Octave coding convention for cuddled parenthis in function calls with empty argument lists.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
228 disable_buffer (); |
| 5269 | 229 |
| 230 /** | |
| 231 * Underlying file pointer. | |
| 232 */ | |
| 233 gzFile file; | |
| 234 | |
| 235 /** | |
| 236 * Mode in which file was opened. | |
| 237 */ | |
| 238 std::ios_base::openmode io_mode; | |
| 239 | |
| 240 /** | |
| 241 * @brief True if this object owns file descriptor. | |
| 242 * | |
| 243 * This makes the class responsible for closing the file | |
| 244 * upon destruction. | |
| 245 */ | |
| 246 bool own_fd; | |
| 247 | |
| 248 /** | |
| 249 * @brief Stream buffer. | |
| 250 * | |
| 251 * For simplicity this remains allocated on the free store for the | |
| 252 * entire life span of the gzfilebuf object, unless replaced by setbuf. | |
| 253 */ | |
| 254 char_type* buffer; | |
| 255 | |
| 256 /** | |
| 257 * @brief Stream buffer size. | |
| 258 * | |
| 259 * Defaults to system default buffer size (typically 8192 bytes). | |
| 260 * Modified by setbuf. | |
| 261 */ | |
| 262 std::streamsize buffer_size; | |
| 263 | |
| 264 /** | |
| 265 * @brief True if this object owns stream buffer. | |
| 266 * | |
| 267 * This makes the class responsible for deleting the buffer | |
| 268 * upon destruction. | |
| 269 */ | |
| 270 bool own_buffer; | |
| 271 }; | |
| 272 | |
| 273 /*****************************************************************************/ | |
| 274 | |
| 275 /** | |
| 276 * @brief Gzipped file input stream class. | |
| 277 * | |
| 278 * This class implements ifstream for gzipped files. Seeking and putback | |
| 279 * is not supported yet. | |
| 280 */ | |
| 281 class gzifstream : public std::istream | |
| 282 { | |
| 283 public: | |
| 284 // Default constructor | |
|
14846
460a3c6d8bf1
maint: Use Octave coding convention for cuddled parenthis in function calls with empty argument lists.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
285 gzifstream (); |
| 5269 | 286 |
| 287 /** | |
| 288 * @brief Construct stream on gzipped file to be opened. | |
| 289 * @param name File name. | |
| 290 * @param mode Open mode flags (forced to contain ios::in). | |
| 291 */ | |
| 292 explicit | |
|
14861
f7afecdd87ef
maint: Use Octave coding conventions for cuddling parentheses in src/ directory
Rik <octave@nomad.inbox5.com>
parents:
14846
diff
changeset
|
293 gzifstream (const char* name, |
|
f7afecdd87ef
maint: Use Octave coding conventions for cuddling parentheses in src/ directory
Rik <octave@nomad.inbox5.com>
parents:
14846
diff
changeset
|
294 std::ios_base::openmode mode = std::ios_base::in); |
| 5269 | 295 |
| 296 /** | |
| 297 * @brief Construct stream on already open gzipped file. | |
| 298 * @param fd File descriptor. | |
| 299 * @param mode Open mode flags (forced to contain ios::in). | |
| 300 */ | |
| 301 explicit | |
|
14861
f7afecdd87ef
maint: Use Octave coding conventions for cuddling parentheses in src/ directory
Rik <octave@nomad.inbox5.com>
parents:
14846
diff
changeset
|
302 gzifstream (int fd, |
|
f7afecdd87ef
maint: Use Octave coding conventions for cuddling parentheses in src/ directory
Rik <octave@nomad.inbox5.com>
parents:
14846
diff
changeset
|
303 std::ios_base::openmode mode = std::ios_base::in); |
| 5269 | 304 |
| 305 /** | |
| 306 * Obtain underlying stream buffer. | |
| 307 */ | |
| 308 gzfilebuf* | |
|
14846
460a3c6d8bf1
maint: Use Octave coding convention for cuddled parenthis in function calls with empty argument lists.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
309 rdbuf () const |
| 5269 | 310 { return const_cast<gzfilebuf*>(&sb); } |
| 311 | |
| 312 /** | |
| 313 * @brief Check if file is open. | |
| 314 * @return True if file is open. | |
| 315 */ | |
| 316 bool | |
|
14846
460a3c6d8bf1
maint: Use Octave coding convention for cuddled parenthis in function calls with empty argument lists.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
317 is_open () { return sb.is_open (); } |
| 5269 | 318 |
| 319 /** | |
| 320 * @brief Open gzipped file. | |
| 321 * @param name File name. | |
| 322 * @param mode Open mode flags (forced to contain ios::in). | |
| 323 * | |
| 324 * Stream will be in state good() if file opens successfully; | |
| 325 * otherwise in state fail(). This differs from the behavior of | |
| 326 * ifstream, which never sets the state to good() and therefore | |
| 327 * won't allow you to reuse the stream for a second file unless | |
| 328 * you manually clear() the state. The choice is a matter of | |
| 329 * convenience. | |
| 330 */ | |
| 331 void | |
|
14861
f7afecdd87ef
maint: Use Octave coding conventions for cuddling parentheses in src/ directory
Rik <octave@nomad.inbox5.com>
parents:
14846
diff
changeset
|
332 open (const char* name, |
|
f7afecdd87ef
maint: Use Octave coding conventions for cuddling parentheses in src/ directory
Rik <octave@nomad.inbox5.com>
parents:
14846
diff
changeset
|
333 std::ios_base::openmode mode = std::ios_base::in); |
| 5269 | 334 |
| 335 /** | |
| 336 * @brief Attach to already open gzipped file. | |
| 337 * @param fd File descriptor. | |
| 338 * @param mode Open mode flags (forced to contain ios::in). | |
| 339 * | |
| 340 * Stream will be in state good() if attach succeeded; otherwise | |
| 341 * in state fail(). | |
| 342 */ | |
| 343 void | |
|
14861
f7afecdd87ef
maint: Use Octave coding conventions for cuddling parentheses in src/ directory
Rik <octave@nomad.inbox5.com>
parents:
14846
diff
changeset
|
344 attach (int fd, |
|
f7afecdd87ef
maint: Use Octave coding conventions for cuddling parentheses in src/ directory
Rik <octave@nomad.inbox5.com>
parents:
14846
diff
changeset
|
345 std::ios_base::openmode mode = std::ios_base::in); |
| 5269 | 346 |
| 347 /** | |
| 348 * @brief Close gzipped file. | |
| 349 * | |
| 350 * Stream will be in state fail() if close failed. | |
| 351 */ | |
| 352 void | |
|
14846
460a3c6d8bf1
maint: Use Octave coding convention for cuddled parenthis in function calls with empty argument lists.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
353 close (); |
| 5269 | 354 |
| 355 private: | |
| 356 /** | |
| 357 * Underlying stream buffer. | |
| 358 */ | |
| 359 gzfilebuf sb; | |
| 360 }; | |
| 361 | |
| 362 /*****************************************************************************/ | |
| 363 | |
| 364 /** | |
| 365 * @brief Gzipped file output stream class. | |
| 366 * | |
| 367 * This class implements ofstream for gzipped files. Seeking and putback | |
| 368 * is not supported yet. | |
| 369 */ | |
| 370 class gzofstream : public std::ostream | |
| 371 { | |
| 372 public: | |
| 373 // Default constructor | |
|
14846
460a3c6d8bf1
maint: Use Octave coding convention for cuddled parenthis in function calls with empty argument lists.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
374 gzofstream (); |
| 5269 | 375 |
| 376 /** | |
| 377 * @brief Construct stream on gzipped file to be opened. | |
| 378 * @param name File name. | |
| 379 * @param mode Open mode flags (forced to contain ios::out). | |
| 380 */ | |
| 381 explicit | |
|
14861
f7afecdd87ef
maint: Use Octave coding conventions for cuddling parentheses in src/ directory
Rik <octave@nomad.inbox5.com>
parents:
14846
diff
changeset
|
382 gzofstream (const char* name, |
|
f7afecdd87ef
maint: Use Octave coding conventions for cuddling parentheses in src/ directory
Rik <octave@nomad.inbox5.com>
parents:
14846
diff
changeset
|
383 std::ios_base::openmode mode = std::ios_base::out); |
| 5269 | 384 |
| 385 /** | |
| 386 * @brief Construct stream on already open gzipped file. | |
| 387 * @param fd File descriptor. | |
| 388 * @param mode Open mode flags (forced to contain ios::out). | |
| 389 */ | |
| 390 explicit | |
|
14861
f7afecdd87ef
maint: Use Octave coding conventions for cuddling parentheses in src/ directory
Rik <octave@nomad.inbox5.com>
parents:
14846
diff
changeset
|
391 gzofstream (int fd, |
|
f7afecdd87ef
maint: Use Octave coding conventions for cuddling parentheses in src/ directory
Rik <octave@nomad.inbox5.com>
parents:
14846
diff
changeset
|
392 std::ios_base::openmode mode = std::ios_base::out); |
| 5269 | 393 |
| 394 /** | |
| 395 * Obtain underlying stream buffer. | |
| 396 */ | |
| 397 gzfilebuf* | |
|
14846
460a3c6d8bf1
maint: Use Octave coding convention for cuddled parenthis in function calls with empty argument lists.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
398 rdbuf () const |
| 5269 | 399 { return const_cast<gzfilebuf*>(&sb); } |
| 400 | |
| 401 /** | |
| 402 * @brief Check if file is open. | |
| 403 * @return True if file is open. | |
| 404 */ | |
| 405 bool | |
|
14846
460a3c6d8bf1
maint: Use Octave coding convention for cuddled parenthis in function calls with empty argument lists.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
406 is_open () { return sb.is_open (); } |
| 5269 | 407 |
| 408 /** | |
| 409 * @brief Open gzipped file. | |
| 410 * @param name File name. | |
| 411 * @param mode Open mode flags (forced to contain ios::out). | |
| 412 * | |
| 413 * Stream will be in state good() if file opens successfully; | |
| 414 * otherwise in state fail(). This differs from the behavior of | |
| 415 * ofstream, which never sets the state to good() and therefore | |
| 416 * won't allow you to reuse the stream for a second file unless | |
| 417 * you manually clear() the state. The choice is a matter of | |
| 418 * convenience. | |
| 419 */ | |
| 420 void | |
|
14861
f7afecdd87ef
maint: Use Octave coding conventions for cuddling parentheses in src/ directory
Rik <octave@nomad.inbox5.com>
parents:
14846
diff
changeset
|
421 open (const char* name, |
|
f7afecdd87ef
maint: Use Octave coding conventions for cuddling parentheses in src/ directory
Rik <octave@nomad.inbox5.com>
parents:
14846
diff
changeset
|
422 std::ios_base::openmode mode = std::ios_base::out); |
| 5269 | 423 |
| 424 /** | |
| 425 * @brief Attach to already open gzipped file. | |
| 426 * @param fd File descriptor. | |
| 427 * @param mode Open mode flags (forced to contain ios::out). | |
| 428 * | |
| 429 * Stream will be in state good() if attach succeeded; otherwise | |
| 430 * in state fail(). | |
| 431 */ | |
| 432 void | |
|
14861
f7afecdd87ef
maint: Use Octave coding conventions for cuddling parentheses in src/ directory
Rik <octave@nomad.inbox5.com>
parents:
14846
diff
changeset
|
433 attach (int fd, |
|
f7afecdd87ef
maint: Use Octave coding conventions for cuddling parentheses in src/ directory
Rik <octave@nomad.inbox5.com>
parents:
14846
diff
changeset
|
434 std::ios_base::openmode mode = std::ios_base::out); |
| 5269 | 435 |
| 436 /** | |
| 437 * @brief Close gzipped file. | |
| 438 * | |
| 439 * Stream will be in state fail() if close failed. | |
| 440 */ | |
| 441 void | |
|
14846
460a3c6d8bf1
maint: Use Octave coding convention for cuddled parenthis in function calls with empty argument lists.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
442 close (); |
| 5269 | 443 |
| 444 private: | |
| 445 /** | |
| 446 * Underlying stream buffer. | |
| 447 */ | |
| 448 gzfilebuf sb; | |
| 449 }; | |
| 450 | |
| 451 /*****************************************************************************/ | |
| 452 | |
| 453 /** | |
| 454 * @brief Gzipped file output stream manipulator class. | |
| 455 * | |
| 456 * This class defines a two-argument manipulator for gzofstream. It is used | |
| 457 * as base for the setcompression(int,int) manipulator. | |
| 458 */ | |
| 459 template<typename T1, typename T2> | |
|
17787
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
460 class gzomanip2 |
|
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
461 { |
|
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
462 public: |
|
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
463 // Allows insertor to peek at internals |
|
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
464 template <typename Ta, typename Tb> |
|
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
465 friend gzofstream& |
|
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
466 operator<<(gzofstream&, |
|
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
467 const gzomanip2<Ta,Tb>&); |
| 5269 | 468 |
|
17787
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
469 // Constructor |
|
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
470 gzomanip2 (gzofstream& (*f)(gzofstream&, T1, T2), |
|
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
471 T1 v1, |
|
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
472 T2 v2); |
|
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
473 private: |
|
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
474 // Underlying manipulator function |
|
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
475 gzofstream& |
|
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
476 (*func)(gzofstream&, T1, T2); |
| 5269 | 477 |
|
17787
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
478 // Arguments for manipulator function |
|
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
479 T1 val1; |
|
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
480 T2 val2; |
|
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
481 }; |
| 5269 | 482 |
| 483 /*****************************************************************************/ | |
| 484 | |
| 485 // Manipulator function thunks through to stream buffer | |
| 486 inline gzofstream& | |
|
14861
f7afecdd87ef
maint: Use Octave coding conventions for cuddling parentheses in src/ directory
Rik <octave@nomad.inbox5.com>
parents:
14846
diff
changeset
|
487 setcompression (gzofstream &gzs, int l, int s = Z_DEFAULT_STRATEGY) |
| 5269 | 488 { |
|
14861
f7afecdd87ef
maint: Use Octave coding conventions for cuddling parentheses in src/ directory
Rik <octave@nomad.inbox5.com>
parents:
14846
diff
changeset
|
489 (gzs.rdbuf ())->setcompression (l, s); |
| 5269 | 490 return gzs; |
| 491 } | |
| 492 | |
| 493 // Manipulator constructor stores arguments | |
| 494 template<typename T1, typename T2> | |
|
17787
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
495 inline |
|
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
496 gzomanip2<T1,T2>::gzomanip2 (gzofstream &(*f)(gzofstream &, T1, T2), |
|
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
497 T1 v1, |
|
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
498 T2 v2) |
| 5269 | 499 : func(f), val1(v1), val2(v2) |
|
17787
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
500 { } |
| 5269 | 501 |
| 502 // Insertor applies underlying manipulator function to stream | |
| 503 template<typename T1, typename T2> | |
|
17787
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
504 inline gzofstream& |
|
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
505 operator<<(gzofstream& s, const gzomanip2<T1,T2>& m) |
|
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
506 { return (*m.func)(s, m.val1, m.val2); } |
| 5269 | 507 |
| 508 // Insert this onto stream to simplify setting of compression level | |
| 509 inline gzomanip2<int,int> | |
|
14861
f7afecdd87ef
maint: Use Octave coding conventions for cuddling parentheses in src/ directory
Rik <octave@nomad.inbox5.com>
parents:
14846
diff
changeset
|
510 setcompression (int l, int s = Z_DEFAULT_STRATEGY) |
| 5269 | 511 { return gzomanip2<int,int>(&setcompression, l, s); } |
| 512 | |
| 513 #endif // HAVE_ZLIB | |
| 514 | |
| 515 #endif // ZFSTREAM_H |