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 #if __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)
 133 #  include <__cxx03/strstream>
 134 #else
 135 #  include <__config>
 136 #  include <__ostream/basic_ostream.h>
 137 #  include <istream>
 138 #  include <streambuf>
 139 #  include <version>
 140
 141 #  if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 142 #    pragma GCC system_header
 143 #  endif
 144
 145 #  if _LIBCPP_STD_VER < 26 || defined(_LIBCPP_ENABLE_CXX26_REMOVED_STRSTREAM) || defined(_LIBCPP_BUILDING_LIBRARY)
 146
 147 _LIBCPP_PUSH_MACROS
 148 #    include <__undef_macros>
 149
 150 _LIBCPP_BEGIN_NAMESPACE_STD
 151
 152 class _LIBCPP_DEPRECATED _LIBCPP_EXPORTED_FROM_ABI strstreambuf : public streambuf {
 153 public:
 154 #    ifndef _LIBCPP_CXX03_LANG
 155   _LIBCPP_HIDE_FROM_ABI strstreambuf() : strstreambuf(0) {}
 156   explicit strstreambuf(streamsize __alsize);
 157 #    else
 158   explicit strstreambuf(streamsize __alsize = 0);
 159 #    endif
 160   strstreambuf(void* (*__palloc)(size_t), void (*__pfree)(void*));
 161   strstreambuf(char* __gnext, streamsize __n, char* __pbeg = nullptr);
 162   strstreambuf(const char* __gnext, streamsize __n);
 163
 164   strstreambuf(signed char* __gnext, streamsize __n, signed char* __pbeg = nullptr);
 165   strstreambuf(const signed char* __gnext, streamsize __n);
 166   strstreambuf(unsigned char* __gnext, streamsize __n, unsigned char* __pbeg = nullptr);
 167   strstreambuf(const unsigned char* __gnext, streamsize __n);
 168
 169 #    ifndef _LIBCPP_CXX03_LANG
 170   _LIBCPP_HIDE_FROM_ABI strstreambuf(strstreambuf&& __rhs);
 171   _LIBCPP_HIDE_FROM_ABI strstreambuf& operator=(strstreambuf&& __rhs);
 172 #    endif // _LIBCPP_CXX03_LANG
 173
 174   ~strstreambuf() override;
 175
 176   void swap(strstreambuf& __rhs);
 177
 178   void freeze(bool __freezefl = true);
 179   char* str();
 180   int pcount() const;
 181
 182 protected:
 183   int_type overflow(int_type __c = EOF) override;
 184   int_type pbackfail(int_type __c = EOF) override;
 185   int_type underflow() override;
 186   pos_type
 187   seekoff(off_type __off, ios_base::seekdir __way, ios_base::openmode __which = ios_base::in | ios_base::out) override;
 188   pos_type seekpos(pos_type __sp, ios_base::openmode __which = ios_base::in | ios_base::out) override;
 189
 190 private:
 191   typedef unsigned __mode_type;
 192   static const __mode_type __allocated     = 0x01;
 193   static const __mode_type __constant      = 0x02;
 194   static const __mode_type __dynamic       = 0x04;
 195   static const __mode_type __frozen        = 0x08;
 196   static const streamsize __default_alsize = 4096;
 197
 198   __mode_type __strmode_;
 199   streamsize __alsize_;
 200   void* (*__palloc_)(size_t);
 201   void (*__pfree_)(void*);
 202
 203   void __init(char* __gnext, streamsize __n, char* __pbeg);
 204 };
 205
 206 #    ifndef _LIBCPP_CXX03_LANG
 207
 208 inline _LIBCPP_HIDE_FROM_ABI strstreambuf::strstreambuf(strstreambuf&& __rhs)
 209     : streambuf(__rhs),
 210       __strmode_(__rhs.__strmode_),
 211       __alsize_(__rhs.__alsize_),
 212       __palloc_(__rhs.__palloc_),
 213       __pfree_(__rhs.__pfree_) {
 214   __rhs.setg(nullptr, nullptr, nullptr);
 215   __rhs.setp(nullptr, nullptr);
 216 }
 217
 218 inline _LIBCPP_HIDE_FROM_ABI strstreambuf& strstreambuf::operator=(strstreambuf&& __rhs) {
 219   if (eback() && (__strmode_ & __allocated) != 0 && (__strmode_ & __frozen) == 0) {
 220     if (__pfree_)
 221       __pfree_(eback());
 222     else
 223       delete[] eback();
 224   }
 225   streambuf::operator=(__rhs);
 226   __strmode_ = __rhs.__strmode_;
 227   __alsize_  = __rhs.__alsize_;
 228   __palloc_  = __rhs.__palloc_;
 229   __pfree_   = __rhs.__pfree_;
 230   __rhs.setg(nullptr, nullptr, nullptr);
 231   __rhs.setp(nullptr, nullptr);
 232   return *this;
 233 }
 234
 235 #    endif // _LIBCPP_CXX03_LANG
 236
 237 class _LIBCPP_DEPRECATED _LIBCPP_EXPORTED_FROM_ABI istrstream : public istream {
 238 public:
 239   _LIBCPP_HIDE_FROM_ABI explicit istrstream(const char* __s) : istream(&__sb_), __sb_(__s, 0) {}
 240   _LIBCPP_HIDE_FROM_ABI explicit istrstream(char* __s) : istream(&__sb_), __sb_(__s, 0) {}
 241   _LIBCPP_HIDE_FROM_ABI istrstream(const char* __s, streamsize __n) : istream(&__sb_), __sb_(__s, __n) {}
 242   _LIBCPP_HIDE_FROM_ABI istrstream(char* __s, streamsize __n) : istream(&__sb_), __sb_(__s, __n) {}
 243
 244 #    ifndef _LIBCPP_CXX03_LANG
 245   _LIBCPP_HIDE_FROM_ABI istrstream(istrstream&& __rhs) // extension
 246       : istream(std::move(static_cast<istream&>(__rhs))), __sb_(std::move(__rhs.__sb_)) {
 247     istream::set_rdbuf(&__sb_);
 248   }
 249
 250   _LIBCPP_HIDE_FROM_ABI istrstream& operator=(istrstream&& __rhs) {
 251     __sb_ = std::move(__rhs.__sb_);
 252     istream::operator=(std::move(__rhs));
 253     return *this;
 254   }
 255 #    endif // _LIBCPP_CXX03_LANG
 256
 257   ~istrstream() override;
 258
 259   _LIBCPP_HIDE_FROM_ABI void swap(istrstream& __rhs) {
 260     istream::swap(__rhs);
 261     __sb_.swap(__rhs.__sb_);
 262   }
 263
 264   _LIBCPP_HIDE_FROM_ABI strstreambuf* rdbuf() const { return const_cast<strstreambuf*>(&__sb_); }
 265   _LIBCPP_HIDE_FROM_ABI char* str() { return __sb_.str(); }
 266
 267 private:
 268   strstreambuf __sb_;
 269 };
 270
 271 class _LIBCPP_DEPRECATED _LIBCPP_EXPORTED_FROM_ABI ostrstream : public ostream {
 272 public:
 273   _LIBCPP_HIDE_FROM_ABI ostrstream() : ostream(&__sb_) {}
 274   _LIBCPP_HIDE_FROM_ABI ostrstream(char* __s, int __n, ios_base::openmode __mode = ios_base::out)
 275       : ostream(&__sb_), __sb_(__s, __n, __s + (__mode & ios::app ? std::strlen(__s) : 0)) {}
 276
 277 #    ifndef _LIBCPP_CXX03_LANG
 278   _LIBCPP_HIDE_FROM_ABI ostrstream(ostrstream&& __rhs) // extension
 279       : ostream(std::move(static_cast<ostream&>(__rhs))), __sb_(std::move(__rhs.__sb_)) {
 280     ostream::set_rdbuf(&__sb_);
 281   }
 282
 283   _LIBCPP_HIDE_FROM_ABI ostrstream& operator=(ostrstream&& __rhs) {
 284     __sb_ = std::move(__rhs.__sb_);
 285     ostream::operator=(std::move(__rhs));
 286     return *this;
 287   }
 288 #    endif // _LIBCPP_CXX03_LANG
 289
 290   ~ostrstream() override;
 291
 292   _LIBCPP_HIDE_FROM_ABI void swap(ostrstream& __rhs) {
 293     ostream::swap(__rhs);
 294     __sb_.swap(__rhs.__sb_);
 295   }
 296
 297   _LIBCPP_HIDE_FROM_ABI strstreambuf* rdbuf() const { return const_cast<strstreambuf*>(&__sb_); }
 298   _LIBCPP_HIDE_FROM_ABI void freeze(bool __freezefl = true) { __sb_.freeze(__freezefl); }
 299   _LIBCPP_HIDE_FROM_ABI char* str() { return __sb_.str(); }
 300   _LIBCPP_HIDE_FROM_ABI int pcount() const { return __sb_.pcount(); }
 301
 302 private:
 303   strstreambuf __sb_; // exposition only
 304 };
 305
 306 class _LIBCPP_DEPRECATED _LIBCPP_EXPORTED_FROM_ABI strstream : public iostream {
 307 public:
 308   // Types
 309   typedef char char_type;
 310   typedef char_traits<char>::int_type int_type;
 311   typedef char_traits<char>::pos_type pos_type;
 312   typedef char_traits<char>::off_type off_type;
 313
 314   // constructors/destructor
 315   _LIBCPP_HIDE_FROM_ABI strstream() : iostream(&__sb_) {}
 316   _LIBCPP_HIDE_FROM_ABI strstream(char* __s, int __n, ios_base::openmode __mode = ios_base::in | ios_base::out)
 317       : iostream(&__sb_), __sb_(__s, __n, __s + (__mode & ios::app ? std::strlen(__s) : 0)) {}
 318
 319 #    ifndef _LIBCPP_CXX03_LANG
 320   _LIBCPP_HIDE_FROM_ABI strstream(strstream&& __rhs) // extension
 321       : iostream(std::move(static_cast<iostream&>(__rhs))), __sb_(std::move(__rhs.__sb_)) {
 322     iostream::set_rdbuf(&__sb_);
 323   }
 324
 325   _LIBCPP_HIDE_FROM_ABI strstream& operator=(strstream&& __rhs) {
 326     __sb_ = std::move(__rhs.__sb_);
 327     iostream::operator=(std::move(__rhs));
 328     return *this;
 329   }
 330 #    endif // _LIBCPP_CXX03_LANG
 331
 332   ~strstream() override;
 333
 334   _LIBCPP_HIDE_FROM_ABI void swap(strstream& __rhs) {
 335     iostream::swap(__rhs);
 336     __sb_.swap(__rhs.__sb_);
 337   }
 338
 339   // Members:
 340   _LIBCPP_HIDE_FROM_ABI strstreambuf* rdbuf() const { return const_cast<strstreambuf*>(&__sb_); }
 341   _LIBCPP_HIDE_FROM_ABI void freeze(bool __freezefl = true) { __sb_.freeze(__freezefl); }
 342   _LIBCPP_HIDE_FROM_ABI int pcount() const { return __sb_.pcount(); }
 343   _LIBCPP_HIDE_FROM_ABI char* str() { return __sb_.str(); }
 344
 345 private:
 346   strstreambuf __sb_; // exposition only
 347 };
 348
 349 _LIBCPP_END_NAMESPACE_STD
 350
 351 _LIBCPP_POP_MACROS
 352
 353 #  endif // _LIBCPP_STD_VER < 26 || defined(_LIBCPP_ENABLE_CXX26_REMOVED_STRSTREAM) || defined(_LIBCPP_BUILDING_LIBRARY)
 354 #endif   // __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)
 355
 356 #endif // _LIBCPP_STRSTREAM