contrib/llvm-project/libcxx/include/strstream

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