include/strstream - third_party/libcxx - Git at Google

 // -*- C++ -*-
 //===--------------------------- strstream --------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

 #ifndef _LIBCPP_STRSTREAM
 #define _LIBCPP_STRSTREAM

 /*
     strstream synopsis

 class strstreambuf
     : public basic_streambuf<char>
 {
 public:
     explicit strstreambuf(streamsize alsize_arg = 0);
     strstreambuf(void* (*palloc_arg)(size_t), void (*pfree_arg)(void*));
     strstreambuf(char* gnext_arg, streamsize n, char* pbeg_arg = 0);
     strstreambuf(const char* gnext_arg, streamsize n);

     strstreambuf(signed char* gnext_arg, streamsize n, signed char* pbeg_arg = 0);
     strstreambuf(const signed char* gnext_arg, streamsize n);
     strstreambuf(unsigned char* gnext_arg, streamsize n, unsigned char* pbeg_arg = 0);
     strstreambuf(const unsigned char* gnext_arg, streamsize n);

     strstreambuf(strstreambuf&& rhs);
     strstreambuf& operator=(strstreambuf&& rhs);

     virtual ~strstreambuf();

     void swap(strstreambuf& rhs);

     void freeze(bool freezefl = true);
     char* str();
     int pcount() const;

 protected:
     virtual int_type overflow (int_type c = EOF);
     virtual int_type pbackfail(int_type c = EOF);
     virtual int_type underflow();
     virtual pos_type seekoff(off_type off, ios_base::seekdir way,
                              ios_base::openmode which = ios_base::in | ios_base::out);
     virtual pos_type seekpos(pos_type sp,
                              ios_base::openmode which = ios_base::in | ios_base::out);
     virtual streambuf* setbuf(char* s, streamsize n);

 private:
     typedef T1 strstate;                // exposition only
     static const strstate allocated;    // exposition only
     static const strstate constant;     // exposition only
     static const strstate dynamic;      // exposition only
     static const strstate frozen;       // exposition only
     strstate strmode;                   // exposition only
     streamsize alsize;                  // exposition only
     void* (*palloc)(size_t);            // exposition only
     void (*pfree)(void*);               // exposition only
 };

 class istrstream
     : public basic_istream<char>
 {
 public:
     explicit istrstream(const char* s);
     explicit istrstream(char* s);
     istrstream(const char* s, streamsize n);
     istrstream(char* s, streamsize n);

     virtual ~istrstream();

     strstreambuf* rdbuf() const;
     char *str();

 private:
     strstreambuf sb; // exposition only
 };

 class ostrstream
     : public basic_ostream<char>
 {
 public:
     ostrstream();
     ostrstream(char* s, int n, ios_base::openmode mode = ios_base::out);

     virtual ~ostrstream();

     strstreambuf* rdbuf() const;
     void freeze(bool freezefl = true);
     char* str();
     int pcount() const;

 private:
     strstreambuf sb; // exposition only
 };

 class strstream
     : public basic_iostream<char>
 {
 public:
     // Types
     typedef char                        char_type;
     typedef char_traits<char>::int_type int_type;
     typedef char_traits<char>::pos_type pos_type;
     typedef char_traits<char>::off_type off_type;

     // constructors/destructor
     strstream();
     strstream(char* s, int n, ios_base::openmode mode = ios_base::in | ios_base::out);

     virtual ~strstream();

     // Members:
     strstreambuf* rdbuf() const;
     void freeze(bool freezefl = true);
     int pcount() const;
     char* str();

 private:
     strstreambuf sb; // exposition only
 };

 }  // std

 */

 #include <__config>
 #include <ostream>
 #include <istream>

 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif

 _LIBCPP_BEGIN_NAMESPACE_STD

 class _LIBCPP_TYPE_VIS strstreambuf
     : public streambuf
 {
 public:
     explicit strstreambuf(streamsize __alsize = 0);
     strstreambuf(void* (*__palloc)(size_t), void (*__pfree)(void*));
     strstreambuf(char* __gnext, streamsize __n, char* __pbeg = 0);
     strstreambuf(const char* __gnext, streamsize __n);

     strstreambuf(signed char* __gnext, streamsize __n, signed char* __pbeg = 0);
     strstreambuf(const signed char* __gnext, streamsize __n);
     strstreambuf(unsigned char* __gnext, streamsize __n, unsigned char* __pbeg = 0);
     strstreambuf(const unsigned char* __gnext, streamsize __n);

 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
     strstreambuf(strstreambuf&& __rhs);
     _LIBCPP_INLINE_VISIBILITY
     strstreambuf& operator=(strstreambuf&& __rhs);
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES

     virtual ~strstreambuf();

     void swap(strstreambuf& __rhs);

     void freeze(bool __freezefl = true);
     char* str();
     int pcount() const;

 protected:
     virtual int_type overflow (int_type __c = EOF);
     virtual int_type pbackfail(int_type __c = EOF);
     virtual int_type underflow();
     virtual pos_type seekoff(off_type __off, ios_base::seekdir __way,
                              ios_base::openmode __which = ios_base::in | ios_base::out);
     virtual pos_type seekpos(pos_type __sp,
                              ios_base::openmode __which = ios_base::in | ios_base::out);

 private:
     typedef unsigned __mode_type;
     static const __mode_type __allocated = 0x01;
     static const __mode_type __constant  = 0x02;
     static const __mode_type __dynamic   = 0x04;
     static const __mode_type __frozen    = 0x08;
     static const streamsize    __default_alsize = 4096;

     __mode_type __strmode_;
     streamsize __alsize_;
     void* (*__palloc_)(size_t);
     void (*__pfree_)(void*);

     void __init(char* __gnext, streamsize __n, char* __pbeg);
 };

 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES

 inline _LIBCPP_INLINE_VISIBILITY
 strstreambuf::strstreambuf(strstreambuf&& __rhs)
     : streambuf(__rhs),
       __strmode_(__rhs.__strmode_),
       __alsize_(__rhs.__alsize_),
       __palloc_(__rhs.__palloc_),
       __pfree_(__rhs.__pfree_)
 {
     __rhs.setg(nullptr, nullptr, nullptr);
     __rhs.setp(nullptr, nullptr);
 }

 inline _LIBCPP_INLINE_VISIBILITY
 strstreambuf&
 strstreambuf::operator=(strstreambuf&& __rhs)
 {
     if (eback() && (__strmode_ & __allocated) != 0 && (__strmode_ & __frozen) == 0)
     {
         if (__pfree_)
             __pfree_(eback());
         else
             delete [] eback();
     }
     streambuf::operator=(__rhs);
     __strmode_ = __rhs.__strmode_;
     __alsize_ = __rhs.__alsize_;
     __palloc_ = __rhs.__palloc_;
     __pfree_ = __rhs.__pfree_;
     __rhs.setg(nullptr, nullptr, nullptr);
     __rhs.setp(nullptr, nullptr);
     return *this;
 }

 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES

 class _LIBCPP_TYPE_VIS istrstream
     : public istream
 {
 public:
     _LIBCPP_INLINE_VISIBILITY
     explicit istrstream(const char* __s)
         : istream(&__sb_), __sb_(__s, 0) {}
     _LIBCPP_INLINE_VISIBILITY
     explicit istrstream(char* __s)
         : istream(&__sb_), __sb_(__s, 0) {}
     _LIBCPP_INLINE_VISIBILITY
     istrstream(const char* __s, streamsize __n)
         : istream(&__sb_), __sb_(__s, __n) {}
     _LIBCPP_INLINE_VISIBILITY
     istrstream(char* __s, streamsize __n)
         : istream(&__sb_), __sb_(__s, __n) {}

 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
     istrstream(istrstream&& __rhs)
         : istream(_VSTD::move(__rhs)),
           __sb_(_VSTD::move(__rhs.__sb_))
     {
         istream::set_rdbuf(&__sb_);
     }

     _LIBCPP_INLINE_VISIBILITY
     istrstream& operator=(istrstream&& __rhs)
     {
         istream::operator=(_VSTD::move(__rhs));
         __sb_ = _VSTD::move(__rhs.__sb_);
         return *this;
     }
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES

     virtual ~istrstream();

     _LIBCPP_INLINE_VISIBILITY
     void swap(istrstream& __rhs)
     {
         istream::swap(__rhs);
         __sb_.swap(__rhs.__sb_);
     }

     _LIBCPP_INLINE_VISIBILITY
     strstreambuf* rdbuf() const {return const_cast<strstreambuf*>(&__sb_);}
     _LIBCPP_INLINE_VISIBILITY
     char *str() {return __sb_.str();}

 private:
     strstreambuf __sb_;
 };

 class _LIBCPP_TYPE_VIS ostrstream
     : public ostream
 {
 public:
     _LIBCPP_INLINE_VISIBILITY
     ostrstream()
         : ostream(&__sb_) {}
     _LIBCPP_INLINE_VISIBILITY
     ostrstream(char* __s, int __n, ios_base::openmode __mode = ios_base::out)
         : ostream(&__sb_),
           __sb_(__s, __n, __s + (__mode & ios::app ? strlen(__s) : 0))
         {}

 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
     ostrstream(ostrstream&& __rhs)
         : ostream(_VSTD::move(__rhs)),
           __sb_(_VSTD::move(__rhs.__sb_))
     {
         ostream::set_rdbuf(&__sb_);
     }

     _LIBCPP_INLINE_VISIBILITY
     ostrstream& operator=(ostrstream&& __rhs)
     {
         ostream::operator=(_VSTD::move(__rhs));
         __sb_ = _VSTD::move(__rhs.__sb_);
         return *this;
     }
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES

     virtual ~ostrstream();

     _LIBCPP_INLINE_VISIBILITY
     void swap(ostrstream& __rhs)
     {
         ostream::swap(__rhs);
         __sb_.swap(__rhs.__sb_);
     }

     _LIBCPP_INLINE_VISIBILITY
     strstreambuf* rdbuf() const {return const_cast<strstreambuf*>(&__sb_);}
     _LIBCPP_INLINE_VISIBILITY
     void freeze(bool __freezefl = true) {__sb_.freeze(__freezefl);}
     _LIBCPP_INLINE_VISIBILITY
     char* str()         {return __sb_.str();}
     _LIBCPP_INLINE_VISIBILITY
     int pcount() const  {return __sb_.pcount();}

 private:
     strstreambuf __sb_; // exposition only
 };

 class _LIBCPP_TYPE_VIS strstream
     : public iostream
 {
 public:
     // Types
     typedef char                        char_type;
     typedef char_traits<char>::int_type int_type;
     typedef char_traits<char>::pos_type pos_type;
     typedef char_traits<char>::off_type off_type;

     // constructors/destructor
     _LIBCPP_INLINE_VISIBILITY
     strstream()
         : iostream(&__sb_) {}
     _LIBCPP_INLINE_VISIBILITY
     strstream(char* __s, int __n, ios_base::openmode __mode = ios_base::in | ios_base::out)
         : iostream(&__sb_),
           __sb_(__s, __n, __s + (__mode & ios::app ? strlen(__s) : 0))
         {}

 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
     strstream(strstream&& __rhs)
         : iostream(_VSTD::move(__rhs)),
           __sb_(_VSTD::move(__rhs.__sb_))
     {
         iostream::set_rdbuf(&__sb_);
     }

     _LIBCPP_INLINE_VISIBILITY
     strstream& operator=(strstream&& __rhs)
     {
         iostream::operator=(_VSTD::move(__rhs));
         __sb_ = _VSTD::move(__rhs.__sb_);
         return *this;
     }
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES

     virtual ~strstream();

     _LIBCPP_INLINE_VISIBILITY
     void swap(strstream& __rhs)
     {
         iostream::swap(__rhs);
         __sb_.swap(__rhs.__sb_);
     }

     // Members:
     _LIBCPP_INLINE_VISIBILITY
     strstreambuf* rdbuf() const {return const_cast<strstreambuf*>(&__sb_);}
     _LIBCPP_INLINE_VISIBILITY
     void freeze(bool __freezefl = true) {__sb_.freeze(__freezefl);}
     _LIBCPP_INLINE_VISIBILITY
     int pcount() const {return __sb_.pcount();}
     _LIBCPP_INLINE_VISIBILITY
     char* str()        {return __sb_.str();}

 private:
     strstreambuf __sb_; // exposition only
 };

 _LIBCPP_END_NAMESPACE_STD

 #endif  // _LIBCPP_STRSTREAM
	// -- C++ --
	//===--------------------------- strstream --------------------------------===//
	//
	// The LLVM Compiler Infrastructure
	//
	// This file is dual licensed under the MIT and the University of Illinois Open
	// Source Licenses. See LICENSE.TXT for details.
	//
	//===----------------------------------------------------------------------===//

	#ifndef _LIBCPP_STRSTREAM
	#define _LIBCPP_STRSTREAM

	/*
	strstream synopsis

	class strstreambuf
	: public basic_streambuf<char>
	{
	public:
	explicit strstreambuf(streamsize alsize_arg = 0);
	strstreambuf(void* (palloc_arg)(size_t), void (pfree_arg)(void*));
	strstreambuf(char* gnext_arg, streamsize n, char* pbeg_arg = 0);
	strstreambuf(const char* gnext_arg, streamsize n);

	strstreambuf(signed char* gnext_arg, streamsize n, signed char* pbeg_arg = 0);
	strstreambuf(const signed char* gnext_arg, streamsize n);
	strstreambuf(unsigned char* gnext_arg, streamsize n, unsigned char* pbeg_arg = 0);
	strstreambuf(const unsigned char* gnext_arg, streamsize n);

	strstreambuf(strstreambuf&& rhs);
	strstreambuf& operator=(strstreambuf&& rhs);

	virtual ~strstreambuf();

	void swap(strstreambuf& rhs);

	void freeze(bool freezefl = true);
	char* str();
	int pcount() const;

	protected:
	virtual int_type overflow (int_type c = EOF);
	virtual int_type pbackfail(int_type c = EOF);
	virtual int_type underflow();
	virtual pos_type seekoff(off_type off, ios_base::seekdir way,
	ios_base::openmode which = ios_base::in \| ios_base::out);
	virtual pos_type seekpos(pos_type sp,
	ios_base::openmode which = ios_base::in \| ios_base::out);
	virtual streambuf* setbuf(char* s, streamsize n);

	private:
	typedef T1 strstate; // exposition only
	static const strstate allocated; // exposition only
	static const strstate constant; // exposition only
	static const strstate dynamic; // exposition only
	static const strstate frozen; // exposition only
	strstate strmode; // exposition only
	streamsize alsize; // exposition only
	void* (*palloc)(size_t); // exposition only
	void (pfree)(void); // exposition only
	};

	class istrstream
	: public basic_istream<char>
	{
	public:
	explicit istrstream(const char* s);
	explicit istrstream(char* s);
	istrstream(const char* s, streamsize n);
	istrstream(char* s, streamsize n);

	virtual ~istrstream();

	strstreambuf* rdbuf() const;
	char *str();

	private:
	strstreambuf sb; // exposition only
	};

	class ostrstream
	: public basic_ostream<char>
	{
	public:
	ostrstream();
	ostrstream(char* s, int n, ios_base::openmode mode = ios_base::out);

	virtual ~ostrstream();

	strstreambuf* rdbuf() const;
	void freeze(bool freezefl = true);
	char* str();
	int pcount() const;

	private:
	strstreambuf sb; // exposition only
	};

	class strstream
	: public basic_iostream<char>
	{
	public:
	// Types
	typedef char char_type;
	typedef char_traits<char>::int_type int_type;
	typedef char_traits<char>::pos_type pos_type;
	typedef char_traits<char>::off_type off_type;

	// constructors/destructor
	strstream();
	strstream(char* s, int n, ios_base::openmode mode = ios_base::in \| ios_base::out);

	virtual ~strstream();

	// Members:
	strstreambuf* rdbuf() const;
	void freeze(bool freezefl = true);
	int pcount() const;
	char* str();

	private:
	strstreambuf sb; // exposition only
	};

	} // std

	*/

	#include <__config>
	#include <ostream>
	#include <istream>

	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
	#pragma GCC system_header
	#endif

	_LIBCPP_BEGIN_NAMESPACE_STD

	class _LIBCPP_TYPE_VIS strstreambuf
	: public streambuf
	{
	public:
	explicit strstreambuf(streamsize __alsize = 0);
	strstreambuf(void* (__palloc)(size_t), void (__pfree)(void*));
	strstreambuf(char* __gnext, streamsize __n, char* __pbeg = 0);
	strstreambuf(const char* __gnext, streamsize __n);

	strstreambuf(signed char* __gnext, streamsize __n, signed char* __pbeg = 0);
	strstreambuf(const signed char* __gnext, streamsize __n);
	strstreambuf(unsigned char* __gnext, streamsize __n, unsigned char* __pbeg = 0);
	strstreambuf(const unsigned char* __gnext, streamsize __n);

	#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
	_LIBCPP_INLINE_VISIBILITY
	strstreambuf(strstreambuf&& __rhs);
	_LIBCPP_INLINE_VISIBILITY
	strstreambuf& operator=(strstreambuf&& __rhs);
	#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES

	virtual ~strstreambuf();

	void swap(strstreambuf& __rhs);

	void freeze(bool __freezefl = true);
	char* str();
	int pcount() const;

	protected:
	virtual int_type overflow (int_type __c = EOF);
	virtual int_type pbackfail(int_type __c = EOF);
	virtual int_type underflow();
	virtual pos_type seekoff(off_type __off, ios_base::seekdir __way,
	ios_base::openmode __which = ios_base::in \| ios_base::out);
	virtual pos_type seekpos(pos_type __sp,
	ios_base::openmode __which = ios_base::in \| ios_base::out);

	private:
	typedef unsigned __mode_type;
	static const __mode_type __allocated = 0x01;
	static const __mode_type __constant = 0x02;
	static const __mode_type __dynamic = 0x04;
	static const __mode_type __frozen = 0x08;
	static const streamsize __default_alsize = 4096;

	__mode_type __strmode_;
	streamsize __alsize_;
	void* (*__palloc_)(size_t);
	void (__pfree_)(void);

	void __init(char* __gnext, streamsize __n, char* __pbeg);
	};

	#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES

	inline _LIBCPP_INLINE_VISIBILITY
	strstreambuf::strstreambuf(strstreambuf&& __rhs)
	: streambuf(__rhs),
	__strmode_(__rhs.__strmode_),
	__alsize_(__rhs.__alsize_),
	__palloc_(__rhs.__palloc_),
	__pfree_(__rhs.__pfree_)
	{
	__rhs.setg(nullptr, nullptr, nullptr);
	__rhs.setp(nullptr, nullptr);
	}

	inline _LIBCPP_INLINE_VISIBILITY
	strstreambuf&
	strstreambuf::operator=(strstreambuf&& __rhs)
	{
	if (eback() && (__strmode_ & __allocated) != 0 && (__strmode_ & __frozen) == 0)
	{
	if (__pfree_)
	__pfree_(eback());
	else
	delete [] eback();
	}
	streambuf::operator=(__rhs);
	__strmode_ = __rhs.__strmode_;
	__alsize_ = __rhs.__alsize_;
	__palloc_ = __rhs.__palloc_;
	__pfree_ = __rhs.__pfree_;
	__rhs.setg(nullptr, nullptr, nullptr);
	__rhs.setp(nullptr, nullptr);
	return *this;
	}

	#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES

	class _LIBCPP_TYPE_VIS istrstream
	: public istream
	{
	public:
	_LIBCPP_INLINE_VISIBILITY
	explicit istrstream(const char* __s)
	: istream(&__sb_), __sb_(__s, 0) {}
	_LIBCPP_INLINE_VISIBILITY
	explicit istrstream(char* __s)
	: istream(&__sb_), __sb_(__s, 0) {}
	_LIBCPP_INLINE_VISIBILITY
	istrstream(const char* __s, streamsize __n)
	: istream(&__sb_), __sb_(__s, __n) {}
	_LIBCPP_INLINE_VISIBILITY
	istrstream(char* __s, streamsize __n)
	: istream(&__sb_), __sb_(__s, __n) {}

	#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
	_LIBCPP_INLINE_VISIBILITY
	istrstream(istrstream&& __rhs)
	: istream(_VSTD::move(__rhs)),
	__sb_(_VSTD::move(__rhs.__sb_))
	{
	istream::set_rdbuf(&__sb_);
	}

	_LIBCPP_INLINE_VISIBILITY
	istrstream& operator=(istrstream&& __rhs)
	{
	istream::operator=(_VSTD::move(__rhs));
	__sb_ = _VSTD::move(__rhs.__sb_);
	return *this;
	}
	#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES

	virtual ~istrstream();

	_LIBCPP_INLINE_VISIBILITY
	void swap(istrstream& __rhs)
	{
	istream::swap(__rhs);
	__sb_.swap(__rhs.__sb_);
	}

	_LIBCPP_INLINE_VISIBILITY
	strstreambuf* rdbuf() const {return const_cast<strstreambuf*>(&__sb_);}
	_LIBCPP_INLINE_VISIBILITY
	char *str() {return __sb_.str();}

	private:
	strstreambuf __sb_;
	};

	class _LIBCPP_TYPE_VIS ostrstream
	: public ostream
	{
	public:
	_LIBCPP_INLINE_VISIBILITY
	ostrstream()
	: ostream(&__sb_) {}
	_LIBCPP_INLINE_VISIBILITY
	ostrstream(char* __s, int __n, ios_base::openmode __mode = ios_base::out)
	: ostream(&__sb_),
	__sb_(__s, __n, __s + (__mode & ios::app ? strlen(__s) : 0))
	{}

	#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
	_LIBCPP_INLINE_VISIBILITY
	ostrstream(ostrstream&& __rhs)
	: ostream(_VSTD::move(__rhs)),
	__sb_(_VSTD::move(__rhs.__sb_))
	{
	ostream::set_rdbuf(&__sb_);
	}

	_LIBCPP_INLINE_VISIBILITY
	ostrstream& operator=(ostrstream&& __rhs)
	{
	ostream::operator=(_VSTD::move(__rhs));
	__sb_ = _VSTD::move(__rhs.__sb_);
	return *this;
	}
	#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES

	virtual ~ostrstream();

	_LIBCPP_INLINE_VISIBILITY
	void swap(ostrstream& __rhs)
	{
	ostream::swap(__rhs);
	__sb_.swap(__rhs.__sb_);
	}

	_LIBCPP_INLINE_VISIBILITY
	strstreambuf* rdbuf() const {return const_cast<strstreambuf*>(&__sb_);}
	_LIBCPP_INLINE_VISIBILITY
	void freeze(bool __freezefl = true) {__sb_.freeze(__freezefl);}
	_LIBCPP_INLINE_VISIBILITY
	char* str() {return __sb_.str();}
	_LIBCPP_INLINE_VISIBILITY
	int pcount() const {return __sb_.pcount();}

	private:
	strstreambuf __sb_; // exposition only
	};

	class _LIBCPP_TYPE_VIS strstream
	: public iostream
	{
	public:
	// Types
	typedef char char_type;
	typedef char_traits<char>::int_type int_type;
	typedef char_traits<char>::pos_type pos_type;
	typedef char_traits<char>::off_type off_type;

	// constructors/destructor
	_LIBCPP_INLINE_VISIBILITY
	strstream()
	: iostream(&__sb_) {}
	_LIBCPP_INLINE_VISIBILITY
	strstream(char* __s, int __n, ios_base::openmode __mode = ios_base::in \| ios_base::out)
	: iostream(&__sb_),
	__sb_(__s, __n, __s + (__mode & ios::app ? strlen(__s) : 0))
	{}

	#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
	_LIBCPP_INLINE_VISIBILITY
	strstream(strstream&& __rhs)
	: iostream(_VSTD::move(__rhs)),
	__sb_(_VSTD::move(__rhs.__sb_))
	{
	iostream::set_rdbuf(&__sb_);
	}

	_LIBCPP_INLINE_VISIBILITY
	strstream& operator=(strstream&& __rhs)
	{
	iostream::operator=(_VSTD::move(__rhs));
	__sb_ = _VSTD::move(__rhs.__sb_);
	return *this;
	}
	#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES

	virtual ~strstream();

	_LIBCPP_INLINE_VISIBILITY
	void swap(strstream& __rhs)
	{
	iostream::swap(__rhs);
	__sb_.swap(__rhs.__sb_);
	}

	// Members:
	_LIBCPP_INLINE_VISIBILITY
	strstreambuf* rdbuf() const {return const_cast<strstreambuf*>(&__sb_);}
	_LIBCPP_INLINE_VISIBILITY
	void freeze(bool __freezefl = true) {__sb_.freeze(__freezefl);}
	_LIBCPP_INLINE_VISIBILITY
	int pcount() const {return __sb_.pcount();}
	_LIBCPP_INLINE_VISIBILITY
	char* str() {return __sb_.str();}

	private:
	strstreambuf __sb_; // exposition only
	};

	_LIBCPP_END_NAMESPACE_STD

	#endif // _LIBCPP_STRSTREAM