OLD | NEW |
(Empty) | |
| 1 // -*- C++ -*- |
| 2 //===--------------------------- strstream --------------------------------===// |
| 3 // |
| 4 // The LLVM Compiler Infrastructure |
| 5 // |
| 6 // This file is dual licensed under the MIT and the University of Illinois Open |
| 7 // Source Licenses. See LICENSE.TXT for details. |
| 8 // |
| 9 //===----------------------------------------------------------------------===// |
| 10 |
| 11 #ifndef _LIBCPP_STRSTREAM |
| 12 #define _LIBCPP_STRSTREAM |
| 13 |
| 14 /* |
| 15 strstream synopsis |
| 16 |
| 17 class strstreambuf |
| 18 : public basic_streambuf<char> |
| 19 { |
| 20 public: |
| 21 explicit strstreambuf(streamsize alsize_arg = 0); |
| 22 strstreambuf(void* (*palloc_arg)(size_t), void (*pfree_arg)(void*)); |
| 23 strstreambuf(char* gnext_arg, streamsize n, char* pbeg_arg = 0); |
| 24 strstreambuf(const char* gnext_arg, streamsize n); |
| 25 |
| 26 strstreambuf(signed char* gnext_arg, streamsize n, signed char* pbeg_arg = 0
); |
| 27 strstreambuf(const signed char* gnext_arg, streamsize n); |
| 28 strstreambuf(unsigned char* gnext_arg, streamsize n, unsigned char* pbeg_arg
= 0); |
| 29 strstreambuf(const unsigned char* gnext_arg, streamsize n); |
| 30 |
| 31 strstreambuf(strstreambuf&& rhs); |
| 32 strstreambuf& operator=(strstreambuf&& rhs); |
| 33 |
| 34 virtual ~strstreambuf(); |
| 35 |
| 36 void swap(strstreambuf& rhs); |
| 37 |
| 38 void freeze(bool freezefl = true); |
| 39 char* str(); |
| 40 int pcount() const; |
| 41 |
| 42 protected: |
| 43 virtual int_type overflow (int_type c = EOF); |
| 44 virtual int_type pbackfail(int_type c = EOF); |
| 45 virtual int_type underflow(); |
| 46 virtual pos_type seekoff(off_type off, ios_base::seekdir way, |
| 47 ios_base::openmode which = ios_base::in | ios_base:
:out); |
| 48 virtual pos_type seekpos(pos_type sp, |
| 49 ios_base::openmode which = ios_base::in | ios_base:
:out); |
| 50 virtual streambuf* setbuf(char* s, streamsize n); |
| 51 |
| 52 private: |
| 53 typedef T1 strstate; // exposition only |
| 54 static const strstate allocated; // exposition only |
| 55 static const strstate constant; // exposition only |
| 56 static const strstate dynamic; // exposition only |
| 57 static const strstate frozen; // exposition only |
| 58 strstate strmode; // exposition only |
| 59 streamsize alsize; // exposition only |
| 60 void* (*palloc)(size_t); // exposition only |
| 61 void (*pfree)(void*); // exposition only |
| 62 }; |
| 63 |
| 64 class istrstream |
| 65 : public basic_istream<char> |
| 66 { |
| 67 public: |
| 68 explicit istrstream(const char* s); |
| 69 explicit istrstream(char* s); |
| 70 istrstream(const char* s, streamsize n); |
| 71 istrstream(char* s, streamsize n); |
| 72 |
| 73 virtual ~istrstream(); |
| 74 |
| 75 strstreambuf* rdbuf() const; |
| 76 char *str(); |
| 77 |
| 78 private: |
| 79 strstreambuf sb; // exposition only |
| 80 }; |
| 81 |
| 82 class ostrstream |
| 83 : public basic_ostream<char> |
| 84 { |
| 85 public: |
| 86 ostrstream(); |
| 87 ostrstream(char* s, int n, ios_base::openmode mode = ios_base::out); |
| 88 |
| 89 virtual ~ostrstream(); |
| 90 |
| 91 strstreambuf* rdbuf() const; |
| 92 void freeze(bool freezefl = true); |
| 93 char* str(); |
| 94 int pcount() const; |
| 95 |
| 96 private: |
| 97 strstreambuf sb; // exposition only |
| 98 }; |
| 99 |
| 100 class strstream |
| 101 : public basic_iostream<char> |
| 102 { |
| 103 public: |
| 104 // Types |
| 105 typedef char char_type; |
| 106 typedef char_traits<char>::int_type int_type; |
| 107 typedef char_traits<char>::pos_type pos_type; |
| 108 typedef char_traits<char>::off_type off_type; |
| 109 |
| 110 // constructors/destructor |
| 111 strstream(); |
| 112 strstream(char* s, int n, ios_base::openmode mode = ios_base::in | ios_base:
:out); |
| 113 |
| 114 virtual ~strstream(); |
| 115 |
| 116 // Members: |
| 117 strstreambuf* rdbuf() const; |
| 118 void freeze(bool freezefl = true); |
| 119 int pcount() const; |
| 120 char* str(); |
| 121 |
| 122 private: |
| 123 strstreambuf sb; // exposition only |
| 124 }; |
| 125 |
| 126 } // std |
| 127 |
| 128 */ |
| 129 |
| 130 #include <__config> |
| 131 #include <ostream> |
| 132 #include <istream> |
| 133 |
| 134 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) |
| 135 #pragma GCC system_header |
| 136 #endif |
| 137 |
| 138 _LIBCPP_BEGIN_NAMESPACE_STD |
| 139 |
| 140 class _LIBCPP_TYPE_VIS strstreambuf |
| 141 : public streambuf |
| 142 { |
| 143 public: |
| 144 explicit strstreambuf(streamsize __alsize = 0); |
| 145 strstreambuf(void* (*__palloc)(size_t), void (*__pfree)(void*)); |
| 146 strstreambuf(char* __gnext, streamsize __n, char* __pbeg = 0); |
| 147 strstreambuf(const char* __gnext, streamsize __n); |
| 148 |
| 149 strstreambuf(signed char* __gnext, streamsize __n, signed char* __pbeg = 0); |
| 150 strstreambuf(const signed char* __gnext, streamsize __n); |
| 151 strstreambuf(unsigned char* __gnext, streamsize __n, unsigned char* __pbeg =
0); |
| 152 strstreambuf(const unsigned char* __gnext, streamsize __n); |
| 153 |
| 154 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES |
| 155 _LIBCPP_INLINE_VISIBILITY |
| 156 strstreambuf(strstreambuf&& __rhs); |
| 157 _LIBCPP_INLINE_VISIBILITY |
| 158 strstreambuf& operator=(strstreambuf&& __rhs); |
| 159 #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES |
| 160 |
| 161 virtual ~strstreambuf(); |
| 162 |
| 163 void swap(strstreambuf& __rhs); |
| 164 |
| 165 void freeze(bool __freezefl = true); |
| 166 char* str(); |
| 167 int pcount() const; |
| 168 |
| 169 protected: |
| 170 virtual int_type overflow (int_type __c = EOF); |
| 171 virtual int_type pbackfail(int_type __c = EOF); |
| 172 virtual int_type underflow(); |
| 173 virtual pos_type seekoff(off_type __off, ios_base::seekdir __way, |
| 174 ios_base::openmode __which = ios_base::in | ios_bas
e::out); |
| 175 virtual pos_type seekpos(pos_type __sp, |
| 176 ios_base::openmode __which = ios_base::in | ios_bas
e::out); |
| 177 |
| 178 private: |
| 179 typedef unsigned __mode_type; |
| 180 static const __mode_type __allocated = 0x01; |
| 181 static const __mode_type __constant = 0x02; |
| 182 static const __mode_type __dynamic = 0x04; |
| 183 static const __mode_type __frozen = 0x08; |
| 184 static const streamsize __default_alsize = 4096; |
| 185 |
| 186 __mode_type __strmode_; |
| 187 streamsize __alsize_; |
| 188 void* (*__palloc_)(size_t); |
| 189 void (*__pfree_)(void*); |
| 190 |
| 191 void __init(char* __gnext, streamsize __n, char* __pbeg); |
| 192 }; |
| 193 |
| 194 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES |
| 195 |
| 196 inline _LIBCPP_INLINE_VISIBILITY |
| 197 strstreambuf::strstreambuf(strstreambuf&& __rhs) |
| 198 : streambuf(__rhs), |
| 199 __strmode_(__rhs.__strmode_), |
| 200 __alsize_(__rhs.__alsize_), |
| 201 __palloc_(__rhs.__palloc_), |
| 202 __pfree_(__rhs.__pfree_) |
| 203 { |
| 204 __rhs.setg(nullptr, nullptr, nullptr); |
| 205 __rhs.setp(nullptr, nullptr); |
| 206 } |
| 207 |
| 208 inline _LIBCPP_INLINE_VISIBILITY |
| 209 strstreambuf& |
| 210 strstreambuf::operator=(strstreambuf&& __rhs) |
| 211 { |
| 212 if (eback() && (__strmode_ & __allocated) != 0 && (__strmode_ & __frozen) ==
0) |
| 213 { |
| 214 if (__pfree_) |
| 215 __pfree_(eback()); |
| 216 else |
| 217 delete [] eback(); |
| 218 } |
| 219 streambuf::operator=(__rhs); |
| 220 __strmode_ = __rhs.__strmode_; |
| 221 __alsize_ = __rhs.__alsize_; |
| 222 __palloc_ = __rhs.__palloc_; |
| 223 __pfree_ = __rhs.__pfree_; |
| 224 __rhs.setg(nullptr, nullptr, nullptr); |
| 225 __rhs.setp(nullptr, nullptr); |
| 226 return *this; |
| 227 } |
| 228 |
| 229 #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES |
| 230 |
| 231 class _LIBCPP_TYPE_VIS istrstream |
| 232 : public istream |
| 233 { |
| 234 public: |
| 235 _LIBCPP_INLINE_VISIBILITY |
| 236 explicit istrstream(const char* __s) |
| 237 : istream(&__sb_), __sb_(__s, 0) {} |
| 238 _LIBCPP_INLINE_VISIBILITY |
| 239 explicit istrstream(char* __s) |
| 240 : istream(&__sb_), __sb_(__s, 0) {} |
| 241 _LIBCPP_INLINE_VISIBILITY |
| 242 istrstream(const char* __s, streamsize __n) |
| 243 : istream(&__sb_), __sb_(__s, __n) {} |
| 244 _LIBCPP_INLINE_VISIBILITY |
| 245 istrstream(char* __s, streamsize __n) |
| 246 : istream(&__sb_), __sb_(__s, __n) {} |
| 247 |
| 248 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES |
| 249 _LIBCPP_INLINE_VISIBILITY |
| 250 istrstream(istrstream&& __rhs) |
| 251 : istream(_VSTD::move(__rhs)), |
| 252 __sb_(_VSTD::move(__rhs.__sb_)) |
| 253 { |
| 254 istream::set_rdbuf(&__sb_); |
| 255 } |
| 256 |
| 257 _LIBCPP_INLINE_VISIBILITY |
| 258 istrstream& operator=(istrstream&& __rhs) |
| 259 { |
| 260 istream::operator=(_VSTD::move(__rhs)); |
| 261 __sb_ = _VSTD::move(__rhs.__sb_); |
| 262 return *this; |
| 263 } |
| 264 #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES |
| 265 |
| 266 virtual ~istrstream(); |
| 267 |
| 268 _LIBCPP_INLINE_VISIBILITY |
| 269 void swap(istrstream& __rhs) |
| 270 { |
| 271 istream::swap(__rhs); |
| 272 __sb_.swap(__rhs.__sb_); |
| 273 } |
| 274 |
| 275 _LIBCPP_INLINE_VISIBILITY |
| 276 strstreambuf* rdbuf() const {return const_cast<strstreambuf*>(&__sb_);} |
| 277 _LIBCPP_INLINE_VISIBILITY |
| 278 char *str() {return __sb_.str();} |
| 279 |
| 280 private: |
| 281 strstreambuf __sb_; |
| 282 }; |
| 283 |
| 284 class _LIBCPP_TYPE_VIS ostrstream |
| 285 : public ostream |
| 286 { |
| 287 public: |
| 288 _LIBCPP_INLINE_VISIBILITY |
| 289 ostrstream() |
| 290 : ostream(&__sb_) {} |
| 291 _LIBCPP_INLINE_VISIBILITY |
| 292 ostrstream(char* __s, int __n, ios_base::openmode __mode = ios_base::out) |
| 293 : ostream(&__sb_), |
| 294 __sb_(__s, __n, __s + (__mode & ios::app ? strlen(__s) : 0)) |
| 295 {} |
| 296 |
| 297 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES |
| 298 _LIBCPP_INLINE_VISIBILITY |
| 299 ostrstream(ostrstream&& __rhs) |
| 300 : ostream(_VSTD::move(__rhs)), |
| 301 __sb_(_VSTD::move(__rhs.__sb_)) |
| 302 { |
| 303 ostream::set_rdbuf(&__sb_); |
| 304 } |
| 305 |
| 306 _LIBCPP_INLINE_VISIBILITY |
| 307 ostrstream& operator=(ostrstream&& __rhs) |
| 308 { |
| 309 ostream::operator=(_VSTD::move(__rhs)); |
| 310 __sb_ = _VSTD::move(__rhs.__sb_); |
| 311 return *this; |
| 312 } |
| 313 #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES |
| 314 |
| 315 virtual ~ostrstream(); |
| 316 |
| 317 _LIBCPP_INLINE_VISIBILITY |
| 318 void swap(ostrstream& __rhs) |
| 319 { |
| 320 ostream::swap(__rhs); |
| 321 __sb_.swap(__rhs.__sb_); |
| 322 } |
| 323 |
| 324 _LIBCPP_INLINE_VISIBILITY |
| 325 strstreambuf* rdbuf() const {return const_cast<strstreambuf*>(&__sb_);} |
| 326 _LIBCPP_INLINE_VISIBILITY |
| 327 void freeze(bool __freezefl = true) {__sb_.freeze(__freezefl);} |
| 328 _LIBCPP_INLINE_VISIBILITY |
| 329 char* str() {return __sb_.str();} |
| 330 _LIBCPP_INLINE_VISIBILITY |
| 331 int pcount() const {return __sb_.pcount();} |
| 332 |
| 333 private: |
| 334 strstreambuf __sb_; // exposition only |
| 335 }; |
| 336 |
| 337 class _LIBCPP_TYPE_VIS strstream |
| 338 : public iostream |
| 339 { |
| 340 public: |
| 341 // Types |
| 342 typedef char char_type; |
| 343 typedef char_traits<char>::int_type int_type; |
| 344 typedef char_traits<char>::pos_type pos_type; |
| 345 typedef char_traits<char>::off_type off_type; |
| 346 |
| 347 // constructors/destructor |
| 348 _LIBCPP_INLINE_VISIBILITY |
| 349 strstream() |
| 350 : iostream(&__sb_) {} |
| 351 _LIBCPP_INLINE_VISIBILITY |
| 352 strstream(char* __s, int __n, ios_base::openmode __mode = ios_base::in | ios
_base::out) |
| 353 : iostream(&__sb_), |
| 354 __sb_(__s, __n, __s + (__mode & ios::app ? strlen(__s) : 0)) |
| 355 {} |
| 356 |
| 357 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES |
| 358 _LIBCPP_INLINE_VISIBILITY |
| 359 strstream(strstream&& __rhs) |
| 360 : iostream(_VSTD::move(__rhs)), |
| 361 __sb_(_VSTD::move(__rhs.__sb_)) |
| 362 { |
| 363 iostream::set_rdbuf(&__sb_); |
| 364 } |
| 365 |
| 366 _LIBCPP_INLINE_VISIBILITY |
| 367 strstream& operator=(strstream&& __rhs) |
| 368 { |
| 369 iostream::operator=(_VSTD::move(__rhs)); |
| 370 __sb_ = _VSTD::move(__rhs.__sb_); |
| 371 return *this; |
| 372 } |
| 373 #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES |
| 374 |
| 375 virtual ~strstream(); |
| 376 |
| 377 _LIBCPP_INLINE_VISIBILITY |
| 378 void swap(strstream& __rhs) |
| 379 { |
| 380 iostream::swap(__rhs); |
| 381 __sb_.swap(__rhs.__sb_); |
| 382 } |
| 383 |
| 384 // Members: |
| 385 _LIBCPP_INLINE_VISIBILITY |
| 386 strstreambuf* rdbuf() const {return const_cast<strstreambuf*>(&__sb_);} |
| 387 _LIBCPP_INLINE_VISIBILITY |
| 388 void freeze(bool __freezefl = true) {__sb_.freeze(__freezefl);} |
| 389 _LIBCPP_INLINE_VISIBILITY |
| 390 int pcount() const {return __sb_.pcount();} |
| 391 _LIBCPP_INLINE_VISIBILITY |
| 392 char* str() {return __sb_.str();} |
| 393 |
| 394 private: |
| 395 strstreambuf __sb_; // exposition only |
| 396 }; |
| 397 |
| 398 _LIBCPP_END_NAMESPACE_STD |
| 399 |
| 400 #endif // _LIBCPP_STRSTREAM |
OLD | NEW |