include/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