Home | History | Annotate | Download | only in include
      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_base::out);
    175     virtual pos_type seekpos(pos_type __sp,
    176                              ios_base::openmode __which = ios_base::in | ios_base::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
    401