STL/stl/inc/streambuf

420 строки
14 KiB
C++
Исходник Обычный вид История

2019-09-05 01:57:56 +03:00
// 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_