Mercurial > octave-libtiff
view libinterp/corefcn/c-file-ptr-stream.h @ 31185:a1145ac2ce9b
Tiff: populated TagID from the C++ map to avoid having two copies
* __tiff__.cc (F__tiff_make_tagid__): implemented internal function as
initializer for TagID.
* Tiff.m: changed the initialization for TagID to use the internal function.
author | magedrifaat <magedrifaat@gmail.com> |
---|---|
date | Thu, 18 Aug 2022 17:23:43 +0200 |
parents | 796f54d4ddbf |
children |
line wrap: on
line source
//////////////////////////////////////////////////////////////////////// // // Copyright (C) 2000-2022 The Octave Project Developers // // See the file COPYRIGHT.md in the top-level directory of this // distribution or <https://octave.org/copyright/>. // // 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 // <https://www.gnu.org/licenses/>. // //////////////////////////////////////////////////////////////////////// #if ! defined (octave_c_file_ptr_stream_h) #define octave_c_file_ptr_stream_h 1 #include "octave-config.h" #include <cstdio> #include <istream> #if defined (HAVE_ZLIB_H) # include <zlib.h> #endif OCTAVE_NAMESPACE_BEGIN class c_file_ptr_buf : public std::streambuf { public: typedef std::streambuf::int_type int_type; typedef int (*close_fcn) (FILE *); FILE *stdiofile (void) { return m_f; } c_file_ptr_buf (FILE *f, close_fcn cf = file_close) : std::streambuf (), m_f (f), m_cf (cf) { } // No copying! c_file_ptr_buf (const c_file_ptr_buf&) = delete; c_file_ptr_buf& operator = (const c_file_ptr_buf&) = delete; ~c_file_ptr_buf (void); int_type overflow (int_type); int_type underflow (void) { return underflow_common (false); } int_type uflow (void) { return underflow_common (true); } int_type pbackfail (int_type); std::streamsize xsputn (const char *, std::streamsize); std::streamsize xsgetn (char *, std::streamsize); std::streampos seekoff (std::streamoff, std::ios::seekdir, std::ios::openmode = std::ios::in | std::ios::out); std::streampos seekpos (std::streampos, std::ios::openmode = std::ios::in | std::ios::out); int sync (void); int flush (void); int buf_close (void); int file_number () const { return m_f ? fileno (m_f) : -1; } int seek (off_t offset, int origin); off_t tell (void); void clear (void) { if (m_f) clearerr (m_f); } static int file_close (FILE *m_f); protected: FILE *m_f; close_fcn m_cf; private: int_type underflow_common (bool); }; // FIXME: the following three classes could probably share some code... template <typename STREAM_T, typename FILE_T, typename BUF_T> class c_file_ptr_stream : public STREAM_T { public: c_file_ptr_stream (FILE_T m_f, typename BUF_T::close_fcn m_cf = BUF_T::file_close) : STREAM_T (nullptr), m_buf (new BUF_T (m_f, m_cf)) { STREAM_T::init (m_buf); } // No copying! c_file_ptr_stream (const c_file_ptr_stream&) = delete; c_file_ptr_stream& operator = (const c_file_ptr_stream&) = delete; ~c_file_ptr_stream (void) { delete m_buf; m_buf = nullptr; } BUF_T * rdbuf (void) { return m_buf; } void stream_close (void) { if (m_buf) m_buf->buf_close (); } int seek (off_t offset, int origin) { return m_buf ? m_buf->seek (offset, origin) : -1; } off_t tell (void) { return m_buf ? m_buf->tell () : -1; } void clear (void) { if (m_buf) m_buf->clear (); STREAM_T::clear (); } private: BUF_T *m_buf; }; typedef c_file_ptr_stream<std::istream, FILE *, c_file_ptr_buf> i_c_file_ptr_stream; typedef c_file_ptr_stream<std::ostream, FILE *, c_file_ptr_buf> o_c_file_ptr_stream; typedef c_file_ptr_stream<std::iostream, FILE *, c_file_ptr_buf> io_c_file_ptr_stream; #if defined (HAVE_ZLIB) class c_zfile_ptr_buf : public std::streambuf { public: typedef std::streambuf::int_type int_type; typedef int (*close_fcn) (gzFile); gzFile stdiofile (void) { return m_f; } c_zfile_ptr_buf (gzFile f, close_fcn cf = file_close) : std::streambuf (), m_f (f), m_cf (cf) { } // No copying! c_zfile_ptr_buf (const c_zfile_ptr_buf&) = delete; c_zfile_ptr_buf& operator = (const c_zfile_ptr_buf&) = delete; ~c_zfile_ptr_buf (void); int_type overflow (int_type); int_type underflow (void) { return underflow_common (false); } int_type uflow (void) { return underflow_common (true); } int_type pbackfail (int_type); std::streamsize xsputn (const char *, std::streamsize); std::streamsize xsgetn (char *, std::streamsize); std::streampos seekoff (std::streamoff, std::ios::seekdir, std::ios::openmode = std::ios::in | std::ios::out); std::streampos seekpos (std::streampos, std::ios::openmode = std::ios::in | std::ios::out); int sync (void); int flush (void); int buf_close (void); int file_number () const { return -1; } int seek (off_t offset, int origin) { return m_f ? gzseek (m_f, offset, origin) >= 0 : -1; } off_t tell (void) { return m_f ? gztell (m_f) : -1; } void clear (void) { if (m_f) gzclearerr (m_f); } static int file_close (gzFile m_f) { return ::gzclose (m_f); } protected: gzFile m_f; close_fcn m_cf; private: int_type underflow_common (bool); }; typedef c_file_ptr_stream<std::istream, gzFile, c_zfile_ptr_buf> i_c_zfile_ptr_stream; typedef c_file_ptr_stream<std::ostream, gzFile, c_zfile_ptr_buf> o_c_zfile_ptr_stream; typedef c_file_ptr_stream<std::iostream, gzFile, c_zfile_ptr_buf> io_c_zfile_ptr_stream; #endif OCTAVE_NAMESPACE_END #if defined (OCTAVE_PROVIDE_DEPRECATED_SYMBOLS) OCTAVE_DEPRECATED (7, "use 'octave::i_c_file_ptr_stream' instead") typedef octave::i_c_file_ptr_stream i_c_file_ptr_stream; OCTAVE_DEPRECATED (7, "use 'octave::o_c_file_ptr_stream' instead") typedef octave::o_c_file_ptr_stream o_c_file_ptr_stream; OCTAVE_DEPRECATED (7, "use 'octave::io_c_file_ptr_stream' instead") typedef octave::io_c_file_ptr_stream io_c_file_ptr_stream; // FIXME: HAVE_ZLIB is not defined here because we do not (and should // not) include config.h in this header file. We need to find a way to // define this interface without exposing gzFile. Should this be a // private header that can only be used if included after config.h in an // Octave source file and not inside another header file? # if defined (HAVE_ZLIB) OCTAVE_DEPRECATED (7, "use 'octave::i_c_zfile_ptr_stream' instead") typedef octave::c_file_ptr_stream<std::istream, gzFile, octave::c_zfile_ptr_buf> i_c_zfile_ptr_stream; OCTAVE_DEPRECATED (7, "use 'octave::o_c_zfile_ptr_stream' instead") typedef octave::c_file_ptr_stream<std::ostream, gzFile, octave::c_zfile_ptr_buf> o_c_zfile_ptr_stream; OCTAVE_DEPRECATED (7, "use 'octave::io_c_zfile_ptr_stream' instead") typedef octave::c_file_ptr_stream<std::iostream, gzFile, octave::c_zfile_ptr_buf> io_c_zfile_ptr_stream; # endif #endif #endif