libcxx/include/strstream

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