зеркало из https://github.com/microsoft/STL.git
632 строки
22 KiB
C++
632 строки
22 KiB
C++
// strstream standard header
|
|
|
|
// Copyright (c) Microsoft Corporation.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
|
|
#pragma once
|
|
#ifndef _STRSTREAM_
|
|
#define _STRSTREAM_
|
|
#include <yvals_core.h>
|
|
#if _STL_COMPILER_PREPROCESSOR
|
|
#include <istream>
|
|
|
|
#pragma pack(push, _CRT_PACKING)
|
|
#pragma warning(push, _STL_WARNING_LEVEL)
|
|
#pragma warning(disable : _STL_DISABLED_WARNINGS)
|
|
_STL_DISABLE_CLANG_WARNINGS
|
|
#pragma push_macro("new")
|
|
#undef new
|
|
|
|
_STD_BEGIN
|
|
|
|
_CXX17_DEPRECATE_STRSTREAM typedef int _Header_strstream;
|
|
using _Hdr_strstream = _Header_strstream;
|
|
|
|
// CLASS strstreambuf
|
|
class strstreambuf : public streambuf { // stream buffer associated with static or allocated character array
|
|
public:
|
|
using _Mysb = streambuf;
|
|
enum { // constants for bits in stream state
|
|
_Allocated = 1, // set if character array storage has been allocated
|
|
_Constant = 2, // set if character array immutable
|
|
_Dynamic = 4, // set if character array length grows on demand
|
|
_Frozen = 8
|
|
}; // set if character array ownership given away
|
|
using _Strstate = int;
|
|
|
|
__CLR_OR_THIS_CALL strstreambuf() { // construct with empty character array
|
|
_Init(0);
|
|
}
|
|
|
|
explicit __CLR_OR_THIS_CALL strstreambuf(streamsize _Count) { // construct with suggested initial size
|
|
_Init(_Count);
|
|
}
|
|
|
|
__CLR_OR_THIS_CALL strstreambuf(
|
|
void*(__CLRCALL_OR_CDECL* _Allocfunc)(size_t), void(__CLRCALL_OR_CDECL* _Freefunc)(void*)) {
|
|
// construct with empty character array, allocation functions
|
|
_Init();
|
|
_Palloc = _Allocfunc;
|
|
_Pfree = _Freefunc;
|
|
}
|
|
|
|
__CLR_OR_THIS_CALL strstreambuf(_In_opt_z_ char* _Getptr, streamsize _Count, _In_opt_z_ char* _Putptr = nullptr) {
|
|
// construct with [_Getptr, _Getptr + _Count), possibly mutable
|
|
_Init(_Count, _Getptr, _Putptr);
|
|
}
|
|
|
|
__CLR_OR_THIS_CALL strstreambuf(_In_z_ const char* _Getptr, streamsize _Count) {
|
|
// construct with [_Getptr, _Getptr + _Count), immutable
|
|
_Init(_Count, const_cast<char*>(_Getptr), nullptr, _Constant);
|
|
}
|
|
|
|
__CLR_OR_THIS_CALL strstreambuf(
|
|
_In_opt_z_ unsigned char* _Getptr, streamsize _Count, _In_opt_z_ unsigned char* _Putptr = nullptr) {
|
|
// construct with [_Getptr, _Getptr + _Count), possibly mutable
|
|
_Init(_Count, reinterpret_cast<char*>(_Getptr), reinterpret_cast<char*>(_Putptr));
|
|
}
|
|
|
|
__CLR_OR_THIS_CALL strstreambuf(_In_opt_z_ const unsigned char* _Getptr, streamsize _Count) {
|
|
// construct with [_Getptr, _Getptr + _Count), immutable
|
|
_Init(_Count, const_cast<char*>(reinterpret_cast<const char*>(_Getptr)), nullptr, _Constant);
|
|
}
|
|
|
|
__CLR_OR_THIS_CALL strstreambuf(strstreambuf&& _Right) {
|
|
_Init();
|
|
_Assign_rv(_STD move(_Right));
|
|
}
|
|
|
|
strstreambuf& __CLR_OR_THIS_CALL operator=(strstreambuf&& _Right) {
|
|
_Assign_rv(_STD move(_Right));
|
|
return *this;
|
|
}
|
|
|
|
void __CLR_OR_THIS_CALL _Assign_rv(strstreambuf&& _Right) {
|
|
if (this != _STD addressof(_Right)) {
|
|
_Tidy();
|
|
this->swap(_Right);
|
|
}
|
|
}
|
|
|
|
void __CLR_OR_THIS_CALL swap(strstreambuf& _Right) {
|
|
if (this != _STD addressof(_Right)) {
|
|
_Mysb::swap(_Right);
|
|
_STD swap(_Minsize, _Right._Minsize);
|
|
_STD swap(_Pendsave, _Right._Pendsave);
|
|
_STD swap(_Seekhigh, _Right._Seekhigh);
|
|
_STD swap(_Strmode, _Right._Strmode);
|
|
_STD swap(_Palloc, _Right._Palloc);
|
|
_STD swap(_Pfree, _Right._Pfree);
|
|
}
|
|
}
|
|
|
|
virtual __CLR_OR_THIS_CALL ~strstreambuf() noexcept {
|
|
_Tidy();
|
|
}
|
|
|
|
void __CLR_OR_THIS_CALL freeze(bool _Freezeit = true) { // freeze or unfreeze writing
|
|
if (_Strmode & _Dynamic) {
|
|
if (_Freezeit && !(_Strmode & _Frozen)) { // disable writing
|
|
_Strmode |= _Frozen;
|
|
_Pendsave = epptr();
|
|
setp(pbase(), pptr(), eback());
|
|
} else if (!_Freezeit && (_Strmode & _Frozen)) { // re-enable writing
|
|
_Strmode &= ~_Frozen;
|
|
setp(pbase(), pptr(), _Pendsave);
|
|
}
|
|
}
|
|
}
|
|
|
|
_NODISCARD char* __CLR_OR_THIS_CALL str() { // freeze and return pointer to character array
|
|
freeze();
|
|
return eback();
|
|
}
|
|
|
|
_NODISCARD streamsize __CLR_OR_THIS_CALL pcount() const {
|
|
return pptr() ? static_cast<streamsize>(pptr() - pbase()) : 0;
|
|
}
|
|
|
|
__CLR_OR_THIS_CALL strstreambuf(
|
|
_In_opt_z_ signed char* _Getptr, streamsize _Count, _In_opt_z_ signed char* _Putptr = nullptr) {
|
|
// construct with [_Getptr, _Getptr + _Count), possibly mutable
|
|
_Init(_Count, reinterpret_cast<char*>(_Getptr), reinterpret_cast<char*>(_Putptr));
|
|
}
|
|
|
|
__CLR_OR_THIS_CALL strstreambuf(const signed char* _Getptr, streamsize _Count) {
|
|
// construct with [_Getptr, _Getptr + _Count), immutable
|
|
_Init(_Count, const_cast<char*>(reinterpret_cast<const char*>(_Getptr)), nullptr, _Constant);
|
|
}
|
|
|
|
void clear() { // free any allocated storage
|
|
_Tidy();
|
|
}
|
|
|
|
protected:
|
|
virtual int __CLR_OR_THIS_CALL overflow(int _Meta = EOF) override { // try to extend write area
|
|
if (_Meta == EOF) {
|
|
return 0; // nothing to write
|
|
}
|
|
|
|
if (pptr() && pptr() < epptr()) {
|
|
return static_cast<unsigned char>(*_Pninc() = static_cast<char>(_Meta));
|
|
}
|
|
|
|
if (!(_Strmode & _Dynamic) || (_Strmode & (_Constant | _Frozen))) {
|
|
return EOF; // can't extend
|
|
}
|
|
|
|
// okay to extend
|
|
const size_t _Oldsize = gptr() ? static_cast<size_t>(epptr() - eback()) : 0;
|
|
size_t _Newsize;
|
|
if (_Oldsize < _MINSIZE) {
|
|
_Newsize = _MINSIZE;
|
|
} else if (_Oldsize < INT_MAX / 2) { // grow by 50 percent
|
|
_Newsize = _Oldsize << 1;
|
|
} else if (_Oldsize < INT_MAX) {
|
|
_Newsize = INT_MAX;
|
|
} else { // buffer can't grow, fail
|
|
return EOF;
|
|
}
|
|
|
|
const auto _Ptr = _Alloc(_Newsize);
|
|
if (!_Ptr) { // couldn't grow, return failure
|
|
return EOF;
|
|
}
|
|
|
|
_CSTD memcpy(_Ptr, eback(), _Oldsize); // copy existing
|
|
if (_Strmode & _Allocated) { // buffer to free
|
|
_Free(eback());
|
|
}
|
|
|
|
_Strmode |= _Allocated;
|
|
_Seekhigh = _Ptr + _Oldsize;
|
|
const ptrdiff_t _Old_get_offset = gptr() - eback();
|
|
const ptrdiff_t _Old_put_base_offset = pbase() - eback();
|
|
const ptrdiff_t _Old_put_offset = pptr() - eback();
|
|
setp(_Ptr + _Old_put_base_offset, _Ptr + _Old_put_offset, _Ptr + _Newsize);
|
|
setg(_Ptr, _Ptr + _Old_get_offset, _Ptr + _Old_get_offset + 1);
|
|
return static_cast<unsigned char>(*_Pninc() = static_cast<char>(_Meta));
|
|
}
|
|
|
|
virtual int __CLR_OR_THIS_CALL pbackfail(int _Meta = EOF) override { // try to putback a character
|
|
const auto _Old_gptr = gptr();
|
|
if (_Old_gptr && eback() < _Old_gptr) { // if the input sequence has a putback position available
|
|
if (_Meta == EOF) {
|
|
_Meta = 0; // a value other than EOF
|
|
} else if (!(_Strmode & _Constant)) { // non-constant, overwrite no matter what
|
|
_Old_gptr[-1] = static_cast<char>(_Meta);
|
|
} else if (_Old_gptr[-1] != static_cast<char>(_Meta)) { // constant, unequal, can't put it back
|
|
return EOF;
|
|
}
|
|
|
|
gbump(-1);
|
|
return _Meta;
|
|
}
|
|
|
|
return EOF;
|
|
}
|
|
|
|
virtual int __CLR_OR_THIS_CALL underflow() override { // read if read position available
|
|
const auto _Old_gptr = gptr();
|
|
if (!_Old_gptr) {
|
|
return EOF; // no read buffer
|
|
}
|
|
|
|
if (_Old_gptr < egptr()) { // If the input sequence has a read position available, the function signals success
|
|
// by returning static_cast<unsigned char>(*gnext)
|
|
return static_cast<unsigned char>(*_Old_gptr);
|
|
}
|
|
|
|
const auto _Old_pptr = pptr();
|
|
if (_Old_pptr && _Old_pptr > egptr()
|
|
&& _Old_gptr
|
|
< _Old_pptr) { // Otherwise, if the current write next pointer pnext is not a null pointer and is
|
|
// greater than the current read end pointer gend, makes a read position available by
|
|
// assigning to gend a value greater than gnext and no greater than pnext.
|
|
if (_Seekhigh < _Old_pptr) { // TRANSITION, ABI: appears unused, maintained for ABI compat
|
|
_Seekhigh = _Old_pptr;
|
|
}
|
|
|
|
setg(eback(), gptr(), _Old_pptr);
|
|
return static_cast<unsigned char>(*_Old_gptr);
|
|
}
|
|
|
|
return EOF;
|
|
}
|
|
|
|
virtual streampos __CLR_OR_THIS_CALL seekoff(
|
|
streamoff _Off, ios_base::seekdir _Way, ios_base::openmode _Which = ios_base::in | ios_base::out) override {
|
|
// seek by specified offset
|
|
if (pptr() && _Seekhigh < pptr()) { // TRANSITION, ABI: appears unused, maintained for ABI compat
|
|
_Seekhigh = pptr(); // update high water mark
|
|
}
|
|
|
|
if ((_Which & ios_base::in && !gptr())
|
|
|| (_Which & ios_base::out && !pptr())) { // N4727 [depr.strstreambuf.virtuals]/14:
|
|
// For a sequence to be positioned, if its next pointer
|
|
// is a null pointer, the positioning operation fails.
|
|
return pos_type(off_type(-1));
|
|
}
|
|
|
|
const auto _Seeklow = eback();
|
|
const auto _Seekdist = _Seekhigh - _Seeklow;
|
|
|
|
// N4727 [depr.strstreambuf.virtuals]/15 effectively says check that the result will be in range
|
|
// [_Seeklow, _Seekhigh]; but we want to calculate this without potential integer overflow
|
|
switch (_Way) {
|
|
case ios_base::beg:
|
|
// check that _Off is in acceptable range [0, _Seekdist]
|
|
if (static_cast<unsigned long long>(_Off)
|
|
> static_cast<unsigned long long>(_Seekdist)) { // negative wraparound to positive to save a compare
|
|
return pos_type(off_type(-1));
|
|
}
|
|
break;
|
|
case ios_base::end:
|
|
// check that _Off is in acceptable range [-_Seekdist, 0]
|
|
// is: _Off + _Seekdist in range [0, _Seekdist]
|
|
if (static_cast<unsigned long long>(_Off) + _Seekdist > static_cast<unsigned long long>(_Seekdist)) {
|
|
return pos_type(off_type(-1));
|
|
}
|
|
|
|
_Off += _Seekdist;
|
|
break;
|
|
case ios_base::cur:
|
|
{
|
|
constexpr auto _Both = ios_base::in | ios_base::out;
|
|
if ((_Which & _Both)
|
|
== _Both) { // prohibited by N4727 [depr.strstreambuf.virtuals] Table 137 "seekoff positioning"
|
|
return pos_type(off_type(-1));
|
|
}
|
|
|
|
off_type _Oldoff;
|
|
off_type _Oldleft;
|
|
if (_Which & ios_base::in) {
|
|
_Oldoff = gptr() - eback();
|
|
_Oldleft = _Seekhigh - gptr();
|
|
} else if (_Which & ios_base::out) {
|
|
_Oldoff = pptr() - pbase();
|
|
_Oldleft = _Seekhigh - pptr();
|
|
} else {
|
|
return pos_type(off_type(-1));
|
|
}
|
|
|
|
if (_Off < -_Oldoff // runs off beginning
|
|
|| _Off > _Oldleft) { // runs off end
|
|
return pos_type(off_type(-1));
|
|
}
|
|
|
|
_Off += _Oldoff;
|
|
}
|
|
|
|
break;
|
|
default:
|
|
return pos_type(off_type(-1));
|
|
}
|
|
|
|
if (_Which & ios_base::in) {
|
|
gbump(static_cast<int>(_Off - (gptr() - eback())));
|
|
}
|
|
|
|
if (_Which & ios_base::out) {
|
|
pbump(static_cast<int>(_Off - (pptr() - pbase())));
|
|
}
|
|
|
|
return pos_type(_Off);
|
|
}
|
|
|
|
virtual pos_type __CLR_OR_THIS_CALL seekpos(
|
|
pos_type _Sp, ios_base::openmode _Which = ios_base::in | ios_base::out) override {
|
|
// seek to memorized position
|
|
if (pptr() && _Seekhigh < pptr()) { // TRANSITION, ABI: appears unused, maintained for ABI compat
|
|
_Seekhigh = pptr(); // update high water mark
|
|
}
|
|
|
|
if (((_Which & ios_base::in) && !gptr()) || ((_Which & ios_base::out) && !pptr())) {
|
|
return pos_type(off_type(-1));
|
|
}
|
|
|
|
const auto _Off = static_cast<off_type>(_Sp);
|
|
const auto _Seeklow = eback();
|
|
const auto _Seekdist = _Seekhigh - _Seeklow;
|
|
if (_Off > _Seekdist) {
|
|
return pos_type(off_type(-1));
|
|
}
|
|
|
|
if (_Which & ios_base::in) {
|
|
gbump(static_cast<int>(_Off - (gptr() - eback())));
|
|
}
|
|
|
|
if (_Which & ios_base::out) {
|
|
pbump(static_cast<int>(_Off - (pptr() - pbase())));
|
|
}
|
|
|
|
return pos_type(_Off);
|
|
}
|
|
|
|
void __CLR_OR_THIS_CALL _Init(
|
|
streamsize _Count = 0, char* _Gp = nullptr, char* _Pp = nullptr, _Strstate _Mode = 0) {
|
|
// initialize with possibly static buffer
|
|
streambuf::_Init();
|
|
_Minsize = _MINSIZE;
|
|
_Pendsave = nullptr;
|
|
_Seekhigh = nullptr;
|
|
_Palloc = nullptr;
|
|
_Pfree = nullptr;
|
|
_Strmode = _Mode;
|
|
|
|
if (_Gp) { // make static
|
|
size_t _Size;
|
|
if (_Count == 0) {
|
|
_Size = _CSTD strlen(_Gp);
|
|
} else if (static_cast<unsigned long long>(_Count) < static_cast<unsigned long long>(INT_MAX)) {
|
|
_Size = static_cast<size_t>(_Count);
|
|
} else {
|
|
_Size = INT_MAX;
|
|
}
|
|
|
|
_Seekhigh = _Gp + _Size;
|
|
if (_Pp) { // make writable too
|
|
setg(_Gp, _Gp, _Pp);
|
|
setp(_Pp, _Pp + _Size);
|
|
} else { // set read pointers only
|
|
setg(_Gp, _Gp, _Gp + _Size);
|
|
}
|
|
} else { // make dynamic
|
|
_Strmode |= _Dynamic;
|
|
if (_Count > INT_MAX) {
|
|
_Minsize = INT_MAX;
|
|
} else if (_Minsize < _Count) {
|
|
_Minsize = static_cast<int>(_Count);
|
|
}
|
|
}
|
|
}
|
|
|
|
void __CLR_OR_THIS_CALL _Tidy() noexcept { // free any allocated storage
|
|
if ((_Strmode & (_Allocated | _Frozen)) == _Allocated) {
|
|
_Free(eback());
|
|
}
|
|
|
|
_Seekhigh = nullptr;
|
|
_Strmode &= ~(_Allocated | _Frozen);
|
|
}
|
|
|
|
private:
|
|
enum { // constant for default minimum buffer size
|
|
_MINSIZE = 32
|
|
};
|
|
|
|
char* _Alloc(const size_t _To_allocate) const {
|
|
if (_Palloc) {
|
|
return static_cast<char*>(_Palloc(_To_allocate));
|
|
}
|
|
|
|
return static_cast<char*>(_CSTD _malloc_dbg(_To_allocate, _CRT_BLOCK, __FILE__, __LINE__));
|
|
}
|
|
|
|
void _Free(char* _Ptr) const {
|
|
if (_Pfree) {
|
|
_Pfree(_Ptr);
|
|
return;
|
|
}
|
|
|
|
_CSTD free(_Ptr);
|
|
}
|
|
|
|
int _Minsize; // the minimum buffer size
|
|
char* _Pendsave; // the saved end pointer during freeze
|
|
char* _Seekhigh; // the high-water pointer in character array
|
|
_Strstate _Strmode; // the stream state
|
|
void*(__CLRCALL_OR_CDECL* _Palloc)(size_t); // the pointer to allocator function
|
|
void(__CLRCALL_OR_CDECL* _Pfree)(void*); // the pointer to free function
|
|
};
|
|
|
|
// strstreambuf OPERATORS
|
|
inline void swap(strstreambuf& _Left, strstreambuf& _Right) {
|
|
_Left.swap(_Right);
|
|
}
|
|
|
|
// CLASS istrstream
|
|
class istrstream : public istream { // input stream associated with a character array
|
|
public:
|
|
using _Mybase = istream;
|
|
using _Mysb = strstreambuf;
|
|
|
|
explicit __CLR_OR_THIS_CALL istrstream(const char* _Ptr) : _Mybase(&_Strbuffer), _Strbuffer(_Ptr, 0) {
|
|
// construct with NTBS
|
|
}
|
|
|
|
__CLR_OR_THIS_CALL istrstream(const char* _Ptr, streamsize _Count)
|
|
: _Mybase(&_Strbuffer), _Strbuffer(_Ptr, _Count) {
|
|
// construct with [_Ptr, _Ptr + _Count)
|
|
}
|
|
|
|
explicit __CLR_OR_THIS_CALL istrstream(char* _Ptr) : _Mybase(&_Strbuffer), _Strbuffer(_Ptr, 0) {
|
|
// construct with NTBS
|
|
}
|
|
|
|
__CLR_OR_THIS_CALL istrstream(char* _Ptr, int _Count) : _Mybase(&_Strbuffer), _Strbuffer(_Ptr, _Count) {
|
|
// construct with [_Ptr, _Ptr + _Count)
|
|
}
|
|
|
|
__CLR_OR_THIS_CALL istrstream(istrstream&& _Right) : _Mybase(&_Strbuffer) {
|
|
_Assign_rv(_STD move(_Right));
|
|
}
|
|
|
|
istrstream& __CLR_OR_THIS_CALL operator=(istrstream&& _Right) {
|
|
_Assign_rv(_STD move(_Right));
|
|
return *this;
|
|
}
|
|
|
|
void __CLR_OR_THIS_CALL _Assign_rv(istrstream&& _Right) {
|
|
if (this != _STD addressof(_Right)) {
|
|
_Strbuffer.clear();
|
|
this->swap(_Right);
|
|
}
|
|
}
|
|
|
|
void __CLR_OR_THIS_CALL swap(istrstream& _Right) {
|
|
if (this != _STD addressof(_Right)) {
|
|
_Mybase::swap(_Right);
|
|
_Strbuffer.swap(_Right._Strbuffer);
|
|
}
|
|
}
|
|
|
|
virtual __CLR_OR_THIS_CALL ~istrstream() noexcept {}
|
|
|
|
_NODISCARD _Mysb* __CLR_OR_THIS_CALL rdbuf() const {
|
|
return const_cast<_Mysb*>(&_Strbuffer);
|
|
}
|
|
|
|
_NODISCARD char* __CLR_OR_THIS_CALL str() { // freeze and return pointer to character array
|
|
return _Strbuffer.str();
|
|
}
|
|
|
|
private:
|
|
_Mysb _Strbuffer; // the string buffer
|
|
};
|
|
|
|
// istrstream OPERATORS
|
|
inline void swap(istrstream& _Left, istrstream& _Right) {
|
|
_Left.swap(_Right);
|
|
}
|
|
|
|
// CLASS ostrstream
|
|
class ostrstream : public ostream { // output stream associated with a character array
|
|
public:
|
|
using _Mybase = ostream;
|
|
using _Mysb = strstreambuf;
|
|
|
|
__CLR_OR_THIS_CALL ostrstream() : ostream(&_Strbuffer), _Strbuffer() {}
|
|
|
|
__CLR_OR_THIS_CALL ostrstream(char* _Ptr, streamsize _Count, ios_base::openmode _Mode = ios_base::out)
|
|
: ostream(&_Strbuffer),
|
|
_Strbuffer(_Ptr, _Count, _Ptr && (_Mode & ios_base::app) != 0 ? _Ptr + _CSTD strlen(_Ptr) : _Ptr) {
|
|
// construct with [_Ptr, _Ptr + _Count)
|
|
}
|
|
|
|
__CLR_OR_THIS_CALL ostrstream(ostrstream&& _Right) : _Mybase(&_Strbuffer) {
|
|
_Assign_rv(_STD move(_Right));
|
|
}
|
|
|
|
ostrstream& __CLR_OR_THIS_CALL operator=(ostrstream&& _Right) {
|
|
_Assign_rv(_STD move(_Right));
|
|
return *this;
|
|
}
|
|
|
|
void __CLR_OR_THIS_CALL _Assign_rv(ostrstream&& _Right) {
|
|
if (this != _STD addressof(_Right)) {
|
|
_Strbuffer.clear();
|
|
this->swap(_Right);
|
|
}
|
|
}
|
|
|
|
void __CLR_OR_THIS_CALL swap(ostrstream& _Right) {
|
|
if (this != _STD addressof(_Right)) {
|
|
_Mybase::swap(_Right);
|
|
_Strbuffer.swap(_Right._Strbuffer);
|
|
}
|
|
}
|
|
|
|
virtual __CLR_OR_THIS_CALL ~ostrstream() noexcept {}
|
|
|
|
_NODISCARD _Mysb* __CLR_OR_THIS_CALL rdbuf() const {
|
|
return const_cast<_Mysb*>(&_Strbuffer);
|
|
}
|
|
|
|
void __CLR_OR_THIS_CALL freeze(bool _Freezeit = true) { // freeze or unfreeze writing
|
|
_Strbuffer.freeze(_Freezeit);
|
|
}
|
|
|
|
_NODISCARD char* __CLR_OR_THIS_CALL str() { // freeze and return pointer to character array
|
|
return _Strbuffer.str();
|
|
}
|
|
|
|
_NODISCARD streamsize __CLR_OR_THIS_CALL pcount() const {
|
|
return _Strbuffer.pcount();
|
|
}
|
|
|
|
private:
|
|
_Mysb _Strbuffer; // the string buffer
|
|
};
|
|
|
|
// ostrstream OPERATORS
|
|
inline void swap(ostrstream& _Left, ostrstream& _Right) {
|
|
_Left.swap(_Right);
|
|
}
|
|
|
|
// CLASS strstream
|
|
class strstream : public iostream { // input/output stream associated with character array buffer
|
|
public:
|
|
using _Mybase = iostream;
|
|
using _Mysb = strstreambuf;
|
|
|
|
using char_type = char;
|
|
using int_type = int;
|
|
using pos_type = streampos;
|
|
using off_type = streamoff;
|
|
|
|
__CLR_OR_THIS_CALL strstream() : _Mybase(&_Strbuffer), _Strbuffer() {}
|
|
|
|
__CLR_OR_THIS_CALL strstream(char* _Ptr, streamsize _Count, ios_base::openmode _Mode = ios_base::in | ios_base::out)
|
|
: iostream(&_Strbuffer),
|
|
_Strbuffer(_Ptr, _Count, _Ptr && (_Mode & ios_base::app) != 0 ? _Ptr + _CSTD strlen(_Ptr) : _Ptr) {
|
|
// construct with [_Ptr, _Ptr + _Count)
|
|
}
|
|
|
|
__CLR_OR_THIS_CALL strstream(strstream&& _Right) : _Mybase(&_Strbuffer) {
|
|
_Assign_rv(_STD move(_Right));
|
|
}
|
|
|
|
strstream& __CLR_OR_THIS_CALL operator=(strstream&& _Right) {
|
|
_Assign_rv(_STD move(_Right));
|
|
return *this;
|
|
}
|
|
|
|
void __CLR_OR_THIS_CALL _Assign_rv(strstream&& _Right) {
|
|
if (this != _STD addressof(_Right)) {
|
|
_Strbuffer.clear();
|
|
this->swap(_Right);
|
|
}
|
|
}
|
|
|
|
void __CLR_OR_THIS_CALL swap(strstream& _Right) {
|
|
if (this != _STD addressof(_Right)) {
|
|
_Mybase::swap(_Right);
|
|
_Strbuffer.swap(_Right._Strbuffer);
|
|
}
|
|
}
|
|
|
|
virtual __CLR_OR_THIS_CALL ~strstream() noexcept {}
|
|
|
|
_NODISCARD _Mysb* __CLR_OR_THIS_CALL rdbuf() const {
|
|
return const_cast<_Mysb*>(&_Strbuffer);
|
|
}
|
|
|
|
void __CLR_OR_THIS_CALL freeze(bool _Freezeit = true) { // freeze or unfreeze writing
|
|
_Strbuffer.freeze(_Freezeit);
|
|
}
|
|
|
|
_NODISCARD char* __CLR_OR_THIS_CALL str() { // freeze and return pointer to character array
|
|
return _Strbuffer.str();
|
|
}
|
|
|
|
_NODISCARD streamsize __CLR_OR_THIS_CALL pcount() const {
|
|
return _Strbuffer.pcount();
|
|
}
|
|
|
|
private:
|
|
_Mysb _Strbuffer; // the string buffer
|
|
};
|
|
|
|
// strstream OPERATORS
|
|
inline void swap(strstream& _Left, strstream& _Right) {
|
|
_Left.swap(_Right);
|
|
}
|
|
_STD_END
|
|
#pragma pop_macro("new")
|
|
_STL_RESTORE_CLANG_WARNINGS
|
|
#pragma warning(pop)
|
|
#pragma pack(pop)
|
|
#endif // _STL_COMPILER_PREPROCESSOR
|
|
#endif // _STRSTREAM_
|