1 /* 2 * Copyright (c) 1999 3 * Silicon Graphics Computer Systems, Inc. 4 * 5 * Copyright (c) 1999 6 * Boris Fomitchev 7 * 8 * This material is provided "as is", with absolutely no warranty expressed 9 * or implied. Any use is at your own risk. 10 * 11 * Permission to use or copy this software for any purpose is hereby granted 12 * without fee, provided the above notices are retained on all copies. 13 * Permission to modify the code and to distribute modified code is granted, 14 * provided the above notices are retained, and a notice that the code was 15 * modified is included with the above copyright notice. 16 * 17 */ 18 19 20 // This header defines classes basic_stringbuf, basic_istringstream, 21 // basic_ostringstream, and basic_stringstream. These classes 22 // represent streamsbufs and streams whose sources or destinations are 23 // C++ strings. 24 25 #ifndef _STLP_INTERNAL_SSTREAM 26 #define _STLP_INTERNAL_SSTREAM 27 28 #ifndef _STLP_INTERNAL_STREAMBUF 29 # include <stl/_streambuf.h> 30 #endif 31 32 #ifndef _STLP_INTERNAL_ISTREAM 33 # include <stl/_istream.h> // Includes <ostream>, <ios>, <iosfwd> 34 #endif 35 36 #ifndef _STLP_INTERNAL_STRING_H 37 # include <stl/_string.h> 38 #endif 39 40 _STLP_BEGIN_NAMESPACE 41 42 //---------------------------------------------------------------------- 43 // This version of basic_stringbuf relies on the internal details of 44 // basic_string. It relies on the fact that, in this implementation, 45 // basic_string's iterators are pointers. It also assumes (as allowed 46 // by the standard) that _CharT is a POD type. 47 48 // We have a very small buffer for the put area, just so that we don't 49 // have to use append() for every sputc. Conceptually, the buffer 50 // immediately follows the end of the underlying string. We use this 51 // buffer when appending to write-only streambufs, but we don't use it 52 // for read-write streambufs. 53 54 template <class _CharT, class _Traits, class _Alloc> 55 class basic_stringbuf : public basic_streambuf<_CharT, _Traits> { 56 public: // Typedefs. 57 typedef _CharT char_type; 58 typedef typename _Traits::int_type int_type; 59 typedef typename _Traits::pos_type pos_type; 60 typedef typename _Traits::off_type off_type; 61 typedef _Traits traits_type; 62 63 typedef basic_streambuf<_CharT, _Traits> _Base; 64 typedef basic_stringbuf<_CharT, _Traits, _Alloc> _Self; 65 typedef basic_string<_CharT, _Traits, _Alloc> _String; 66 67 public: // Constructors, destructor. 68 explicit basic_stringbuf(ios_base::openmode __mode 69 = ios_base::in | ios_base::out); 70 explicit basic_stringbuf(const _String& __s, ios_base::openmode __mode 71 = ios_base::in | ios_base::out); 72 virtual ~basic_stringbuf(); 73 74 public: // Get or set the string. str()75 _String str() const { return _M_str; } 76 void str(const _String& __s); 77 78 protected: // Overridden virtual member functions. 79 virtual int_type underflow(); 80 virtual int_type uflow(); 81 virtual int_type pbackfail(int_type __c); 82 virtual int_type overflow(int_type __c); pbackfail()83 int_type pbackfail() {return pbackfail(_Traits::eof());} overflow()84 int_type overflow() {return overflow(_Traits::eof());} 85 86 virtual streamsize xsputn(const char_type* __s, streamsize __n); 87 virtual streamsize _M_xsputnc(char_type __c, streamsize __n); 88 89 virtual _Base* setbuf(_CharT* __buf, streamsize __n); 90 virtual pos_type seekoff(off_type __off, ios_base::seekdir __dir, 91 ios_base::openmode __mode 92 = ios_base::in | ios_base::out); 93 virtual pos_type seekpos(pos_type __pos, ios_base::openmode __mode 94 = ios_base::in | ios_base::out); 95 96 private: // Helper functions. 97 void _M_set_ptrs(); _S_start(const _String & __str)98 static _CharT* _S_start(const _String& __str) { return __CONST_CAST(_CharT*, __str.data()); } _S_finish(const _String & __str)99 static _CharT* _S_finish(const _String& __str) { return __CONST_CAST(_CharT*, __str.data()) + __str.size(); } 100 101 private: 102 ios_base::openmode _M_mode; 103 _String _M_str; 104 }; 105 106 #if defined (_STLP_USE_TEMPLATE_EXPORT) 107 _STLP_EXPORT_TEMPLATE_CLASS basic_stringbuf<char, char_traits<char>, allocator<char> >; 108 # if !defined (_STLP_NO_WCHAR_T) 109 _STLP_EXPORT_TEMPLATE_CLASS basic_stringbuf<wchar_t, char_traits<wchar_t>, allocator<wchar_t> >; 110 # endif 111 #endif /* _STLP_USE_TEMPLATE_EXPORT */ 112 113 //---------------------------------------------------------------------- 114 // Class basic_istringstream, an input stream that uses a stringbuf. 115 116 template <class _CharT, class _Traits, class _Alloc> 117 class basic_istringstream : public basic_istream<_CharT, _Traits> { 118 public: // Typedefs 119 typedef typename _Traits::char_type char_type; 120 typedef typename _Traits::int_type int_type; 121 typedef typename _Traits::pos_type pos_type; 122 typedef typename _Traits::off_type off_type; 123 typedef _Traits traits_type; 124 125 typedef basic_ios<_CharT, _Traits> _Basic_ios; 126 typedef basic_istream<_CharT, _Traits> _Base; 127 typedef basic_string<_CharT, _Traits, _Alloc> _String; 128 typedef basic_stringbuf<_CharT, _Traits, _Alloc> _Buf; 129 130 public: // Constructors, destructor. 131 basic_istringstream(ios_base::openmode __mode = ios_base::in); 132 basic_istringstream(const _String& __str, 133 ios_base::openmode __mode = ios_base::in); 134 ~basic_istringstream(); 135 136 public: // Member functions 137 rdbuf()138 basic_stringbuf<_CharT, _Traits, _Alloc>* rdbuf() const 139 { return __CONST_CAST(_Buf*,&_M_buf); } 140 str()141 _String str() const { return _M_buf.str(); } str(const _String & __s)142 void str(const _String& __s) { _M_buf.str(__s); } 143 144 private: 145 basic_stringbuf<_CharT, _Traits, _Alloc> _M_buf; 146 147 #if defined (_STLP_MSVC) && (_STLP_MSVC >= 1300 && _STLP_MSVC <= 1310) 148 typedef basic_istringstream<_CharT, _Traits> _Self; 149 //explicitely defined as private to avoid warnings: 150 basic_istringstream(_Self const&); 151 _Self& operator = (_Self const&); 152 #endif 153 }; 154 155 156 //---------------------------------------------------------------------- 157 // Class basic_ostringstream, an output stream that uses a stringbuf. 158 159 template <class _CharT, class _Traits, class _Alloc> 160 class basic_ostringstream : public basic_ostream<_CharT, _Traits> { 161 public: // Typedefs 162 typedef typename _Traits::char_type char_type; 163 typedef typename _Traits::int_type int_type; 164 typedef typename _Traits::pos_type pos_type; 165 typedef typename _Traits::off_type off_type; 166 typedef _Traits traits_type; 167 168 typedef basic_ios<_CharT, _Traits> _Basic_ios; 169 typedef basic_ostream<_CharT, _Traits> _Base; 170 typedef basic_string<_CharT, _Traits, _Alloc> _String; 171 typedef basic_stringbuf<_CharT, _Traits, _Alloc> _Buf; 172 173 public: // Constructors, destructor. 174 basic_ostringstream(ios_base::openmode __mode = ios_base::out); 175 basic_ostringstream(const _String& __str, 176 ios_base::openmode __mode = ios_base::out); 177 ~basic_ostringstream(); 178 179 public: // Member functions. 180 rdbuf()181 basic_stringbuf<_CharT, _Traits, _Alloc>* rdbuf() const 182 { return __CONST_CAST(_Buf*,&_M_buf); } 183 str()184 _String str() const { return _M_buf.str(); } str(const _String & __s)185 void str(const _String& __s) { _M_buf.str(__s); } // dwa 02/07/00 - BUG STOMPER DAVE 186 187 188 private: 189 basic_stringbuf<_CharT, _Traits, _Alloc> _M_buf; 190 191 #if defined (_STLP_MSVC) && (_STLP_MSVC >= 1300 && _STLP_MSVC <= 1310) 192 typedef basic_ostringstream<_CharT, _Traits> _Self; 193 //explicitely defined as private to avoid warnings: 194 basic_ostringstream(_Self const&); 195 _Self& operator = (_Self const&); 196 #endif 197 }; 198 199 200 //---------------------------------------------------------------------- 201 // Class basic_stringstream, a bidirectional stream that uses a stringbuf. 202 203 template <class _CharT, class _Traits, class _Alloc> 204 class basic_stringstream : public basic_iostream<_CharT, _Traits> { 205 public: // Typedefs 206 typedef typename _Traits::char_type char_type; 207 typedef typename _Traits::int_type int_type; 208 typedef typename _Traits::pos_type pos_type; 209 typedef typename _Traits::off_type off_type; 210 typedef _Traits traits_type; 211 212 typedef basic_ios<_CharT, _Traits> _Basic_ios; 213 typedef basic_iostream<_CharT, _Traits> _Base; 214 typedef basic_string<_CharT, _Traits, _Alloc> _String; 215 typedef basic_stringbuf<_CharT, _Traits, _Alloc> _Buf; 216 217 typedef ios_base::openmode openmode; 218 219 public: // Constructors, destructor. 220 basic_stringstream(openmode __mod = ios_base::in | ios_base::out); 221 basic_stringstream(const _String& __str, 222 openmode __mod = ios_base::in | ios_base::out); 223 ~basic_stringstream(); 224 225 public: // Member functions. 226 rdbuf()227 basic_stringbuf<_CharT, _Traits, _Alloc>* rdbuf() const 228 { return __CONST_CAST(_Buf*,&_M_buf); } 229 str()230 _String str() const { return _M_buf.str(); } str(const _String & __s)231 void str(const _String& __s) { _M_buf.str(__s); } 232 233 private: 234 basic_stringbuf<_CharT, _Traits, _Alloc> _M_buf; 235 236 #if defined (_STLP_MSVC) && (_STLP_MSVC >= 1300 && _STLP_MSVC <= 1310) 237 typedef basic_stringstream<_CharT, _Traits> _Self; 238 //explicitely defined as private to avoid warnings: 239 basic_stringstream(_Self const&); 240 _Self& operator = (_Self const&); 241 #endif 242 }; 243 244 245 #if defined (_STLP_USE_TEMPLATE_EXPORT) 246 _STLP_EXPORT_TEMPLATE_CLASS basic_istringstream<char, char_traits<char>, allocator<char> >; 247 _STLP_EXPORT_TEMPLATE_CLASS basic_ostringstream<char, char_traits<char>, allocator<char> >; 248 _STLP_EXPORT_TEMPLATE_CLASS basic_stringstream<char, char_traits<char>, allocator<char> >; 249 # if !defined (_STLP_NO_WCHAR_T) 250 _STLP_EXPORT_TEMPLATE_CLASS basic_istringstream<wchar_t, char_traits<wchar_t>, allocator<wchar_t> >; 251 _STLP_EXPORT_TEMPLATE_CLASS basic_ostringstream<wchar_t, char_traits<wchar_t>, allocator<wchar_t> >; 252 _STLP_EXPORT_TEMPLATE_CLASS basic_stringstream<wchar_t, char_traits<wchar_t>, allocator<wchar_t> >; 253 # endif 254 #endif /* _STLP_USE_TEMPLATE_EXPORT */ 255 256 _STLP_END_NAMESPACE 257 258 #if defined (_STLP_EXPOSE_STREAM_IMPLEMENTATION) && !defined (_STLP_LINK_TIME_INSTANTIATION) 259 # include <stl/_sstream.c> 260 #endif 261 262 #endif /* _STLP_INTERNAL_SSTREAM */ 263 264 // Local Variables: 265 // mode:C++ 266 // End: 267