// Backward-compat support -*- C++ -*- // Copyright (C) 2001-2020 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library 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, or (at your option) // any later version. // This library 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. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // <http://www.gnu.org/licenses/>. /* * Copyright (c) 1998 * Silicon Graphics Computer Systems, Inc. * * Permission to use, copy, modify, distribute and sell this software * and its documentation for any purpose is hereby granted without fee, * provided that the above copyright notice appear in all copies and * that both that copyright notice and this permission notice appear * in supporting documentation. Silicon Graphics makes no * representations about the suitability of this software for any * purpose. It is provided "as is" without express or implied warranty. */ // WARNING: The classes defined in this header are DEPRECATED. This // header is defined in section D.7.1 of the C++ standard, and it // MAY BE REMOVED in a future standard revision. One should use the // header <sstream> instead. /** @file strstream * This is a Standard C++ Library header. */ #ifndef _BACKWARD_STRSTREAM #define _BACKWARD_STRSTREAM #include <backward/backward_warning.h> #include <iosfwd> #include <ios> #include <istream> #include <ostream> namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION // Class strstreambuf, a streambuf class that manages an array of char. // Note that this class is not a template. class strstreambuf : public basic_streambuf<char, char_traits<char> > { public: // Types. typedef char_traits<char> _Traits; typedef basic_streambuf<char, _Traits> _Base; public: // Constructor, destructor #if __cplusplus >= 201103L strstreambuf() : strstreambuf(0) { } explicit strstreambuf(streamsize __initial_capacity); #else explicit strstreambuf(streamsize __initial_capacity = 0); #endif strstreambuf(void* (*__alloc)(size_t), void (*__free)(void*)); strstreambuf(char* __get, streamsize __n, char* __put = 0) throw (); strstreambuf(signed char* __get, streamsize __n, signed char* __put = 0) throw (); strstreambuf(unsigned char* __get, streamsize __n, unsigned char* __put=0) throw (); strstreambuf(const char* __get, streamsize __n) throw (); strstreambuf(const signed char* __get, streamsize __n) throw (); strstreambuf(const unsigned char* __get, streamsize __n) throw (); virtual ~strstreambuf(); #if __cplusplus >= 201103L strstreambuf(strstreambuf&& __rhs) noexcept : _Base(__rhs), _M_alloc_fun(__rhs._M_alloc_fun), _M_free_fun(__rhs._M_free_fun), _M_dynamic(__rhs._M_dynamic), _M_frozen(__rhs._M_frozen), _M_constant(__rhs._M_constant) { __rhs.setg(nullptr, nullptr, nullptr); __rhs.setp(nullptr, nullptr); } strstreambuf& operator=(strstreambuf&& __rhs) noexcept { if (_M_dynamic && !_M_frozen) _M_free(eback()); _Base::operator=(static_cast<const _Base&>(__rhs)); _M_alloc_fun = __rhs._M_alloc_fun; _M_free_fun = __rhs._M_free_fun; _M_dynamic = __rhs._M_dynamic; _M_frozen = __rhs._M_frozen; _M_constant = __rhs._M_constant; __rhs.setg(nullptr, nullptr, nullptr); __rhs.setp(nullptr, nullptr); return *this; } #endif public: void freeze(bool = true) throw (); char* str() throw (); _GLIBCXX_PURE int pcount() const throw (); protected: virtual int_type overflow(int_type __c = _Traits::eof()); virtual int_type pbackfail(int_type __c = _Traits::eof()); virtual int_type underflow(); virtual _Base* setbuf(char* __buf, streamsize __n); virtual pos_type seekoff(off_type __off, ios_base::seekdir __dir, ios_base::openmode __mode = ios_base::in | ios_base::out); virtual pos_type seekpos(pos_type __pos, ios_base::openmode __mode = ios_base::in | ios_base::out); private: #if __cplusplus < 201103L strstreambuf& operator=(const strstreambuf&); strstreambuf(const strstreambuf&); #endif // Dynamic allocation, possibly using _M_alloc_fun and _M_free_fun. char* _M_alloc(size_t); void _M_free(char*); // Helper function used in constructors. void _M_setup(char* __get, char* __put, streamsize __n) throw (); // Data members. void* (*_M_alloc_fun)(size_t); void (*_M_free_fun)(void*); bool _M_dynamic : 1; bool _M_frozen : 1; bool _M_constant : 1; }; // Class istrstream, an istream that manages a strstreambuf. class istrstream : public basic_istream<char> { public: explicit istrstream(char*); explicit istrstream(const char*); istrstream(char* , streamsize); istrstream(const char*, streamsize); virtual ~istrstream(); #if __cplusplus >= 201103L istrstream(istrstream&& __rhs) : istream(std::move(__rhs)), _M_buf(std::move(__rhs._M_buf)) { set_rdbuf(&_M_buf); } istrstream& operator=(istrstream&&) = default; #endif _GLIBCXX_CONST strstreambuf* rdbuf() const throw (); char* str() throw (); private: strstreambuf _M_buf; }; // Class ostrstream class ostrstream : public basic_ostream<char> { public: ostrstream(); ostrstream(char*, int, ios_base::openmode = ios_base::out); virtual ~ostrstream(); #if __cplusplus >= 201103L ostrstream(ostrstream&& __rhs) : ostream(std::move(__rhs)), _M_buf(std::move(__rhs._M_buf)) { set_rdbuf(&_M_buf); } ostrstream& operator=(ostrstream&&) = default; #endif _GLIBCXX_CONST strstreambuf* rdbuf() const throw (); void freeze(bool = true) throw(); char* str() throw (); _GLIBCXX_PURE int pcount() const throw (); private: strstreambuf _M_buf; }; // Class strstream class strstream : public basic_iostream<char> { public: typedef char char_type; typedef char_traits<char>::int_type int_type; typedef char_traits<char>::pos_type pos_type; typedef char_traits<char>::off_type off_type; strstream(); strstream(char*, int, ios_base::openmode = ios_base::in | ios_base::out); virtual ~strstream(); #if __cplusplus >= 201103L strstream(strstream&& __rhs) : iostream(std::move(__rhs)), _M_buf(std::move(__rhs._M_buf)) { set_rdbuf(&_M_buf); } strstream& operator=(strstream&&) = default; #endif _GLIBCXX_CONST strstreambuf* rdbuf() const throw (); void freeze(bool = true) throw (); _GLIBCXX_PURE int pcount() const throw (); char* str() throw (); private: strstreambuf _M_buf; }; _GLIBCXX_END_NAMESPACE_VERSION } // namespace #endif