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-exception
7//
8//===----------------------------------------------------------------------===//
9
10#ifndef _LIBCPP_STRSTREAM
11#define _LIBCPP_STRSTREAM
12
13/*
14 strstream synopsis
15
16class strstreambuf // Removed in C++26
17 : public basic_streambuf<char>
18{
19public:
20 explicit strstreambuf(streamsize alsize_arg = 0); // before C++20
21 strstreambuf() : strstreambuf(0) {} // C++20
22 explicit strstreambuf(streamsize alsize_arg); // C++20
23
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 only
56 static const strstate allocated; // exposition only
57 static const strstate constant; // exposition only
58 static const strstate dynamic; // exposition only
59 static const strstate frozen; // exposition only
60 strstate strmode; // exposition only
61 streamsize alsize; // exposition only
62 void* (*palloc)(size_t); // exposition only
63 void (*pfree)(void*); // exposition only
64};
65
66class istrstream // Removed in C++26
67 : 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 only
82};
83
84class ostrstream // Removed in C++26
85 : 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 only
100};
101
102class strstream // Removed in C++26
103 : public basic_iostream<char>
104{
105public:
106 // Types
107 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/destructor
113 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 only
126};
127
128} // std
129
130*/
131
132#if __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)
133# include <__cxx03/strstream>
134#else
135# include <__config>
136
137# if _LIBCPP_HAS_LOCALIZATION
138
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_header
146# endif
147
148# if _LIBCPP_STD_VER < 26 || defined(_LIBCPP_ENABLE_CXX26_REMOVED_STRSTREAM) || defined(_LIBCPP_BUILDING_LIBRARY)
149
150_LIBCPP_PUSH_MACROS
151# include <__undef_macros>
152
153_LIBCPP_BEGIN_NAMESPACE_STD
154_LIBCPP_BEGIN_EXPLICIT_ABI_ANNOTATIONS
155
156class _LIBCPP_DEPRECATED _LIBCPP_EXPORTED_FROM_ABI strstreambuf : public streambuf {
157public:
158# ifndef _LIBCPP_CXX03_LANG
159 _LIBCPP_HIDE_FROM_ABI strstreambuf() : strstreambuf(0) {}
160 explicit strstreambuf(streamsize __alsize);
161# else
162 explicit strstreambuf(streamsize __alsize = 0);
163# endif
164 strstreambuf(void* (*__palloc)(size_t), void (*__pfree)(void*));
165 strstreambuf(char* __gnext, streamsize __n, char* __pbeg = nullptr);
166 strstreambuf(const char* __gnext, streamsize __n);
167
168 strstreambuf(signed char* __gnext, streamsize __n, signed char* __pbeg = nullptr);
169 strstreambuf(const signed char* __gnext, streamsize __n);
170 strstreambuf(unsigned char* __gnext, streamsize __n, unsigned char* __pbeg = nullptr);
171 strstreambuf(const unsigned char* __gnext, streamsize __n);
172
173# ifndef _LIBCPP_CXX03_LANG
174 _LIBCPP_HIDE_FROM_ABI strstreambuf(strstreambuf&& __rhs);
175 _LIBCPP_HIDE_FROM_ABI strstreambuf& operator=(strstreambuf&& __rhs);
176# endif // _LIBCPP_CXX03_LANG
177
178 ~strstreambuf() override;
179
180 void swap(strstreambuf& __rhs);
181
182 void freeze(bool __freezefl = true);
183 [[__nodiscard__]] char* str();
184 [[__nodiscard__]] int pcount() const;
185
186protected:
187 int_type overflow(int_type __c = EOF) override;
188 int_type pbackfail(int_type __c = EOF) override;
189 int_type underflow() override;
190 pos_type
191 seekoff(off_type __off, ios_base::seekdir __way, ios_base::openmode __which = ios_base::in | ios_base::out) override;
192 pos_type seekpos(pos_type __sp, ios_base::openmode __which = ios_base::in | ios_base::out) override;
193
194private:
195 typedef unsigned __mode_type;
196 static const __mode_type __allocated = 0x01;
197 static const __mode_type __constant = 0x02;
198 static const __mode_type __dynamic = 0x04;
199 static const __mode_type __frozen = 0x08;
200 static const streamsize __default_alsize = 4096;
201
202 __mode_type __strmode_;
203 streamsize __alsize_;
204 void* (*__palloc_)(size_t);
205 void (*__pfree_)(void*);
206
207 void __init(char* __gnext, streamsize __n, char* __pbeg);
208};
209
210# ifndef _LIBCPP_CXX03_LANG
211
212inline _LIBCPP_HIDE_FROM_ABI strstreambuf::strstreambuf(strstreambuf&& __rhs)
213 : streambuf(__rhs),
214 __strmode_(__rhs.__strmode_),
215 __alsize_(__rhs.__alsize_),
216 __palloc_(__rhs.__palloc_),
217 __pfree_(__rhs.__pfree_) {
218 __rhs.setg(gbeg: nullptr, gnext: nullptr, gend: nullptr);
219 __rhs.setp(pbeg: nullptr, pend: nullptr);
220}
221
222inline _LIBCPP_HIDE_FROM_ABI strstreambuf& strstreambuf::operator=(strstreambuf&& __rhs) {
223 if (eback() && (__strmode_ & __allocated) != 0 && (__strmode_ & __frozen) == 0) {
224 if (__pfree_)
225 __pfree_(eback());
226 else
227 delete[] eback();
228 }
229 streambuf::operator=(sb: __rhs);
230 __strmode_ = __rhs.__strmode_;
231 __alsize_ = __rhs.__alsize_;
232 __palloc_ = __rhs.__palloc_;
233 __pfree_ = __rhs.__pfree_;
234 __rhs.setg(gbeg: nullptr, gnext: nullptr, gend: nullptr);
235 __rhs.setp(pbeg: nullptr, pend: nullptr);
236 return *this;
237}
238
239# endif // _LIBCPP_CXX03_LANG
240
241class _LIBCPP_DEPRECATED _LIBCPP_EXPORTED_FROM_ABI istrstream : public istream {
242public:
243 _LIBCPP_HIDE_FROM_ABI explicit istrstream(const char* __s) : istream(&__sb_), __sb_(__s, 0) {}
244 _LIBCPP_HIDE_FROM_ABI explicit istrstream(char* __s) : istream(&__sb_), __sb_(__s, 0) {}
245 _LIBCPP_HIDE_FROM_ABI istrstream(const char* __s, streamsize __n) : istream(&__sb_), __sb_(__s, __n) {}
246 _LIBCPP_HIDE_FROM_ABI istrstream(char* __s, streamsize __n) : istream(&__sb_), __sb_(__s, __n) {}
247
248# ifndef _LIBCPP_CXX03_LANG
249 _LIBCPP_HIDE_FROM_ABI istrstream(istrstream&& __rhs) // extension
250 : istream(std::move(static_cast<istream&>(__rhs))), __sb_(std::move(__rhs.__sb_)) {
251 istream::set_rdbuf(&__sb_);
252 }
253
254 _LIBCPP_HIDE_FROM_ABI istrstream& operator=(istrstream&& __rhs) {
255 __sb_ = std::move(__rhs.__sb_);
256 istream::operator=(rhs: std::move(__rhs));
257 return *this;
258 }
259# endif // _LIBCPP_CXX03_LANG
260
261 ~istrstream() override;
262
263 _LIBCPP_HIDE_FROM_ABI void swap(istrstream& __rhs) {
264 istream::swap(__rhs);
265 __sb_.swap(rhs&: __rhs.__sb_);
266 }
267
268 [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI strstreambuf* rdbuf() const { return const_cast<strstreambuf*>(&__sb_); }
269 [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI char* str() { return __sb_.str(); }
270
271private:
272 strstreambuf __sb_;
273};
274
275class _LIBCPP_DEPRECATED _LIBCPP_EXPORTED_FROM_ABI ostrstream : public ostream {
276public:
277 _LIBCPP_HIDE_FROM_ABI ostrstream() : ostream(&__sb_) {}
278 _LIBCPP_HIDE_FROM_ABI ostrstream(char* __s, int __n, ios_base::openmode __mode = ios_base::out)
279 : ostream(&__sb_), __sb_(__s, __n, __s + (__mode & ios::app ? std::strlen(__s) : 0)) {}
280
281# ifndef _LIBCPP_CXX03_LANG
282 _LIBCPP_HIDE_FROM_ABI ostrstream(ostrstream&& __rhs) // extension
283 : ostream(std::move(static_cast<ostream&>(__rhs))), __sb_(std::move(__rhs.__sb_)) {
284 ostream::set_rdbuf(&__sb_);
285 }
286
287 _LIBCPP_HIDE_FROM_ABI ostrstream& operator=(ostrstream&& __rhs) {
288 __sb_ = std::move(__rhs.__sb_);
289 ostream::operator=(rhs: std::move(__rhs));
290 return *this;
291 }
292# endif // _LIBCPP_CXX03_LANG
293
294 ~ostrstream() override;
295
296 _LIBCPP_HIDE_FROM_ABI void swap(ostrstream& __rhs) {
297 ostream::swap(__rhs);
298 __sb_.swap(rhs&: __rhs.__sb_);
299 }
300
301 [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI strstreambuf* rdbuf() const { return const_cast<strstreambuf*>(&__sb_); }
302 _LIBCPP_HIDE_FROM_ABI void freeze(bool __freezefl = true) { __sb_.freeze(__freezefl); }
303 [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI char* str() { return __sb_.str(); }
304 [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI int pcount() const { return __sb_.pcount(); }
305
306private:
307 strstreambuf __sb_; // exposition only
308};
309
310class _LIBCPP_DEPRECATED _LIBCPP_EXPORTED_FROM_ABI strstream : public iostream {
311public:
312 // Types
313 typedef char char_type;
314 typedef char_traits<char>::int_type int_type;
315 typedef char_traits<char>::pos_type pos_type;
316 typedef char_traits<char>::off_type off_type;
317
318 // constructors/destructor
319 _LIBCPP_HIDE_FROM_ABI strstream() : iostream(&__sb_) {}
320 _LIBCPP_HIDE_FROM_ABI strstream(char* __s, int __n, ios_base::openmode __mode = ios_base::in | ios_base::out)
321 : iostream(&__sb_), __sb_(__s, __n, __s + (__mode & ios::app ? std::strlen(__s) : 0)) {}
322
323# ifndef _LIBCPP_CXX03_LANG
324 _LIBCPP_HIDE_FROM_ABI strstream(strstream&& __rhs) // extension
325 : iostream(std::move(static_cast<iostream&>(__rhs))), __sb_(std::move(__rhs.__sb_)) {
326 iostream::set_rdbuf(&__sb_);
327 }
328
329 _LIBCPP_HIDE_FROM_ABI strstream& operator=(strstream&& __rhs) {
330 __sb_ = std::move(__rhs.__sb_);
331 iostream::operator=(rhs: std::move(__rhs));
332 return *this;
333 }
334# endif // _LIBCPP_CXX03_LANG
335
336 ~strstream() override;
337
338 _LIBCPP_HIDE_FROM_ABI void swap(strstream& __rhs) {
339 iostream::swap(__rhs);
340 __sb_.swap(rhs&: __rhs.__sb_);
341 }
342
343 // Members:
344 [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI strstreambuf* rdbuf() const { return const_cast<strstreambuf*>(&__sb_); }
345 _LIBCPP_HIDE_FROM_ABI void freeze(bool __freezefl = true) { __sb_.freeze(__freezefl); }
346 [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI int pcount() const { return __sb_.pcount(); }
347 [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI char* str() { return __sb_.str(); }
348
349private:
350 strstreambuf __sb_; // exposition only
351};
352
353_LIBCPP_END_EXPLICIT_ABI_ANNOTATIONS
354_LIBCPP_END_NAMESPACE_STD
355
356_LIBCPP_POP_MACROS
357
358# endif // _LIBCPP_STD_VER < 26 || defined(_LIBCPP_ENABLE_CXX26_REMOVED_STRSTREAM) ||
359 // defined(_LIBCPP_BUILDING_LIBRARY)
360
361# endif // _LIBCPP_HAS_LOCALIZATION
362
363#endif // __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)
364
365#endif // _LIBCPP_STRSTREAM
366