diff options
author | Howard Hinnant <hhinnant@apple.com> | 2010-05-11 23:42:16 +0400 |
---|---|---|
committer | Howard Hinnant <hhinnant@apple.com> | 2010-05-11 23:42:16 +0400 |
commit | 3e519524c118651123eecf60c2bbc5d65ad9bac3 (patch) | |
tree | b2dd4168cfe448920a602cd7d2e40f95da187153 /libcxx/include/strstream | |
parent | 9132c59d43b6c590c9bb33496eebf9f192d6857a (diff) |
libcxx initial import
llvm-svn: 103490
Diffstat (limited to 'libcxx/include/strstream')
-rw-r--r-- | libcxx/include/strstream | 332 |
1 files changed, 332 insertions, 0 deletions
diff --git a/libcxx/include/strstream b/libcxx/include/strstream new file mode 100644 index 000000000000..50f639f8c5d0 --- /dev/null +++ b/libcxx/include/strstream @@ -0,0 +1,332 @@ +// -*- C++ -*- +//===--------------------------- strstream --------------------------------===// +// +// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. 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 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); + +#ifdef _LIBCPP_MOVE + strstreambuf(strstreambuf&& __rhs); + strstreambuf& operator=(strstreambuf&& __rhs); +#endif + + 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 istrstream + : public istream +{ +public: + explicit istrstream(const char* __s) + : istream(&__sb_), __sb_(__s, 0) {} + explicit istrstream(char* __s) + : istream(&__sb_), __sb_(__s, 0) {} + istrstream(const char* __s, streamsize __n) + : istream(&__sb_), __sb_(__s, __n) {} + istrstream(char* __s, streamsize __n) + : istream(&__sb_), __sb_(__s, __n) {} + +#ifdef _LIBCPP_MOVE + istrstream(istrstream&& __rhs) + : istream(_STD::move(__rhs)), + __sb_(_STD::move(__rhs.__sb_)) + { + istream::set_rdbuf(&__sb_); + } + + istrstream& operator=(istrstream&& __rhs) + { + istream::operator=(_STD::move(__rhs)); + __sb_ = _STD::move(__rhs.__sb_); + return *this; + } +#endif + + virtual ~istrstream(); + + void swap(istrstream& __rhs) + { + istream::swap(__rhs); + __sb_.swap(__rhs.__sb_); + } + + strstreambuf* rdbuf() const {return const_cast<strstreambuf*>(&__sb_);} + char *str() {return __sb_.str();} + +private: + strstreambuf __sb_; +}; + +class ostrstream + : public ostream +{ +public: + ostrstream() + : ostream(&__sb_) {} + ostrstream(char* __s, int __n, ios_base::openmode __mode = ios_base::out) + : ostream(&__sb_), + __sb_(__s, __n, __s + (__mode & ios::app ? strlen(__s) : 0)) + {} + +#ifdef _LIBCPP_MOVE + ostrstream(ostrstream&& __rhs) + : ostream(_STD::move(__rhs)), + __sb_(_STD::move(__rhs.__sb_)) + { + ostream::set_rdbuf(&__sb_); + } + + ostrstream& operator=(ostrstream&& __rhs) + { + ostream::operator=(_STD::move(__rhs)); + __sb_ = _STD::move(__rhs.__sb_); + return *this; + } +#endif + + virtual ~ostrstream(); + + void swap(ostrstream& __rhs) + { + ostream::swap(__rhs); + __sb_.swap(__rhs.__sb_); + } + + strstreambuf* rdbuf() const {return const_cast<strstreambuf*>(&__sb_);} + void freeze(bool __freezefl = true) {__sb_.freeze(__freezefl);} + char* str() {return __sb_.str();} + int pcount() const {return __sb_.pcount();} + +private: + strstreambuf __sb_; // exposition only +}; + +class 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 + strstream() + : iostream(&__sb_) {} + 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)) + {} + +#ifdef _LIBCPP_MOVE + strstream(strstream&& __rhs) + : iostream(_STD::move(__rhs)), + __sb_(_STD::move(__rhs.__sb_)) + { + iostream::set_rdbuf(&__sb_); + } + + strstream& operator=(strstream&& __rhs) + { + iostream::operator=(_STD::move(__rhs)); + __sb_ = _STD::move(__rhs.__sb_); + return *this; + } +#endif + + virtual ~strstream(); + + void swap(strstream& __rhs) + { + iostream::swap(__rhs); + __sb_.swap(__rhs.__sb_); + } + + // Members: + strstreambuf* rdbuf() const {return const_cast<strstreambuf*>(&__sb_);} + void freeze(bool __freezefl = true) {__sb_.freeze(__freezefl);} + int pcount() const {return __sb_.pcount();} + char* str() {return __sb_.str();} + +private: + strstreambuf __sb_; // exposition only +}; + +_LIBCPP_END_NAMESPACE_STD + +#endif // _LIBCPP_STRSTREAM |