diff options
Diffstat (limited to 'tests/libcxx/include/strstream')
| -rw-r--r-- | tests/libcxx/include/strstream | 359 |
1 files changed, 359 insertions, 0 deletions
diff --git a/tests/libcxx/include/strstream b/tests/libcxx/include/strstream new file mode 100644 index 00000000..6e603654 --- /dev/null +++ b/tests/libcxx/include/strstream @@ -0,0 +1,359 @@ +// -*- 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> + +#pragma GCC system_header + +_LIBCPP_BEGIN_NAMESPACE_STD + +class _LIBCPP_VISIBLE 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 + strstreambuf(strstreambuf&& __rhs); + 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); +}; + +class _LIBCPP_VISIBLE 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(_STD::move(__rhs)), + __sb_(_STD::move(__rhs.__sb_)) + { + istream::set_rdbuf(&__sb_); + } + + _LIBCPP_INLINE_VISIBILITY + istrstream& operator=(istrstream&& __rhs) + { + istream::operator=(_STD::move(__rhs)); + __sb_ = _STD::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_VISIBLE 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(_STD::move(__rhs)), + __sb_(_STD::move(__rhs.__sb_)) + { + ostream::set_rdbuf(&__sb_); + } + + _LIBCPP_INLINE_VISIBILITY + ostrstream& operator=(ostrstream&& __rhs) + { + ostream::operator=(_STD::move(__rhs)); + __sb_ = _STD::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_VISIBLE 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(_STD::move(__rhs)), + __sb_(_STD::move(__rhs.__sb_)) + { + iostream::set_rdbuf(&__sb_); + } + + _LIBCPP_INLINE_VISIBILITY + strstream& operator=(strstream&& __rhs) + { + iostream::operator=(_STD::move(__rhs)); + __sb_ = _STD::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 |