зеркало из https://github.com/microsoft/STL.git
418 строки
14 KiB
C++
418 строки
14 KiB
C++
// streambuf standard header
|
|
|
|
// Copyright (c) Microsoft Corporation.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
|
|
#pragma once
|
|
#ifndef _STREAMBUF_
|
|
#define _STREAMBUF_
|
|
#include <yvals_core.h>
|
|
#if _STL_COMPILER_PREPROCESSOR
|
|
#include <xiosbase>
|
|
|
|
#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
|
|
// CLASS TEMPLATE basic_streambuf
|
|
template <class _Elem, class _Traits>
|
|
class basic_streambuf { // control read/write buffers
|
|
protected:
|
|
__CLR_OR_THIS_CALL basic_streambuf() : _Plocale(new locale) {
|
|
_Init();
|
|
}
|
|
|
|
__CLR_OR_THIS_CALL basic_streambuf(_Uninitialized) {}
|
|
|
|
__CLR_OR_THIS_CALL basic_streambuf(const basic_streambuf& _Right) : _Plocale(new locale(_Right.getloc())) {
|
|
_Init();
|
|
setp(_Right.pbase(), _Right.pptr(), _Right.epptr());
|
|
setg(_Right.eback(), _Right.gptr(), _Right.egptr());
|
|
}
|
|
|
|
basic_streambuf& __CLR_OR_THIS_CALL operator=(const basic_streambuf& _Right) {
|
|
if (this != _STD addressof(_Right)) {
|
|
setp(_Right.pbase(), _Right.pptr(), _Right.epptr());
|
|
setg(_Right.eback(), _Right.gptr(), _Right.egptr());
|
|
pubimbue(_Right.getloc());
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
void __CLR_OR_THIS_CALL swap(basic_streambuf& _Right) {
|
|
if (this != _STD addressof(_Right)) {
|
|
_Elem* _Pfirst0 = pbase();
|
|
_Elem* _Pnext0 = pptr();
|
|
_Elem* _Pend = epptr();
|
|
_Elem* _Gfirst0 = eback();
|
|
_Elem* _Gnext0 = gptr();
|
|
_Elem* _Gend = egptr();
|
|
|
|
setp(_Right.pbase(), _Right.pptr(), _Right.epptr());
|
|
_Right.setp(_Pfirst0, _Pnext0, _Pend);
|
|
|
|
setg(_Right.eback(), _Right.gptr(), _Right.egptr());
|
|
_Right.setg(_Gfirst0, _Gnext0, _Gend);
|
|
|
|
_STD swap(_Plocale, _Right._Plocale);
|
|
}
|
|
}
|
|
|
|
public:
|
|
using char_type = _Elem;
|
|
using traits_type = _Traits;
|
|
|
|
virtual __CLR_OR_THIS_CALL ~basic_streambuf() noexcept {
|
|
delete _Plocale;
|
|
}
|
|
|
|
using int_type = typename _Traits::int_type;
|
|
using pos_type = typename _Traits::pos_type;
|
|
using off_type = typename _Traits::off_type;
|
|
|
|
pos_type __CLR_OR_THIS_CALL pubseekoff(off_type _Off, ios_base::seekdir _Way,
|
|
ios_base::openmode _Mode = ios_base::in | ios_base::out) { // change position by _Off, according to _Way, _Mode
|
|
return seekoff(_Off, _Way, _Mode);
|
|
}
|
|
|
|
#if _HAS_OLD_IOSTREAMS_MEMBERS
|
|
pos_type __CLR_OR_THIS_CALL pubseekoff(off_type _Off, ios_base::seek_dir _Way,
|
|
ios_base::open_mode _Mode) { // change position by _Off, according to _Way, _Mode (old style)
|
|
return pubseekoff(_Off, static_cast<ios_base::seekdir>(_Way), static_cast<ios_base::openmode>(_Mode));
|
|
}
|
|
#endif // _HAS_OLD_IOSTREAMS_MEMBERS
|
|
|
|
pos_type __CLR_OR_THIS_CALL pubseekpos(pos_type _Pos,
|
|
ios_base::openmode _Mode = ios_base::in | ios_base::out) { // change position to _Pos, according to _Mode
|
|
return seekpos(_Pos, _Mode);
|
|
}
|
|
|
|
#if _HAS_OLD_IOSTREAMS_MEMBERS
|
|
pos_type __CLR_OR_THIS_CALL pubseekpos(pos_type _Pos,
|
|
ios_base::open_mode _Mode) { // change position to _Pos, according to _Mode (old style)
|
|
return seekpos(_Pos, static_cast<ios_base::openmode>(_Mode));
|
|
}
|
|
#endif // _HAS_OLD_IOSTREAMS_MEMBERS
|
|
|
|
basic_streambuf* __CLR_OR_THIS_CALL pubsetbuf(_Elem* _Buffer,
|
|
streamsize _Count) { // offer _Buffer to external agent
|
|
return setbuf(_Buffer, _Count);
|
|
}
|
|
|
|
locale __CLR_OR_THIS_CALL pubimbue(const locale& _Newlocale) { // set locale to argument
|
|
locale _Oldlocale = *_Plocale;
|
|
imbue(_Newlocale);
|
|
*_Plocale = _Newlocale;
|
|
return _Oldlocale;
|
|
}
|
|
|
|
locale __CLR_OR_THIS_CALL getloc() const { // get locale
|
|
return *_Plocale;
|
|
}
|
|
|
|
streamsize __CLR_OR_THIS_CALL in_avail() {
|
|
streamsize _Res = _Gnavail();
|
|
return 0 < _Res ? _Res : showmanyc();
|
|
}
|
|
|
|
int __CLR_OR_THIS_CALL pubsync() { // synchronize with external agent
|
|
return sync();
|
|
}
|
|
|
|
int_type __CLR_OR_THIS_CALL sbumpc() { // get a character and point past it
|
|
return 0 < _Gnavail() ? _Traits::to_int_type(*_Gninc()) : uflow();
|
|
}
|
|
|
|
int_type __CLR_OR_THIS_CALL sgetc() { // get a character and don't point past it
|
|
return 0 < _Gnavail() ? _Traits::to_int_type(*gptr()) : underflow();
|
|
}
|
|
|
|
streamsize __CLR_OR_THIS_CALL sgetn(_Elem* _Ptr,
|
|
streamsize _Count) { // get up to _Count characters into array beginning at _Ptr
|
|
return xsgetn(_Ptr, _Count);
|
|
}
|
|
|
|
int_type __CLR_OR_THIS_CALL snextc() { // point to next character and return it
|
|
return 1 < _Gnavail() ? _Traits::to_int_type(*_Gnpreinc())
|
|
: _Traits::eq_int_type(_Traits::eof(), sbumpc()) ? _Traits::eof()
|
|
: sgetc();
|
|
}
|
|
|
|
int_type __CLR_OR_THIS_CALL sputbackc(_Elem _Ch) { // put back _Ch
|
|
if (gptr() && eback() < gptr() && _Traits::eq(_Ch, gptr()[-1])) {
|
|
return _Traits::to_int_type(*_Gndec());
|
|
}
|
|
|
|
return pbackfail(_Traits::to_int_type(_Ch));
|
|
}
|
|
|
|
#if _HAS_OLD_IOSTREAMS_MEMBERS
|
|
void __CLR_OR_THIS_CALL stossc() { // point past a character
|
|
if (0 < _Gnavail()) {
|
|
_Gninc();
|
|
} else {
|
|
uflow();
|
|
}
|
|
}
|
|
#endif // _HAS_OLD_IOSTREAMS_MEMBERS
|
|
|
|
int_type __CLR_OR_THIS_CALL sungetc() { // back up one position
|
|
return gptr() && eback() < gptr() ? _Traits::to_int_type(*_Gndec()) : pbackfail();
|
|
}
|
|
|
|
int_type __CLR_OR_THIS_CALL sputc(_Elem _Ch) { // put a character
|
|
return 0 < _Pnavail() ? _Traits::to_int_type(*_Pninc() = _Ch) : overflow(_Traits::to_int_type(_Ch));
|
|
}
|
|
|
|
streamsize __CLR_OR_THIS_CALL sputn(const _Elem* _Ptr,
|
|
streamsize _Count) { // put _Count characters from array beginning at _Ptr
|
|
return xsputn(_Ptr, _Count);
|
|
}
|
|
|
|
virtual void __CLR_OR_THIS_CALL _Lock() {} // set the thread lock (overridden by basic_filebuf)
|
|
|
|
virtual void __CLR_OR_THIS_CALL _Unlock() {} // clear the thread lock (overridden by basic_filebuf)
|
|
|
|
protected:
|
|
_Elem* __CLR_OR_THIS_CALL eback() const {
|
|
return *_IGfirst;
|
|
}
|
|
|
|
_Elem* __CLR_OR_THIS_CALL gptr() const {
|
|
return *_IGnext;
|
|
}
|
|
|
|
_Elem* __CLR_OR_THIS_CALL pbase() const {
|
|
return *_IPfirst;
|
|
}
|
|
|
|
_Elem* __CLR_OR_THIS_CALL pptr() const {
|
|
return *_IPnext;
|
|
}
|
|
|
|
_Elem* __CLR_OR_THIS_CALL egptr() const {
|
|
return *_IGnext + *_IGcount;
|
|
}
|
|
|
|
void __CLR_OR_THIS_CALL gbump(int _Off) { // alter current position in read buffer by _Off
|
|
*_IGcount -= _Off;
|
|
*_IGnext += _Off;
|
|
}
|
|
|
|
void __CLR_OR_THIS_CALL setg(_Elem* _First, _Elem* _Next, _Elem* _Last) { // set pointers for read buffer
|
|
*_IGfirst = _First;
|
|
*_IGnext = _Next;
|
|
*_IGcount = static_cast<int>(_Last - _Next);
|
|
}
|
|
|
|
_Elem* __CLR_OR_THIS_CALL epptr() const {
|
|
return *_IPnext + *_IPcount;
|
|
}
|
|
|
|
_Elem* __CLR_OR_THIS_CALL _Gndec() { // decrement current position in read buffer
|
|
++*_IGcount;
|
|
return --*_IGnext;
|
|
}
|
|
|
|
_Elem* __CLR_OR_THIS_CALL _Gninc() { // increment current position in read buffer
|
|
--*_IGcount;
|
|
return (*_IGnext)++;
|
|
}
|
|
|
|
_Elem* __CLR_OR_THIS_CALL _Gnpreinc() { // preincrement current position in read buffer
|
|
--*_IGcount;
|
|
return ++(*_IGnext);
|
|
}
|
|
|
|
streamsize __CLR_OR_THIS_CALL _Gnavail() const { // count number of available elements in read buffer
|
|
return *_IGnext ? *_IGcount : 0;
|
|
}
|
|
|
|
void __CLR_OR_THIS_CALL pbump(int _Off) { // alter current position in write buffer by _Off
|
|
*_IPcount -= _Off;
|
|
*_IPnext += _Off;
|
|
}
|
|
|
|
void __CLR_OR_THIS_CALL setp(_Elem* _First, _Elem* _Last) { // set pointers for write buffer
|
|
*_IPfirst = _First;
|
|
*_IPnext = _First;
|
|
*_IPcount = static_cast<int>(_Last - _First);
|
|
}
|
|
|
|
void __CLR_OR_THIS_CALL setp(
|
|
_Elem* _First, _Elem* _Next, _Elem* _Last) { // set pointers for write buffer, extended version
|
|
*_IPfirst = _First;
|
|
*_IPnext = _Next;
|
|
*_IPcount = static_cast<int>(_Last - _Next);
|
|
}
|
|
|
|
_Elem* __CLR_OR_THIS_CALL _Pninc() { // increment current position in write buffer
|
|
--*_IPcount;
|
|
return (*_IPnext)++;
|
|
}
|
|
|
|
streamsize __CLR_OR_THIS_CALL _Pnavail() const { // count number of available positions in write buffer
|
|
return *_IPnext ? *_IPcount : 0;
|
|
}
|
|
|
|
void __CLR_OR_THIS_CALL _Init() { // initialize buffer parameters for no buffers
|
|
_IGfirst = &_Gfirst;
|
|
_IPfirst = &_Pfirst;
|
|
_IGnext = &_Gnext;
|
|
_IPnext = &_Pnext;
|
|
_IGcount = &_Gcount;
|
|
_IPcount = &_Pcount;
|
|
setp(nullptr, nullptr);
|
|
setg(nullptr, nullptr, nullptr);
|
|
}
|
|
|
|
void __CLR_OR_THIS_CALL _Init(_Elem** _Gf, _Elem** _Gn, int* _Gc, _Elem** _Pf, _Elem** _Pn, int* _Pc) {
|
|
// initialize buffer parameters as specified
|
|
_IGfirst = _Gf;
|
|
_IPfirst = _Pf;
|
|
_IGnext = _Gn;
|
|
_IPnext = _Pn;
|
|
_IGcount = _Gc;
|
|
_IPcount = _Pc;
|
|
}
|
|
|
|
virtual int_type __CLR_OR_THIS_CALL overflow(int_type = _Traits::eof()) { // put a character to stream (always fail)
|
|
return _Traits::eof();
|
|
}
|
|
|
|
virtual int_type __CLR_OR_THIS_CALL pbackfail(int_type = _Traits::eof()) {
|
|
// put a character back to stream (always fail)
|
|
return _Traits::eof();
|
|
}
|
|
|
|
virtual streamsize __CLR_OR_THIS_CALL showmanyc() {
|
|
return 0;
|
|
}
|
|
|
|
virtual int_type __CLR_OR_THIS_CALL underflow() { // get a character from stream, but don't point past it
|
|
return _Traits::eof();
|
|
}
|
|
|
|
virtual int_type __CLR_OR_THIS_CALL uflow() { // get a character from stream, point past it
|
|
return _Traits::eq_int_type(_Traits::eof(), underflow()) ? _Traits::eof() : _Traits::to_int_type(*_Gninc());
|
|
}
|
|
|
|
virtual streamsize __CLR_OR_THIS_CALL xsgetn(_Elem* _Ptr, streamsize _Count) { // get _Count characters from stream
|
|
const streamsize _Start_count = _Count;
|
|
|
|
while (0 < _Count) {
|
|
streamsize _Size = _Gnavail();
|
|
if (0 < _Size) { // copy from read buffer
|
|
if (_Count < _Size) {
|
|
_Size = _Count;
|
|
}
|
|
|
|
_Traits::copy(_Ptr, gptr(), static_cast<size_t>(_Size));
|
|
_Ptr += _Size;
|
|
_Count -= _Size;
|
|
gbump(static_cast<int>(_Size));
|
|
} else {
|
|
const int_type _Meta = uflow();
|
|
if (_Traits::eq_int_type(_Traits::eof(), _Meta)) {
|
|
break; // end of file, quit
|
|
}
|
|
|
|
// get a single character
|
|
*_Ptr++ = _Traits::to_char_type(_Meta);
|
|
--_Count;
|
|
}
|
|
}
|
|
|
|
return _Start_count - _Count;
|
|
}
|
|
|
|
virtual streamsize __CLR_OR_THIS_CALL xsputn(const _Elem* _Ptr, streamsize _Count) {
|
|
// put _Count characters to stream
|
|
const streamsize _Start_count = _Count;
|
|
while (0 < _Count) {
|
|
streamsize _Size = _Pnavail();
|
|
if (0 < _Size) { // copy to write buffer
|
|
if (_Count < _Size) {
|
|
_Size = _Count;
|
|
}
|
|
|
|
_Traits::copy(pptr(), _Ptr, static_cast<size_t>(_Size));
|
|
_Ptr += _Size;
|
|
_Count -= _Size;
|
|
pbump(static_cast<int>(_Size));
|
|
} else if (_Traits::eq_int_type(_Traits::eof(), overflow(_Traits::to_int_type(*_Ptr)))) {
|
|
break; // single character put failed, quit
|
|
} else { // count character successfully put
|
|
++_Ptr;
|
|
--_Count;
|
|
}
|
|
}
|
|
|
|
return _Start_count - _Count;
|
|
}
|
|
|
|
virtual pos_type __CLR_OR_THIS_CALL seekoff(
|
|
off_type, ios_base::seekdir, ios_base::openmode = ios_base::in | ios_base::out) {
|
|
// change position by offset, according to way and mode
|
|
return streampos(-1);
|
|
}
|
|
|
|
virtual pos_type __CLR_OR_THIS_CALL seekpos(pos_type, ios_base::openmode = ios_base::in | ios_base::out) {
|
|
// change to specified position, according to mode
|
|
return streampos(-1);
|
|
}
|
|
|
|
virtual basic_streambuf* __CLR_OR_THIS_CALL setbuf(_Elem*, streamsize) {
|
|
// offer buffer to external agent (do nothing)
|
|
return this;
|
|
}
|
|
|
|
virtual int __CLR_OR_THIS_CALL sync() { // synchronize with external agent (do nothing)
|
|
return 0;
|
|
}
|
|
|
|
virtual void __CLR_OR_THIS_CALL imbue(const locale&) {} // set locale to argument (do nothing)
|
|
|
|
private:
|
|
_Elem* _Gfirst; // beginning of read buffer
|
|
_Elem* _Pfirst; // beginning of write buffer
|
|
_Elem** _IGfirst; // pointer to beginning of read buffer
|
|
_Elem** _IPfirst; // pointer to beginning of write buffer
|
|
_Elem* _Gnext; // current position in read buffer
|
|
_Elem* _Pnext; // current position in write buffer
|
|
_Elem** _IGnext; // pointer to current position in read buffer
|
|
_Elem** _IPnext; // pointer to current position in write buffer
|
|
|
|
int _Gcount; // length of read buffer
|
|
int _Pcount; // length of write buffer
|
|
int* _IGcount; // pointer to length of read buffer
|
|
int* _IPcount; // pointer to length of write buffer
|
|
|
|
protected:
|
|
locale* _Plocale; // pointer to imbued locale object
|
|
};
|
|
|
|
#if defined(_DLL_CPPLIB)
|
|
|
|
#if !defined(_CRTBLD) || defined(__FORCE_INSTANCE)
|
|
template class _CRTIMP2_PURE_IMPORT basic_streambuf<char, char_traits<char>>;
|
|
template class _CRTIMP2_PURE_IMPORT basic_streambuf<wchar_t, char_traits<wchar_t>>;
|
|
#endif // !defined(_CRTBLD) || defined(__FORCE_INSTANCE)
|
|
|
|
#ifdef __FORCE_INSTANCE
|
|
template class _CRTIMP2_PURE_IMPORT basic_streambuf<unsigned short, char_traits<unsigned short>>;
|
|
#endif // __FORCE_INSTANCE
|
|
#endif // defined(_DLL_CPPLIB)
|
|
_STD_END
|
|
|
|
#pragma pop_macro("new")
|
|
_STL_RESTORE_CLANG_WARNINGS
|
|
#pragma warning(pop)
|
|
#pragma pack(pop)
|
|
#endif // _STL_COMPILER_PREPROCESSOR
|
|
#endif // _STREAMBUF_
|