xref: /freebsd/contrib/llvm-project/libcxx/include/strstream (revision c66ec88fed842fbaad62c30d510644ceb7bd2d71) 
1// -*- C++ -*-
2//===--------------------------- strstream --------------------------------===//
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
17    : public basic_streambuf<char>
18{
19public:
20    explicit strstreambuf(streamsize alsize_arg = 0);
21    strstreambuf(void* (*palloc_arg)(size_t), void (*pfree_arg)(void*));
22    strstreambuf(char* gnext_arg, streamsize n, char* pbeg_arg = 0);
23    strstreambuf(const char* gnext_arg, streamsize n);
24
25    strstreambuf(signed char* gnext_arg, streamsize n, signed char* pbeg_arg = 0);
26    strstreambuf(const signed char* gnext_arg, streamsize n);
27    strstreambuf(unsigned char* gnext_arg, streamsize n, unsigned char* pbeg_arg = 0);
28    strstreambuf(const unsigned char* gnext_arg, streamsize n);
29
30    strstreambuf(strstreambuf&& rhs);
31    strstreambuf& operator=(strstreambuf&& rhs);
32
33    virtual ~strstreambuf();
34
35    void swap(strstreambuf& rhs);
36
37    void freeze(bool freezefl = true);
38    char* str();
39    int pcount() const;
40
41protected:
42    virtual int_type overflow (int_type c = EOF);
43    virtual int_type pbackfail(int_type c = EOF);
44    virtual int_type underflow();
45    virtual pos_type seekoff(off_type off, ios_base::seekdir way,
46                             ios_base::openmode which = ios_base::in | ios_base::out);
47    virtual pos_type seekpos(pos_type sp,
48                             ios_base::openmode which = ios_base::in | ios_base::out);
49    virtual streambuf* setbuf(char* s, streamsize n);
50
51private:
52    typedef T1 strstate;                // exposition only
53    static const strstate allocated;    // exposition only
54    static const strstate constant;     // exposition only
55    static const strstate dynamic;      // exposition only
56    static const strstate frozen;       // exposition only
57    strstate strmode;                   // exposition only
58    streamsize alsize;                  // exposition only
59    void* (*palloc)(size_t);            // exposition only
60    void (*pfree)(void*);               // exposition only
61};
62
63class istrstream
64    : public basic_istream<char>
65{
66public:
67    explicit istrstream(const char* s);
68    explicit istrstream(char* s);
69    istrstream(const char* s, streamsize n);
70    istrstream(char* s, streamsize n);
71
72    virtual ~istrstream();
73
74    strstreambuf* rdbuf() const;
75    char *str();
76
77private:
78    strstreambuf sb; // exposition only
79};
80
81class ostrstream
82    : public basic_ostream<char>
83{
84public:
85    ostrstream();
86    ostrstream(char* s, int n, ios_base::openmode mode = ios_base::out);
87
88    virtual ~ostrstream();
89
90    strstreambuf* rdbuf() const;
91    void freeze(bool freezefl = true);
92    char* str();
93    int pcount() const;
94
95private:
96    strstreambuf sb; // exposition only
97};
98
99class strstream
100    : public basic_iostream<char>
101{
102public:
103    // Types
104    typedef char                        char_type;
105    typedef char_traits<char>::int_type int_type;
106    typedef char_traits<char>::pos_type pos_type;
107    typedef char_traits<char>::off_type off_type;
108
109    // constructors/destructor
110    strstream();
111    strstream(char* s, int n, ios_base::openmode mode = ios_base::in | ios_base::out);
112
113    virtual ~strstream();
114
115    // Members:
116    strstreambuf* rdbuf() const;
117    void freeze(bool freezefl = true);
118    int pcount() const;
119    char* str();
120
121private:
122    strstreambuf sb; // exposition only
123};
124
125}  // std
126
127*/
128
129#include <__config>
130#include <ostream>
131#include <istream>
132
133#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
134#pragma GCC system_header
135#endif
136
137_LIBCPP_BEGIN_NAMESPACE_STD
138
139class _LIBCPP_TYPE_VIS strstreambuf
140    : public streambuf
141{
142public:
143    explicit strstreambuf(streamsize __alsize = 0);
144    strstreambuf(void* (*__palloc)(size_t), void (*__pfree)(void*));
145    strstreambuf(char* __gnext, streamsize __n, char* __pbeg = 0);
146    strstreambuf(const char* __gnext, streamsize __n);
147
148    strstreambuf(signed char* __gnext, streamsize __n, signed char* __pbeg = 0);
149    strstreambuf(const signed char* __gnext, streamsize __n);
150    strstreambuf(unsigned char* __gnext, streamsize __n, unsigned char* __pbeg = 0);
151    strstreambuf(const unsigned char* __gnext, streamsize __n);
152
153#ifndef _LIBCPP_CXX03_LANG
154    _LIBCPP_INLINE_VISIBILITY
155    strstreambuf(strstreambuf&& __rhs);
156    _LIBCPP_INLINE_VISIBILITY
157    strstreambuf& operator=(strstreambuf&& __rhs);
158#endif  // _LIBCPP_CXX03_LANG
159
160    virtual ~strstreambuf();
161
162    void swap(strstreambuf& __rhs);
163
164    void freeze(bool __freezefl = true);
165    char* str();
166    int pcount() const;
167
168protected:
169    virtual int_type overflow (int_type __c = EOF);
170    virtual int_type pbackfail(int_type __c = EOF);
171    virtual int_type underflow();
172    virtual pos_type seekoff(off_type __off, ios_base::seekdir __way,
173                             ios_base::openmode __which = ios_base::in | ios_base::out);
174    virtual pos_type seekpos(pos_type __sp,
175                             ios_base::openmode __which = ios_base::in | ios_base::out);
176
177private:
178    typedef unsigned __mode_type;
179    static const __mode_type __allocated = 0x01;
180    static const __mode_type __constant  = 0x02;
181    static const __mode_type __dynamic   = 0x04;
182    static const __mode_type __frozen    = 0x08;
183    static const streamsize    __default_alsize = 4096;
184
185    __mode_type __strmode_;
186    streamsize __alsize_;
187    void* (*__palloc_)(size_t);
188    void (*__pfree_)(void*);
189
190    void __init(char* __gnext, streamsize __n, char* __pbeg);
191};
192
193#ifndef _LIBCPP_CXX03_LANG
194
195inline _LIBCPP_INLINE_VISIBILITY
196strstreambuf::strstreambuf(strstreambuf&& __rhs)
197    : streambuf(__rhs),
198      __strmode_(__rhs.__strmode_),
199      __alsize_(__rhs.__alsize_),
200      __palloc_(__rhs.__palloc_),
201      __pfree_(__rhs.__pfree_)
202{
203    __rhs.setg(nullptr, nullptr, nullptr);
204    __rhs.setp(nullptr, nullptr);
205}
206
207inline _LIBCPP_INLINE_VISIBILITY
208strstreambuf&
209strstreambuf::operator=(strstreambuf&& __rhs)
210{
211    if (eback() && (__strmode_ & __allocated) != 0 && (__strmode_ & __frozen) == 0)
212    {
213        if (__pfree_)
214            __pfree_(eback());
215        else
216            delete [] eback();
217    }
218    streambuf::operator=(__rhs);
219    __strmode_ = __rhs.__strmode_;
220    __alsize_ = __rhs.__alsize_;
221    __palloc_ = __rhs.__palloc_;
222    __pfree_ = __rhs.__pfree_;
223    __rhs.setg(nullptr, nullptr, nullptr);
224    __rhs.setp(nullptr, nullptr);
225    return *this;
226}
227
228#endif  // _LIBCPP_CXX03_LANG
229
230class _LIBCPP_TYPE_VIS istrstream
231    : public istream
232{
233public:
234    _LIBCPP_INLINE_VISIBILITY
235    explicit istrstream(const char* __s)
236        : istream(&__sb_), __sb_(__s, 0) {}
237    _LIBCPP_INLINE_VISIBILITY
238    explicit istrstream(char* __s)
239        : istream(&__sb_), __sb_(__s, 0) {}
240    _LIBCPP_INLINE_VISIBILITY
241    istrstream(const char* __s, streamsize __n)
242        : istream(&__sb_), __sb_(__s, __n) {}
243    _LIBCPP_INLINE_VISIBILITY
244    istrstream(char* __s, streamsize __n)
245        : istream(&__sb_), __sb_(__s, __n) {}
246
247#ifndef _LIBCPP_CXX03_LANG
248    _LIBCPP_INLINE_VISIBILITY
249    istrstream(istrstream&& __rhs)
250        : istream(_VSTD::move(__rhs)),
251          __sb_(_VSTD::move(__rhs.__sb_))
252    {
253        istream::set_rdbuf(&__sb_);
254    }
255
256    _LIBCPP_INLINE_VISIBILITY
257    istrstream& operator=(istrstream&& __rhs)
258    {
259        istream::operator=(_VSTD::move(__rhs));
260        __sb_ = _VSTD::move(__rhs.__sb_);
261        return *this;
262    }
263#endif  // _LIBCPP_CXX03_LANG
264
265    virtual ~istrstream();
266
267    _LIBCPP_INLINE_VISIBILITY
268    void swap(istrstream& __rhs)
269    {
270        istream::swap(__rhs);
271        __sb_.swap(__rhs.__sb_);
272    }
273
274    _LIBCPP_INLINE_VISIBILITY
275    strstreambuf* rdbuf() const {return const_cast<strstreambuf*>(&__sb_);}
276    _LIBCPP_INLINE_VISIBILITY
277    char *str() {return __sb_.str();}
278
279private:
280    strstreambuf __sb_;
281};
282
283class _LIBCPP_TYPE_VIS ostrstream
284    : public ostream
285{
286public:
287    _LIBCPP_INLINE_VISIBILITY
288    ostrstream()
289        : ostream(&__sb_) {}
290    _LIBCPP_INLINE_VISIBILITY
291    ostrstream(char* __s, int __n, ios_base::openmode __mode = ios_base::out)
292        : ostream(&__sb_),
293          __sb_(__s, __n, __s + (__mode & ios::app ? strlen(__s) : 0))
294        {}
295
296#ifndef _LIBCPP_CXX03_LANG
297    _LIBCPP_INLINE_VISIBILITY
298    ostrstream(ostrstream&& __rhs)
299        : ostream(_VSTD::move(__rhs)),
300          __sb_(_VSTD::move(__rhs.__sb_))
301    {
302        ostream::set_rdbuf(&__sb_);
303    }
304
305    _LIBCPP_INLINE_VISIBILITY
306    ostrstream& operator=(ostrstream&& __rhs)
307    {
308        ostream::operator=(_VSTD::move(__rhs));
309        __sb_ = _VSTD::move(__rhs.__sb_);
310        return *this;
311    }
312#endif  // _LIBCPP_CXX03_LANG
313
314    virtual ~ostrstream();
315
316    _LIBCPP_INLINE_VISIBILITY
317    void swap(ostrstream& __rhs)
318    {
319        ostream::swap(__rhs);
320        __sb_.swap(__rhs.__sb_);
321    }
322
323    _LIBCPP_INLINE_VISIBILITY
324    strstreambuf* rdbuf() const {return const_cast<strstreambuf*>(&__sb_);}
325    _LIBCPP_INLINE_VISIBILITY
326    void freeze(bool __freezefl = true) {__sb_.freeze(__freezefl);}
327    _LIBCPP_INLINE_VISIBILITY
328    char* str()         {return __sb_.str();}
329    _LIBCPP_INLINE_VISIBILITY
330    int pcount() const  {return __sb_.pcount();}
331
332private:
333    strstreambuf __sb_; // exposition only
334};
335
336class _LIBCPP_TYPE_VIS strstream
337    : public iostream
338{
339public:
340    // Types
341    typedef char                        char_type;
342    typedef char_traits<char>::int_type int_type;
343    typedef char_traits<char>::pos_type pos_type;
344    typedef char_traits<char>::off_type off_type;
345
346    // constructors/destructor
347    _LIBCPP_INLINE_VISIBILITY
348    strstream()
349        : iostream(&__sb_) {}
350    _LIBCPP_INLINE_VISIBILITY
351    strstream(char* __s, int __n, ios_base::openmode __mode = ios_base::in | ios_base::out)
352        : iostream(&__sb_),
353          __sb_(__s, __n, __s + (__mode & ios::app ? strlen(__s) : 0))
354        {}
355
356#ifndef _LIBCPP_CXX03_LANG
357    _LIBCPP_INLINE_VISIBILITY
358    strstream(strstream&& __rhs)
359        : iostream(_VSTD::move(__rhs)),
360          __sb_(_VSTD::move(__rhs.__sb_))
361    {
362        iostream::set_rdbuf(&__sb_);
363    }
364
365    _LIBCPP_INLINE_VISIBILITY
366    strstream& operator=(strstream&& __rhs)
367    {
368        iostream::operator=(_VSTD::move(__rhs));
369        __sb_ = _VSTD::move(__rhs.__sb_);
370        return *this;
371    }
372#endif  // _LIBCPP_CXX03_LANG
373
374    virtual ~strstream();
375
376    _LIBCPP_INLINE_VISIBILITY
377    void swap(strstream& __rhs)
378    {
379        iostream::swap(__rhs);
380        __sb_.swap(__rhs.__sb_);
381    }
382
383    // Members:
384    _LIBCPP_INLINE_VISIBILITY
385    strstreambuf* rdbuf() const {return const_cast<strstreambuf*>(&__sb_);}
386    _LIBCPP_INLINE_VISIBILITY
387    void freeze(bool __freezefl = true) {__sb_.freeze(__freezefl);}
388    _LIBCPP_INLINE_VISIBILITY
389    int pcount() const {return __sb_.pcount();}
390    _LIBCPP_INLINE_VISIBILITY
391    char* str()        {return __sb_.str();}
392
393private:
394    strstreambuf __sb_; // exposition only
395};
396
397_LIBCPP_END_NAMESPACE_STD
398
399#endif  // _LIBCPP_STRSTREAM
400