Mercurial > octave
view libinterp/corefcn/zfstream.h @ 21213:f7d1050b9b53
maint: Clean up various usages of #ifdef.
* randmtzig.c: Use #ifdef rather than just #if.
* EditControl.h : Use '#if ! defined' rather than '#ifndef' in
guard block to match Octave style.
* dialog.cc, settings-dialog.cc: Add FIXME notes about questionable use of #if
mechanism.
* file-editor-tab.cc, Array-b.cc, Array-ch.cc, Array-d.cc, Array-f.cc,
Array-i.cc, Array-s.cc, MatrixType.h, quit.h, lo-sysdep.cc, lo-cutils.c,
oct-alloc.h, oct-shlib.cc, sparse-sort.h: #define HAVE_XXX macros to 1, not
just empty but defined.
* octave-txt-lexer.h, octave-cmd.h, octave-preserve-stream-state.h, txt-eng.h,
zfstream.h, oct-conf-features.h, oct-conf.h: Use octave_ namespace prefix on
name of #define used to prevent multiple inclusion of headers.
* parser.h, webinfo.h, ov-oncleanup.h, op-int.h, display-available.h,
shared-fcns.h: Add #define guard to prevent multiple inclusion.
* quadcc.cc: use all capitals for #define MIN_CQUAD_HEAPSIZE.
* ov-intx.h: Add note that this file must not use guard #define.
* eigs-base.h, randmtzig.h: Write '! defined' rather than '!defined'.
* file-ops.cc, oct-sparse.h: Use parentheses around complex #if tests.
* oct-syscalls.cc, oct-base64.cc, statdefs.h: Indent #ifdef blocks correctly.
* oct-conf-post.in.h: Use "! defined". Define macros to 1, not just empty but
defined.
author | Rik <rik@octave.org> |
---|---|
date | Sat, 06 Feb 2016 18:22:32 -0800 |
parents | 538b57866b90 |
children | 1473547f50f5 |
line wrap: on
line source
/* Copyright (C) 2005-2015 Ludwig Schwardt, Kevin Ruland This file is part of Octave. Octave is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version. Octave is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with Octave; see the file COPYING. If not, see <http://www.gnu.org/licenses/>. */ /* This file is adapted from the zlib 1.2.2 contrib/iostream3 code, written by Ludwig Schwardt <schwardt@sun.ac.za> original version by Kevin Ruland <kevin@rodin.wustl.edu> */ #if ! defined (octave_zfsstream_h) #define octave_zfsstream_h 1 #ifdef HAVE_ZLIB #include <iosfwd> #include "zlib.h" /** * @brief Gzipped file stream buffer class. * * This class implements basic_filebuf for gzipped files. It doesn't yet * support seeking (allowed by zlib but slow/limited), putback and read/write * access * (tricky). Otherwise, it attempts to be a drop-in replacement for * the standard file streambuf. */ class gzfilebuf : public std::streambuf { public: // Default constructor. gzfilebuf (); // Destructor. virtual ~gzfilebuf (); /** * @brief Set compression level and strategy on the fly. * @param comp_level Compression level (see zlib.h for allowed values) * @param comp_strategy Compression strategy (see zlib.h for allowed values) * @return Z_OK on success, Z_STREAM_ERROR otherwise. * * Unfortunately, these parameters cannot be modified separately, as the * previous zfstream version assumed. Since the strategy is seldom changed, * it can default and setcompression(level) then becomes like the old * setcompressionlevel(level). */ int setcompression (int comp_level, int comp_strategy = Z_DEFAULT_STRATEGY); /** * @brief Check if file is open. * @return True if file is open. */ bool is_open () const { return (file != 0); } /** * @brief Open gzipped file. * @param name Filename. * @param mode Open mode flags. * @return @c this on success, NULL on failure. */ gzfilebuf* open (const char* name, std::ios_base::openmode mode); /** * @brief Attach to already open gzipped file. * @param fd File descriptor. * @param mode Open mode flags. * @return @c this on success, NULL on failure. */ gzfilebuf* attach (int fd, std::ios_base::openmode mode); /** * @brief Close gzipped file. * @return @c this on success, NULL on failure. */ gzfilebuf* close (); protected: /** * @brief Convert ios open mode int to mode string used by zlib. * @return True if valid mode flag combination. */ bool open_mode (std::ios_base::openmode mode, char* c_mode) const; /** * @brief Number of characters available in stream buffer. * @return Number of characters. * * This indicates number of characters in get area of stream buffer. * These characters can be read without accessing the gzipped file. */ virtual std::streamsize showmanyc (); /** * @brief Fill get area from gzipped file. * @return First character in get area on success, EOF on error. * * This actually reads characters from gzipped file to stream * buffer. Always buffered. */ virtual int_type underflow (); /** * @brief Write put area to gzipped file. * @param c Extra character to add to buffer contents. * @return Non-EOF on success, EOF on error. * * This actually writes characters in stream buffer to * gzipped file. With unbuffered output this is done one * character at a time. */ virtual int_type overflow (int_type c = traits_type::eof ()); /** * @brief Installs external stream buffer. * @param p Pointer to char buffer. * @param n Size of external buffer. * @return @c this on success, NULL on failure. * * Call setbuf(0,0) to enable unbuffered output. */ virtual std::streambuf* setbuf (char_type* p, std::streamsize n); /** * @brief Flush stream buffer to file. * @return 0 on success, -1 on error. * * This calls underflow(EOF) to do the job. */ virtual int sync (); /** * @brief Alters the stream positions. * * Each derived class provides its own appropriate behavior. */ virtual pos_type seekoff (off_type off, std::ios_base::seekdir way, std::ios_base::openmode mode = std::ios_base::in|std::ios_base::out); /** * @brief Alters the stream positions. * * Each derived class provides its own appropriate behavior. */ virtual pos_type seekpos (pos_type sp, std::ios_base::openmode mode = std::ios_base::in|std::ios_base::out); virtual int_type pbackfail (int_type c = traits_type::eof ()); // // Some future enhancements // // virtual int_type uflow(); // virtual int_type pbackfail(int_type c = traits_type::eof()); private: // No copying! gzfilebuf (const gzfilebuf&); gzfilebuf& operator = (const gzfilebuf&); /** * @brief Allocate internal buffer. * * This function is safe to call multiple times. It will ensure * that a proper internal buffer exists if it is required. If the * buffer already exists or is external, the buffer pointers will be * reset to their original state. */ void enable_buffer (); /** * @brief Destroy internal buffer. * * This function is safe to call multiple times. It will ensure * that the internal buffer is deallocated if it exists. In any * case, it will also reset the buffer pointers. */ void disable_buffer (); /** * Underlying file pointer. */ gzFile file; /** * Mode in which file was opened. */ std::ios_base::openmode io_mode; /** * @brief True if this object owns file descriptor. * * This makes the class responsible for closing the file * upon destruction. */ bool own_fd; /** * @brief Stream buffer. * * For simplicity this remains allocated on the free store for the * entire life span of the gzfilebuf object, unless replaced by setbuf. */ char_type* buffer; /** * @brief Stream buffer size. * * Defaults to system default buffer size (typically 8192 bytes). * Modified by setbuf. */ std::streamsize buffer_size; /** * @brief True if this object owns stream buffer. * * This makes the class responsible for deleting the buffer * upon destruction. */ bool own_buffer; }; /** * @brief Gzipped file input stream class. * * This class implements ifstream for gzipped files. Seeking and putback * is not supported yet. */ class gzifstream : public std::istream { public: // Default constructor gzifstream (); /** * @brief Construct stream on gzipped file to be opened. * @param name Filename. * @param mode Open mode flags (forced to contain ios::in). */ explicit gzifstream (const char* name, std::ios_base::openmode mode = std::ios_base::in); /** * @brief Construct stream on already open gzipped file. * @param fd File descriptor. * @param mode Open mode flags (forced to contain ios::in). */ explicit gzifstream (int fd, std::ios_base::openmode mode = std::ios_base::in); /** * Obtain underlying stream buffer. */ gzfilebuf* rdbuf () const { return const_cast<gzfilebuf*>(&sb); } /** * @brief Check if file is open. * @return True if file is open. */ bool is_open () { return sb.is_open (); } /** * @brief Open gzipped file. * @param name Filename. * @param mode Open mode flags (forced to contain ios::in). * * Stream will be in state good() if file opens successfully; * otherwise in state fail(). This differs from the behavior of * ifstream, which never sets the state to good() and therefore * won't allow you to reuse the stream for a second file unless * you manually clear() the state. The choice is a matter of * convenience. */ void open (const char* name, std::ios_base::openmode mode = std::ios_base::in); /** * @brief Attach to already open gzipped file. * @param fd File descriptor. * @param mode Open mode flags (forced to contain ios::in). * * Stream will be in state good() if attach succeeded; otherwise * in state fail(). */ void attach (int fd, std::ios_base::openmode mode = std::ios_base::in); /** * @brief Close gzipped file. * * Stream will be in state fail() if close failed. */ void close (); private: /** * Underlying stream buffer. */ gzfilebuf sb; }; /** * @brief Gzipped file output stream class. * * This class implements ofstream for gzipped files. Seeking and putback * is not supported yet. */ class gzofstream : public std::ostream { public: // Default constructor gzofstream (); /** * @brief Construct stream on gzipped file to be opened. * @param name Filename. * @param mode Open mode flags (forced to contain ios::out). */ explicit gzofstream (const char* name, std::ios_base::openmode mode = std::ios_base::out); /** * @brief Construct stream on already open gzipped file. * @param fd File descriptor. * @param mode Open mode flags (forced to contain ios::out). */ explicit gzofstream (int fd, std::ios_base::openmode mode = std::ios_base::out); /** * Obtain underlying stream buffer. */ gzfilebuf* rdbuf () const { return const_cast<gzfilebuf*>(&sb); } /** * @brief Check if file is open. * @return True if file is open. */ bool is_open () { return sb.is_open (); } /** * @brief Open gzipped file. * @param name Filename. * @param mode Open mode flags (forced to contain ios::out). * * Stream will be in state good() if file opens successfully; * otherwise in state fail(). This differs from the behavior of * ofstream, which never sets the state to good() and therefore * won't allow you to reuse the stream for a second file unless * you manually clear() the state. The choice is a matter of * convenience. */ void open (const char* name, std::ios_base::openmode mode = std::ios_base::out); /** * @brief Attach to already open gzipped file. * @param fd File descriptor. * @param mode Open mode flags (forced to contain ios::out). * * Stream will be in state good() if attach succeeded; otherwise * in state fail(). */ void attach (int fd, std::ios_base::openmode mode = std::ios_base::out); /** * @brief Close gzipped file. * * Stream will be in state fail() if close failed. */ void close (); private: /** * Underlying stream buffer. */ gzfilebuf sb; }; /** * @brief Gzipped file output stream manipulator class. * * This class defines a two-argument manipulator for gzofstream. It is used * as base for the setcompression(int,int) manipulator. */ template <typename T1, typename T2> class gzomanip2 { public: // Allows insertor to peek at internals template <typename Ta, typename Tb> friend gzofstream& operator<<(gzofstream&, const gzomanip2<Ta,Tb>&); // Constructor gzomanip2 (gzofstream& (*f)(gzofstream&, T1, T2), T1 v1, T2 v2); private: // Underlying manipulator function gzofstream& (*func)(gzofstream&, T1, T2); // Arguments for manipulator function T1 val1; T2 val2; }; // Manipulator function thunks through to stream buffer inline gzofstream& setcompression (gzofstream &gzs, int l, int s = Z_DEFAULT_STRATEGY) { (gzs.rdbuf ())->setcompression (l, s); return gzs; } // Manipulator constructor stores arguments template <typename T1, typename T2> inline gzomanip2<T1,T2>::gzomanip2 (gzofstream &(*f)(gzofstream &, T1, T2), T1 v1, T2 v2) : func(f), val1(v1), val2(v2) { } // Insertor applies underlying manipulator function to stream template <typename T1, typename T2> inline gzofstream& operator<<(gzofstream& s, const gzomanip2<T1,T2>& m) { return (*m.func)(s, m.val1, m.val2); } // Insert this onto stream to simplify setting of compression level inline gzomanip2<int,int> setcompression (int l, int s = Z_DEFAULT_STRATEGY) { return gzomanip2<int,int>(&setcompression, l, s); } #endif #endif