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