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#pragma GCC system_header
135
136_LIBCPP_BEGIN_NAMESPACE_STD
137
138class _LIBCPP_VISIBLE strstreambuf
139    : public streambuf
140{
141public:
142    explicit strstreambuf(streamsize __alsize = 0);
143    strstreambuf(void* (*__palloc)(size_t), void (*__pfree)(void*));
144    strstreambuf(char* __gnext, streamsize __n, char* __pbeg = 0);
145    strstreambuf(const char* __gnext, streamsize __n);
146
147    strstreambuf(signed char* __gnext, streamsize __n, signed char* __pbeg = 0);
148    strstreambuf(const signed char* __gnext, streamsize __n);
149    strstreambuf(unsigned char* __gnext, streamsize __n, unsigned char* __pbeg = 0);
150    strstreambuf(const unsigned char* __gnext, streamsize __n);
151
152#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
153    strstreambuf(strstreambuf&& __rhs);
154    strstreambuf& operator=(strstreambuf&& __rhs);
155#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
156
157    virtual ~strstreambuf();
158
159    void swap(strstreambuf& __rhs);
160
161    void freeze(bool __freezefl = true);
162    char* str();
163    int pcount() const;
164
165protected:
166    virtual int_type overflow (int_type __c = EOF);
167    virtual int_type pbackfail(int_type __c = EOF);
168    virtual int_type underflow();
169    virtual pos_type seekoff(off_type __off, ios_base::seekdir __way,
170                             ios_base::openmode __which = ios_base::in | ios_base::out);
171    virtual pos_type seekpos(pos_type __sp,
172                             ios_base::openmode __which = ios_base::in | ios_base::out);
173
174private:
175    typedef unsigned __mode_type;
176    static const __mode_type __allocated = 0x01;
177    static const __mode_type __constant  = 0x02;
178    static const __mode_type __dynamic   = 0x04;
179    static const __mode_type __frozen    = 0x08;
180    static const streamsize    __default_alsize = 4096;
181
182    __mode_type __strmode_;
183    streamsize __alsize_;
184    void* (*__palloc_)(size_t);
185    void (*__pfree_)(void*);
186
187    void __init(char* __gnext, streamsize __n, char* __pbeg);
188};
189
190class _LIBCPP_VISIBLE istrstream
191    : public istream
192{
193public:
194    _LIBCPP_INLINE_VISIBILITY
195    explicit istrstream(const char* __s)
196        : istream(&__sb_), __sb_(__s, 0) {}
197    _LIBCPP_INLINE_VISIBILITY
198    explicit istrstream(char* __s)
199        : istream(&__sb_), __sb_(__s, 0) {}
200    _LIBCPP_INLINE_VISIBILITY
201    istrstream(const char* __s, streamsize __n)
202        : istream(&__sb_), __sb_(__s, __n) {}
203    _LIBCPP_INLINE_VISIBILITY
204    istrstream(char* __s, streamsize __n)
205        : istream(&__sb_), __sb_(__s, __n) {}
206
207#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
208    _LIBCPP_INLINE_VISIBILITY
209    istrstream(istrstream&& __rhs)
210        : istream(_STD::move(__rhs)),
211          __sb_(_STD::move(__rhs.__sb_))
212    {
213        istream::set_rdbuf(&__sb_);
214    }
215
216    _LIBCPP_INLINE_VISIBILITY
217    istrstream& operator=(istrstream&& __rhs)
218    {
219        istream::operator=(_STD::move(__rhs));
220        __sb_ = _STD::move(__rhs.__sb_);
221        return *this;
222    }
223#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
224
225    virtual ~istrstream();
226
227    _LIBCPP_INLINE_VISIBILITY
228    void swap(istrstream& __rhs)
229    {
230        istream::swap(__rhs);
231        __sb_.swap(__rhs.__sb_);
232    }
233
234    _LIBCPP_INLINE_VISIBILITY
235    strstreambuf* rdbuf() const {return const_cast<strstreambuf*>(&__sb_);}
236    _LIBCPP_INLINE_VISIBILITY
237    char *str() {return __sb_.str();}
238
239private:
240    strstreambuf __sb_;
241};
242
243class _LIBCPP_VISIBLE ostrstream
244    : public ostream
245{
246public:
247    _LIBCPP_INLINE_VISIBILITY
248    ostrstream()
249        : ostream(&__sb_) {}
250    _LIBCPP_INLINE_VISIBILITY
251    ostrstream(char* __s, int __n, ios_base::openmode __mode = ios_base::out)
252        : ostream(&__sb_),
253          __sb_(__s, __n, __s + (__mode & ios::app ? strlen(__s) : 0))
254        {}
255
256#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
257    _LIBCPP_INLINE_VISIBILITY
258    ostrstream(ostrstream&& __rhs)
259        : ostream(_STD::move(__rhs)),
260          __sb_(_STD::move(__rhs.__sb_))
261    {
262        ostream::set_rdbuf(&__sb_);
263    }
264
265    _LIBCPP_INLINE_VISIBILITY
266    ostrstream& operator=(ostrstream&& __rhs)
267    {
268        ostream::operator=(_STD::move(__rhs));
269        __sb_ = _STD::move(__rhs.__sb_);
270        return *this;
271    }
272#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
273
274    virtual ~ostrstream();
275
276    _LIBCPP_INLINE_VISIBILITY
277    void swap(ostrstream& __rhs)
278    {
279        ostream::swap(__rhs);
280        __sb_.swap(__rhs.__sb_);
281    }
282
283    _LIBCPP_INLINE_VISIBILITY
284    strstreambuf* rdbuf() const {return const_cast<strstreambuf*>(&__sb_);}
285    _LIBCPP_INLINE_VISIBILITY
286    void freeze(bool __freezefl = true) {__sb_.freeze(__freezefl);}
287    _LIBCPP_INLINE_VISIBILITY
288    char* str()         {return __sb_.str();}
289    _LIBCPP_INLINE_VISIBILITY
290    int pcount() const  {return __sb_.pcount();}
291
292private:
293    strstreambuf __sb_; // exposition only
294};
295
296class _LIBCPP_VISIBLE strstream
297    : public iostream
298{
299public:
300    // Types
301    typedef char                        char_type;
302    typedef char_traits<char>::int_type int_type;
303    typedef char_traits<char>::pos_type pos_type;
304    typedef char_traits<char>::off_type off_type;
305
306    // constructors/destructor
307    _LIBCPP_INLINE_VISIBILITY
308    strstream()
309        : iostream(&__sb_) {}
310    _LIBCPP_INLINE_VISIBILITY
311    strstream(char* __s, int __n, ios_base::openmode __mode = ios_base::in | ios_base::out)
312        : iostream(&__sb_),
313          __sb_(__s, __n, __s + (__mode & ios::app ? strlen(__s) : 0))
314        {}
315
316#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
317    _LIBCPP_INLINE_VISIBILITY
318    strstream(strstream&& __rhs)
319        : iostream(_STD::move(__rhs)),
320          __sb_(_STD::move(__rhs.__sb_))
321    {
322        iostream::set_rdbuf(&__sb_);
323    }
324
325    _LIBCPP_INLINE_VISIBILITY
326    strstream& operator=(strstream&& __rhs)
327    {
328        iostream::operator=(_STD::move(__rhs));
329        __sb_ = _STD::move(__rhs.__sb_);
330        return *this;
331    }
332#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
333
334    virtual ~strstream();
335
336    _LIBCPP_INLINE_VISIBILITY
337    void swap(strstream& __rhs)
338    {
339        iostream::swap(__rhs);
340        __sb_.swap(__rhs.__sb_);
341    }
342
343    // Members:
344    _LIBCPP_INLINE_VISIBILITY
345    strstreambuf* rdbuf() const {return const_cast<strstreambuf*>(&__sb_);}
346    _LIBCPP_INLINE_VISIBILITY
347    void freeze(bool __freezefl = true) {__sb_.freeze(__freezefl);}
348    _LIBCPP_INLINE_VISIBILITY
349    int pcount() const {return __sb_.pcount();}
350    _LIBCPP_INLINE_VISIBILITY
351    char* str()        {return __sb_.str();}
352
353private:
354    strstreambuf __sb_; // exposition only
355};
356
357_LIBCPP_END_NAMESPACE_STD
358
359#endif  // _LIBCPP_STRSTREAM
360