364 lines · plain
1// -*- C++ -*-2//===----------------------------------------------------------------------===//3//4// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.5// See https://llvm.org/LICENSE.txt for license information.6// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception7//8//===----------------------------------------------------------------------===//9 10#ifndef _LIBCPP_STRSTREAM11#define _LIBCPP_STRSTREAM12 13/*14 strstream synopsis15 16class strstreambuf // Removed in C++2617 : public basic_streambuf<char>18{19public:20 explicit strstreambuf(streamsize alsize_arg = 0); // before C++2021 strstreambuf() : strstreambuf(0) {} // C++2022 explicit strstreambuf(streamsize alsize_arg); // C++2023 24 strstreambuf(void* (*palloc_arg)(size_t), void (*pfree_arg)(void*));25 strstreambuf(char* gnext_arg, streamsize n, char* pbeg_arg = nullptr);26 strstreambuf(const char* gnext_arg, streamsize n);27 28 strstreambuf(signed char* gnext_arg, streamsize n, signed char* pbeg_arg = nullptr);29 strstreambuf(const signed char* gnext_arg, streamsize n);30 strstreambuf(unsigned char* gnext_arg, streamsize n, unsigned char* pbeg_arg = nullptr);31 strstreambuf(const unsigned char* gnext_arg, streamsize n);32 33 strstreambuf(strstreambuf&& rhs);34 strstreambuf& operator=(strstreambuf&& rhs);35 36 virtual ~strstreambuf();37 38 void swap(strstreambuf& rhs);39 40 void freeze(bool freezefl = true);41 char* str();42 int pcount() const;43 44protected:45 virtual int_type overflow (int_type c = EOF);46 virtual int_type pbackfail(int_type c = EOF);47 virtual int_type underflow();48 virtual pos_type seekoff(off_type off, ios_base::seekdir way,49 ios_base::openmode which = ios_base::in | ios_base::out);50 virtual pos_type seekpos(pos_type sp,51 ios_base::openmode which = ios_base::in | ios_base::out);52 virtual streambuf* setbuf(char* s, streamsize n);53 54private:55 typedef T1 strstate; // exposition only56 static const strstate allocated; // exposition only57 static const strstate constant; // exposition only58 static const strstate dynamic; // exposition only59 static const strstate frozen; // exposition only60 strstate strmode; // exposition only61 streamsize alsize; // exposition only62 void* (*palloc)(size_t); // exposition only63 void (*pfree)(void*); // exposition only64};65 66class istrstream // Removed in C++2667 : public basic_istream<char>68{69public:70 explicit istrstream(const char* s);71 explicit istrstream(char* s);72 istrstream(const char* s, streamsize n);73 istrstream(char* s, streamsize n);74 75 virtual ~istrstream();76 77 strstreambuf* rdbuf() const;78 char *str();79 80private:81 strstreambuf sb; // exposition only82};83 84class ostrstream // Removed in C++2685 : public basic_ostream<char>86{87public:88 ostrstream();89 ostrstream(char* s, int n, ios_base::openmode mode = ios_base::out);90 91 virtual ~ostrstream();92 93 strstreambuf* rdbuf() const;94 void freeze(bool freezefl = true);95 char* str();96 int pcount() const;97 98private:99 strstreambuf sb; // exposition only100};101 102class strstream // Removed in C++26103 : public basic_iostream<char>104{105public:106 // Types107 typedef char char_type;108 typedef char_traits<char>::int_type int_type;109 typedef char_traits<char>::pos_type pos_type;110 typedef char_traits<char>::off_type off_type;111 112 // constructors/destructor113 strstream();114 strstream(char* s, int n, ios_base::openmode mode = ios_base::in | ios_base::out);115 116 virtual ~strstream();117 118 // Members:119 strstreambuf* rdbuf() const;120 void freeze(bool freezefl = true);121 int pcount() const;122 char* str();123 124private:125 strstreambuf sb; // exposition only126};127 128} // std129 130*/131 132#if __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)133# include <__cxx03/strstream>134#else135# include <__config>136 137# if _LIBCPP_HAS_LOCALIZATION138 139# include <__ostream/basic_ostream.h>140# include <istream>141# include <streambuf>142# include <version>143 144# if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)145# pragma GCC system_header146# endif147 148# if _LIBCPP_STD_VER < 26 || defined(_LIBCPP_ENABLE_CXX26_REMOVED_STRSTREAM) || defined(_LIBCPP_BUILDING_LIBRARY)149 150_LIBCPP_PUSH_MACROS151# include <__undef_macros>152 153_LIBCPP_BEGIN_NAMESPACE_STD154 155class _LIBCPP_DEPRECATED _LIBCPP_EXPORTED_FROM_ABI strstreambuf : public streambuf {156public:157# ifndef _LIBCPP_CXX03_LANG158 _LIBCPP_HIDE_FROM_ABI strstreambuf() : strstreambuf(0) {}159 explicit strstreambuf(streamsize __alsize);160# else161 explicit strstreambuf(streamsize __alsize = 0);162# endif163 strstreambuf(void* (*__palloc)(size_t), void (*__pfree)(void*));164 strstreambuf(char* __gnext, streamsize __n, char* __pbeg = nullptr);165 strstreambuf(const char* __gnext, streamsize __n);166 167 strstreambuf(signed char* __gnext, streamsize __n, signed char* __pbeg = nullptr);168 strstreambuf(const signed char* __gnext, streamsize __n);169 strstreambuf(unsigned char* __gnext, streamsize __n, unsigned char* __pbeg = nullptr);170 strstreambuf(const unsigned char* __gnext, streamsize __n);171 172# ifndef _LIBCPP_CXX03_LANG173 _LIBCPP_HIDE_FROM_ABI strstreambuf(strstreambuf&& __rhs);174 _LIBCPP_HIDE_FROM_ABI strstreambuf& operator=(strstreambuf&& __rhs);175# endif // _LIBCPP_CXX03_LANG176 177 ~strstreambuf() override;178 179 void swap(strstreambuf& __rhs);180 181 void freeze(bool __freezefl = true);182 char* str();183 int pcount() const;184 185protected:186 int_type overflow(int_type __c = EOF) override;187 int_type pbackfail(int_type __c = EOF) override;188 int_type underflow() override;189 pos_type190 seekoff(off_type __off, ios_base::seekdir __way, ios_base::openmode __which = ios_base::in | ios_base::out) override;191 pos_type seekpos(pos_type __sp, ios_base::openmode __which = ios_base::in | ios_base::out) override;192 193private:194 typedef unsigned __mode_type;195 static const __mode_type __allocated = 0x01;196 static const __mode_type __constant = 0x02;197 static const __mode_type __dynamic = 0x04;198 static const __mode_type __frozen = 0x08;199 static const streamsize __default_alsize = 4096;200 201 __mode_type __strmode_;202 streamsize __alsize_;203 void* (*__palloc_)(size_t);204 void (*__pfree_)(void*);205 206 void __init(char* __gnext, streamsize __n, char* __pbeg);207};208 209# ifndef _LIBCPP_CXX03_LANG210 211inline _LIBCPP_HIDE_FROM_ABI strstreambuf::strstreambuf(strstreambuf&& __rhs)212 : streambuf(__rhs),213 __strmode_(__rhs.__strmode_),214 __alsize_(__rhs.__alsize_),215 __palloc_(__rhs.__palloc_),216 __pfree_(__rhs.__pfree_) {217 __rhs.setg(nullptr, nullptr, nullptr);218 __rhs.setp(nullptr, nullptr);219}220 221inline _LIBCPP_HIDE_FROM_ABI strstreambuf& strstreambuf::operator=(strstreambuf&& __rhs) {222 if (eback() && (__strmode_ & __allocated) != 0 && (__strmode_ & __frozen) == 0) {223 if (__pfree_)224 __pfree_(eback());225 else226 delete[] eback();227 }228 streambuf::operator=(__rhs);229 __strmode_ = __rhs.__strmode_;230 __alsize_ = __rhs.__alsize_;231 __palloc_ = __rhs.__palloc_;232 __pfree_ = __rhs.__pfree_;233 __rhs.setg(nullptr, nullptr, nullptr);234 __rhs.setp(nullptr, nullptr);235 return *this;236}237 238# endif // _LIBCPP_CXX03_LANG239 240class _LIBCPP_DEPRECATED _LIBCPP_EXPORTED_FROM_ABI istrstream : public istream {241public:242 _LIBCPP_HIDE_FROM_ABI explicit istrstream(const char* __s) : istream(&__sb_), __sb_(__s, 0) {}243 _LIBCPP_HIDE_FROM_ABI explicit istrstream(char* __s) : istream(&__sb_), __sb_(__s, 0) {}244 _LIBCPP_HIDE_FROM_ABI istrstream(const char* __s, streamsize __n) : istream(&__sb_), __sb_(__s, __n) {}245 _LIBCPP_HIDE_FROM_ABI istrstream(char* __s, streamsize __n) : istream(&__sb_), __sb_(__s, __n) {}246 247# ifndef _LIBCPP_CXX03_LANG248 _LIBCPP_HIDE_FROM_ABI istrstream(istrstream&& __rhs) // extension249 : istream(std::move(static_cast<istream&>(__rhs))), __sb_(std::move(__rhs.__sb_)) {250 istream::set_rdbuf(&__sb_);251 }252 253 _LIBCPP_HIDE_FROM_ABI istrstream& operator=(istrstream&& __rhs) {254 __sb_ = std::move(__rhs.__sb_);255 istream::operator=(std::move(__rhs));256 return *this;257 }258# endif // _LIBCPP_CXX03_LANG259 260 ~istrstream() override;261 262 _LIBCPP_HIDE_FROM_ABI void swap(istrstream& __rhs) {263 istream::swap(__rhs);264 __sb_.swap(__rhs.__sb_);265 }266 267 _LIBCPP_HIDE_FROM_ABI strstreambuf* rdbuf() const { return const_cast<strstreambuf*>(&__sb_); }268 _LIBCPP_HIDE_FROM_ABI char* str() { return __sb_.str(); }269 270private:271 strstreambuf __sb_;272};273 274class _LIBCPP_DEPRECATED _LIBCPP_EXPORTED_FROM_ABI ostrstream : public ostream {275public:276 _LIBCPP_HIDE_FROM_ABI ostrstream() : ostream(&__sb_) {}277 _LIBCPP_HIDE_FROM_ABI ostrstream(char* __s, int __n, ios_base::openmode __mode = ios_base::out)278 : ostream(&__sb_), __sb_(__s, __n, __s + (__mode & ios::app ? std::strlen(__s) : 0)) {}279 280# ifndef _LIBCPP_CXX03_LANG281 _LIBCPP_HIDE_FROM_ABI ostrstream(ostrstream&& __rhs) // extension282 : ostream(std::move(static_cast<ostream&>(__rhs))), __sb_(std::move(__rhs.__sb_)) {283 ostream::set_rdbuf(&__sb_);284 }285 286 _LIBCPP_HIDE_FROM_ABI ostrstream& operator=(ostrstream&& __rhs) {287 __sb_ = std::move(__rhs.__sb_);288 ostream::operator=(std::move(__rhs));289 return *this;290 }291# endif // _LIBCPP_CXX03_LANG292 293 ~ostrstream() override;294 295 _LIBCPP_HIDE_FROM_ABI void swap(ostrstream& __rhs) {296 ostream::swap(__rhs);297 __sb_.swap(__rhs.__sb_);298 }299 300 _LIBCPP_HIDE_FROM_ABI strstreambuf* rdbuf() const { return const_cast<strstreambuf*>(&__sb_); }301 _LIBCPP_HIDE_FROM_ABI void freeze(bool __freezefl = true) { __sb_.freeze(__freezefl); }302 _LIBCPP_HIDE_FROM_ABI char* str() { return __sb_.str(); }303 _LIBCPP_HIDE_FROM_ABI int pcount() const { return __sb_.pcount(); }304 305private:306 strstreambuf __sb_; // exposition only307};308 309class _LIBCPP_DEPRECATED _LIBCPP_EXPORTED_FROM_ABI strstream : public iostream {310public:311 // Types312 typedef char char_type;313 typedef char_traits<char>::int_type int_type;314 typedef char_traits<char>::pos_type pos_type;315 typedef char_traits<char>::off_type off_type;316 317 // constructors/destructor318 _LIBCPP_HIDE_FROM_ABI strstream() : iostream(&__sb_) {}319 _LIBCPP_HIDE_FROM_ABI strstream(char* __s, int __n, ios_base::openmode __mode = ios_base::in | ios_base::out)320 : iostream(&__sb_), __sb_(__s, __n, __s + (__mode & ios::app ? std::strlen(__s) : 0)) {}321 322# ifndef _LIBCPP_CXX03_LANG323 _LIBCPP_HIDE_FROM_ABI strstream(strstream&& __rhs) // extension324 : iostream(std::move(static_cast<iostream&>(__rhs))), __sb_(std::move(__rhs.__sb_)) {325 iostream::set_rdbuf(&__sb_);326 }327 328 _LIBCPP_HIDE_FROM_ABI strstream& operator=(strstream&& __rhs) {329 __sb_ = std::move(__rhs.__sb_);330 iostream::operator=(std::move(__rhs));331 return *this;332 }333# endif // _LIBCPP_CXX03_LANG334 335 ~strstream() override;336 337 _LIBCPP_HIDE_FROM_ABI void swap(strstream& __rhs) {338 iostream::swap(__rhs);339 __sb_.swap(__rhs.__sb_);340 }341 342 // Members:343 _LIBCPP_HIDE_FROM_ABI strstreambuf* rdbuf() const { return const_cast<strstreambuf*>(&__sb_); }344 _LIBCPP_HIDE_FROM_ABI void freeze(bool __freezefl = true) { __sb_.freeze(__freezefl); }345 _LIBCPP_HIDE_FROM_ABI int pcount() const { return __sb_.pcount(); }346 _LIBCPP_HIDE_FROM_ABI char* str() { return __sb_.str(); }347 348private:349 strstreambuf __sb_; // exposition only350};351 352_LIBCPP_END_NAMESPACE_STD353 354_LIBCPP_POP_MACROS355 356# endif // _LIBCPP_STD_VER < 26 || defined(_LIBCPP_ENABLE_CXX26_REMOVED_STRSTREAM) ||357 // defined(_LIBCPP_BUILDING_LIBRARY)358 359# endif // _LIBCPP_HAS_LOCALIZATION360 361#endif // __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)362 363#endif // _LIBCPP_STRSTREAM364