istream

// istream standard header

#pragma once

#ifndef _ISTREAM_

#define _ISTREAM_

#ifndef RC_INVOKED #include <ostream>

#pragma pack(push,_CRT_PACKING)

#pragma pack(push,

)

#pragma warning(push,_STL_WARNING_LEVEL)

#pragma warning(push,

)

#pragma warning(disable: _STL_DISABLED_WARNINGS)

#pragma warning(disable:

4455

4494

4619

4643

4702

4984

4988

)

_STL_DISABLE_CLANG_WARNINGS

#pragma push_macro("new")

#undef new

_STD_BEGIN

namespace

std

{

#pragma vtordisp(push, 2) // compiler bug workaround

#pragma vtordisp(push,

)

// CLASS TEMPLATE basic_istream

template

class

_Elem

class

_Traits

class

basic_istream

virtual

public

basic_ios

_Elem

_Traits

> {

// control extractions from a stream buffer

public

typedef

basic_ios

_Elem

_Traits

_Myios

;

typedef

basic_streambuf

_Elem

_Traits

_Mysb

;

typedef

istreambuf_iterator

_Elem

_Traits

_Iter

;

typedef

ctype

_Elem

_Ctype

;

typedef

num_get

_Elem

_Iter

_Nget

;

#if defined(__FORCE_INSTANCE)

explicit __CLR_OR_THIS_CALL basic_istream(_Mysb *_Strbuf,

bool _Isstd, bool _Noinit)

: _Chcount(0)

{ // construct from stream buffer pointer

if (!_Noinit)

_Myios::init(_Strbuf, _Isstd);

} #endif /* defined(__FORCE_INSTANCE) */

explicit __CLR_OR_THIS_CALL basic_istream(_Mysb *_Strbuf,

explicit

basic_istream

(

_Mysb

_Strbuf

bool

_Isstd

false

) : _Chcount(

) {

// construct from stream buffer pointer

_Myios

init

(

_Strbuf

_Isstd

); }

__CLR_OR_THIS_CALL basic_istream(_Uninitialized)

basic_istream

(

_Uninitialized

)

{

// construct uninitialized

this

_Addstd

(

this

); }

protected

__CLR_OR_THIS_CALL basic_istream(basic_istream&& _Right)

basic_istream

(

basic_istream

_Right

)

: _Chcount(

_Right

_Chcount

) {

// construct by moving _Right

_Myios

init

();

_Myios::move(_STD move(_Right));

_Myios

move

(::

std

move

(

_Right

));

_Right

_Chcount

; }

basic_istream& __CLR_OR_THIS_CALL operator=(basic_istream&& _Right)

basic_istream

operator

(

basic_istream

_Right

)

{

// move from _Right

this

swap

(

_Right

);

return

this

); }

void __CLR_OR_THIS_CALL swap(basic_istream& _Right)

void

swap

(

basic_istream

_Right

)

{

// swap with _Right

_Myios

swap

(

_Right

);

_STD swap(_Chcount, _Right._Chcount);

std

swap

(

_Chcount

_Right

_Chcount

);

}

public

__CLR_OR_THIS_CALL basic_istream(const basic_istream&) = delete;

basic_istream

(

const

basic_istream

&) =

delete

;

basic_istream& __CLR_OR_THIS_CALL operator=(const basic_istream&) = delete;

basic_istream

operator

(

const

basic_istream

&) =

delete

;

virtual __CLR_OR_THIS_CALL ~basic_istream() noexcept

virtual

basic_istream

()

noexcept

{

// destroy the object

}

typedef

typename

_Traits

::int_type

int_type

;

typedef

typename

_Traits

::pos_type

pos_type

;

typedef

typename

_Traits

::off_type

off_type

;

// CLASS TEMPLATE sentry

class

_Sentry_base

{

// stores thread lock and reference to input stream

public

__CLR_OR_THIS_CALL _Sentry_base(basic_istream& _Istr)

_Sentry_base

(

basic_istream

_Istr

)

: _Myistr(

_Istr

) {

// lock the stream buffer, if there

(

_Myistr

rdbuf

() !=

nullptr

)

_Myistr

rdbuf

()->_Lock(); }

__CLR_OR_THIS_CALL ~_Sentry_base() noexcept

_Sentry_base

()

noexcept

{

// destroy after unlocking

(

_Myistr

rdbuf

() !=

nullptr

)

_Myistr

rdbuf

()->_Unlock(); }

basic_istream

_Myistr

;

// the input stream, for _Unlock call at destruction

_Sentry_base

operator

(

const

_Sentry_base

&) =

delete

; };

class

sentry

public

_Sentry_base

{

// stores thread lock and result of _Ipfx call

public

explicit __CLR_OR_THIS_CALL sentry(basic_istream& _Istr, bool _Noskip = false)

explicit

sentry

(

basic_istream

_Istr

bool

_Noskip

false

)

_Sentry_base

(

_Istr

) {

// construct locking and calling _Ipfx

_Ok

this

_Myistr

_Ipfx

(

_Noskip

); }

explicit __CLR_OR_THIS_CALL operator bool() const

explicit

operator

bool

()

const

{

// test if _Ipfx succeeded

return

(

_Ok

); }

__CLR_OR_THIS_CALL sentry(const sentry&) = delete;

sentry

(

const

sentry

&) =

delete

;

sentry& __CLR_OR_THIS_CALL operator=(const sentry&) = delete;

sentry

operator

(

const

sentry

&) =

delete

;

private

bool

_Ok

;

// true if _Ipfx succeeded at construction

};

bool __CLR_OR_THIS_CALL _Ipfx(bool _Noskip = false)

bool

_Ipfx

(

bool

_Noskip

false

)

{

// test stream state and skip whitespace as needed

(

this

good

()) {

// state okay, flush tied stream and skip whitespace

(

_Myios

tie

() !=

nullptr

)

_Myios

tie

()->flush();

_Noskip

this

flags

() &

ios_base

skipws

) {

// skip whitespace

const _Ctype& _Ctype_fac = _STD use_facet<_Ctype>(this->getloc());

const

_Ctype

_Ctype_fac

= ::

std

use_facet

_Ctype

this

getloc

());

_TRY_IO_BEGIN

try

{

int_type

_Meta

_Myios

rdbuf

()->sgetc();

for

(; ;

_Meta

_Myios

rdbuf

()->snextc())

(

_Traits

::eq_int_type(

_Traits

::eof(),

_Meta

)) {

// end of file, quit

_Myios

setstate

(

ios_base

eofbit

);

break

; }

else

_Ctype_fac

(

_Ctype

space

_Traits

::to_char_type(

_Meta

)))

break

;

// not whitespace, quit

_CATCH_IO_END

}

catch

(...) {

_Myios

setstate

(

ios_base

badbit

true

); }

}

(

this

good

())

return

(

true

); }

_Myios

setstate

(

ios_base

failbit

);

return

(

false

); }

bool __CLR_OR_THIS_CALL ipfx(bool _Noskip = false)

bool

ipfx

(

bool

_Noskip

false

)

{

// test stream state and skip whitespace as needed (retained)

return

(

_Ipfx

(

_Noskip

)); }

void __CLR_OR_THIS_CALL isfx()

void

isfx

()

{

// perform any wrapup (retained)

}

#ifdef _M_CEE_PURE

basic_istream& __CLR_OR_THIS_CALL operator>>(basic_istream& (__clrcall *_Pfn)(basic_istream&))

{ // call basic_istream manipulator

return ((*_Pfn)(*this));

}

basic_istream& __CLR_OR_THIS_CALL operator>>(_Myios& (__clrcall *_Pfn)(_Myios&))

{ // call basic_ios manipulator

(*_Pfn)(*(_Myios *)this);

return (*this);

}

basic_istream& __CLR_OR_THIS_CALL operator>>(ios_base& (__clrcall *_Pfn)(ios_base&))

{ // call ios_base manipulator

(*_Pfn)(*(ios_base *)this);

return (*this);

}

#endif /* _M_CEE_PURE */

basic_istream& __CLR_OR_THIS_CALL operator>>(basic_istream& (__cdecl *_Pfn)(basic_istream&))

basic_istream

operator

(

basic_istream

& (

__cdecl

_Pfn

)(

basic_istream

&))

{

// call basic_istream manipulator

return

((*

_Pfn

)(*

this

)); }

basic_istream& __CLR_OR_THIS_CALL operator>>(_Myios& (__cdecl *_Pfn)(_Myios&))

basic_istream

operator

(

_Myios

& (

__cdecl

_Pfn

)(

_Myios

&))

{

// call basic_ios manipulator

_Pfn

)(*(

_Myios

this

);

return

this

); }

basic_istream& __CLR_OR_THIS_CALL operator>>(ios_base& (__cdecl *_Pfn)(ios_base&))

basic_istream

operator

(

ios_base

& (

__cdecl

_Pfn

)(

ios_base

&))

{

// call ios_base manipulator

_Pfn

)(*(

ios_base

this

);

return

this

); }

private

template

class

_Ty

basic_istream

_Common_extract_with_num_get

(

_Ty

_Val

) {

// formatted extract with num_get

ios_base

iostate

_Err

ios_base

goodbit

;

const

sentry

_Ok

this

);

(

_Ok

) {

// state okay, use facet to extract

_TRY_IO_BEGIN

try

{

_STD use_facet<_Nget>(this->getloc()).get(*this, {}, *this, _Err, _Val);

std

use_facet

_Nget

this

getloc

()).

get

this

, {}, *

this

_Err

_Val

);

_CATCH_IO_END

}

catch

(...) {

_Myios

setstate

(

ios_base

badbit

true

); }

}

_Myios

setstate

(

_Err

);

return

this

); }

public

basic_istream& __CLR_OR_THIS_CALL operator>>(bool& _Val)

basic_istream

operator

(

bool

_Val

)

{

// extract a boolean

return

(

_Common_extract_with_num_get

(

_Val

)); }

basic_istream& __CLR_OR_THIS_CALL operator>>(short& _Val)

basic_istream

operator

(

short

_Val

)

{

// extract a short

ios_base

iostate

_Err

ios_base

goodbit

;

const

sentry

_Ok

this

);

(

_Ok

) {

// state okay, use facet to extract

_TRY_IO_BEGIN

try

{

long

_Lval

;

_STD use_facet<_Nget>(this->getloc()).get(*this, {}, *this, _Err, _Lval);

std

use_facet

_Nget

this

getloc

()).

get

this

, {}, *

this

_Err

_Lval

);

if (_Lval < SHRT_MIN)

(

_Lval

32768

))

{

_Err

ios_base

failbit

;

_Val = SHRT_MIN;

_Val

= (-

32768

);

}

else if (_Lval > SHRT_MAX)

else

(

_Lval

32767

)

{

_Err

ios_base

failbit

;

_Val = SHRT_MAX;

_Val

32767

;

}

else

{

_Val

static_cast

short

_Lval

); }

_CATCH_IO_END

}

catch

(...) {

_Myios

setstate

(

ios_base

badbit

true

); }

}

_Myios

setstate

(

_Err

);

return

this

); }

/* NOTE: If you are not using native wchar_t, the unsigned short extractor is masked by an explicit specialization that treats an unsigned short as a wide character. To read or write unsigned shorts as integers with wchar_t streams, make wchar_t a native type with the command line option /Zc:wchar_t. */

basic_istream& __CLR_OR_THIS_CALL operator>>(unsigned short& _Val)

basic_istream

operator

(

unsigned

short

_Val

)

{

// extract an unsigned short

return

(

_Common_extract_with_num_get

(

_Val

)); }

basic_istream& __CLR_OR_THIS_CALL operator>>(int& _Val)

basic_istream

operator

(

int

_Val

)

{

// extract an int

static_assert

(

sizeof

(

int

)

sizeof

(

long

"Bad overflow assumptions due to sizeof(int) != sizeof(long)"

);

long

_Result

_Val

;

_Common_extract_with_num_get

(

_Result

);

_Val

_Result

;

return

this

); }

basic_istream& __CLR_OR_THIS_CALL operator>>(unsigned int& _Val)

basic_istream

operator

(

unsigned

int

_Val

)

{

// extract an unsigned int

return

(

_Common_extract_with_num_get

(

_Val

)); }

basic_istream& __CLR_OR_THIS_CALL operator>>(long& _Val)

basic_istream

operator

(

long

_Val

)

{

// extract a long

return

(

_Common_extract_with_num_get

(

_Val

)); }

basic_istream& __CLR_OR_THIS_CALL operator>>(unsigned long& _Val)

basic_istream

operator

(

unsigned

long

_Val

)

{

// extract an unsigned long

return

(

_Common_extract_with_num_get

(

_Val

)); }

basic_istream& __CLR_OR_THIS_CALL operator>>(long long& _Val)

basic_istream

operator

(

long

_Val

)

{

// extract a long long

return

(

_Common_extract_with_num_get

(

_Val

)); }

basic_istream& __CLR_OR_THIS_CALL operator>>(unsigned long long& _Val)

basic_istream

operator

(

unsigned

long

_Val

)

{

// extract an unsigned long long

return

(

_Common_extract_with_num_get

(

_Val

)); }

basic_istream& __CLR_OR_THIS_CALL operator>>(float& _Val)

basic_istream

operator

(

float

_Val

)

{

// extract a float

return

(

_Common_extract_with_num_get

(

_Val

)); }

basic_istream& __CLR_OR_THIS_CALL operator>>(double& _Val)

basic_istream

operator

(

double

_Val

)

{

// extract a double

return

(

_Common_extract_with_num_get

(

_Val

)); }

basic_istream& __CLR_OR_THIS_CALL operator>>(long double& _Val)

basic_istream

operator

(

long

double

_Val

)

{

// extract a long double

return

(

_Common_extract_with_num_get

(

_Val

)); }

basic_istream& __CLR_OR_THIS_CALL operator>>(void *& _Val)

basic_istream

operator

(

void

_Val

)

{

// extract a void pointer

return

(

_Common_extract_with_num_get

(

_Val

)); }

basic_istream& __CLR_OR_THIS_CALL operator>>(_Mysb * _Strbuf)

basic_istream

operator

(

_Mysb

_Strbuf

)

{

// extract until end-of-file into a stream buffer

_Chcount

;

// behaves as an unformatted input function

const

sentry

_Ok

this

true

);

ios_base

iostate

_State

ios_base

goodbit

;

(

_Ok

_Strbuf

nullptr

) {

// state okay, extract characters

_TRY_IO_BEGIN

try

{

for

(

int_type

_Meta

_Myios

rdbuf

()->sgetc(); ;

_Meta

_Myios

rdbuf

()->snextc()) {

(

_Traits

::eq_int_type(

_Traits

::eof(),

_Meta

)) {

// end of file, quit

_State

ios_base

eofbit

;

break

; }

// got a character, insert it into buffer

_TRY_BEGIN

try

{

(

_Traits

::eq_int_type(

_Traits

::eof(),

_Strbuf

sputc

(

_Traits

::to_char_type(

_Meta

)))) {

break

; }

_CATCH_ALL

}

catch

(...) {

break

;

_CATCH_END

}

_Chcount

; }

_CATCH_IO_END

}

catch

(...) {

_Myios

setstate

(

ios_base

badbit

true

); }

}

(

_Chcount

) {

// If the function inserts no characters, it calls setstate(failbit)

_State

ios_base

failbit

; }

_Myios

setstate

(

_State

);

return

this

); }

int_type __CLR_OR_THIS_CALL get()

int_type

get

()

{

// extract a metacharacter

int_type

_Meta

;

ios_base

iostate

_State

ios_base

goodbit

;

_Chcount

;

const

sentry

_Ok

this

true

);

_Ok

)

_Meta

_Traits

::eof();

// state not okay, return EOF

else

{

// state okay, extract a character

_TRY_IO_BEGIN

try

{

_Meta

_Myios

rdbuf

()->sgetc();

(

_Traits

::eq_int_type(

_Traits

::eof(),

_Meta

))

_State

ios_base

eofbit

ios_base

failbit

;

// end of file

else

{

// got a character, count it

_Myios

rdbuf

()->sbumpc(); ++

_Chcount

; }

_CATCH_IO_END

}

catch

(...) {

_Myios

setstate

(

ios_base

badbit

true

); }

}

_Myios

setstate

(

_State

);

return

(

_Meta

); }

basic_istream& __CLR_OR_THIS_CALL get(_Elem *_Str, streamsize _Count)

basic_istream

get

(

_Elem

_Str

streamsize

_Count

)

{

// get up to _Count characters into NTCS

return

(

get

(

_Str

_Count

_Myios

widen

(

'\n'

))); }

basic_istream& __CLR_OR_THIS_CALL get(_Elem *_Str,

basic_istream

get

(

_Elem

_Str

streamsize

_Count

_Elem

_Delim

) {

// get up to _Count characters into NTCS, stop before _Delim

ios_base

iostate

_State

ios_base

goodbit

;

_Chcount

;

const

sentry

_Ok

this

true

);

(

_Ok

_Count

) {

// state okay, extract characters

_TRY_IO_BEGIN

try

{

int_type

_Meta

_Myios

rdbuf

()->sgetc();

for

(;

_Count

;

_Meta

_Myios

rdbuf

()->snextc())

(

_Traits

::eq_int_type(

_Traits

::eof(),

_Meta

)) {

// end of file, quit

_State

ios_base

eofbit

;

break

; }

else

(

_Traits

::to_char_type(

_Meta

) ==

_Delim

)

break

;

// got a delimiter, quit

else

{

// got a character, add it to string

_Str

++ =

_Traits

::to_char_type(

_Meta

); ++

_Chcount

; }

_CATCH_IO_END

}

catch

(...) {

_Myios

setstate

(

ios_base

badbit

true

); }

}

_Myios

setstate

(

_Chcount

_State

ios_base

failbit

_State

); *

_Str

_Elem

();

// add terminating null character

return

this

); }

basic_istream& __CLR_OR_THIS_CALL get(_Elem& _Ch)

basic_istream

get

(

_Elem

_Ch

)

{

// get a character

int_type

_Meta

get

();

_Traits

::eq_int_type(

_Traits

::eof(),

_Meta

))

_Ch

_Traits

::to_char_type(

_Meta

);

return

this

); }

basic_istream& __CLR_OR_THIS_CALL get(_Mysb& _Strbuf)

basic_istream

get

(

_Mysb

_Strbuf

)

{

// extract up to newline and insert into stream buffer

return

(

get

(

_Strbuf

_Myios

widen

(

'\n'

))); }

basic_istream& __CLR_OR_THIS_CALL get(_Mysb& _Strbuf, _Elem _Delim)

basic_istream

get

(

_Mysb

_Strbuf

_Elem

_Delim

)

{

// extract up to delimiter and insert into stream buffer

ios_base

iostate

_State

ios_base

goodbit

;

_Chcount

;

const

sentry

_Ok

this

true

);

(

_Ok

) {

// state okay, use facet to extract

_TRY_IO_BEGIN

try

{

int_type

_Meta

_Myios

rdbuf

()->sgetc();

for

(; ;

_Meta

_Myios

rdbuf

()->snextc())

(

_Traits

::eq_int_type(

_Traits

::eof(),

_Meta

)) {

// end of file, quit

_State

ios_base

eofbit

;

break

; }

else

{

// got a character, insert it into stream buffer

_TRY_BEGIN

try

{

_Elem

_Ch

_Traits

::to_char_type(

_Meta

);

(

_Ch

_Delim

_Traits

::eq_int_type(

_Traits

::eof(),

_Strbuf

sputc

(

_Ch

)))

break

;

_CATCH_ALL

}

catch

(...) {

break

;

_CATCH_END

}

_Chcount

; }

_CATCH_IO_END

}

catch

(...) {

_Myios

setstate

(

ios_base

badbit

true

); }

}

(

_Chcount

)

_State

ios_base

failbit

;

_Myios

setstate

(

_State

);

return

this

); }

basic_istream& __CLR_OR_THIS_CALL getline(_Elem *_Str, streamsize _Count)

basic_istream

getline

(

_Elem

_Str

streamsize

_Count

)

{

// get up to _Count characters into NTCS, discard newline

return

(

getline

(

_Str

_Count

_Myios

widen

(

'\n'

))); }

basic_istream& __CLR_OR_THIS_CALL getline(_Elem *_Str,

basic_istream

getline

(

_Elem

_Str

streamsize

_Count

_Elem

_Delim

) {

// get up to _Count characters into NTCS, discard _Delim

ios_base

iostate

_State

ios_base

goodbit

;

_Chcount

;

const

sentry

_Ok

this

true

);

(

_Ok

_Count

) {

// state okay, use facet to extract

int_type

_Metadelim

_Traits

::to_int_type(

_Delim

);

_TRY_IO_BEGIN

try

{

int_type

_Meta

_Myios

rdbuf

()->sgetc();

for

(; ;

_Meta

_Myios

rdbuf

()->snextc())

(

_Traits

::eq_int_type(

_Traits

::eof(),

_Meta

)) {

// end of file, quit

_State

ios_base

eofbit

;

break

; }

else

(

_Meta

_Metadelim

) {

// got a delimiter, discard it and quit

_Chcount

;

_Myios

rdbuf

()->sbumpc();

break

; }

else

(--

_Count

) {

// buffer full, quit

_State

ios_base

failbit

;

break

; }

else

{

// got a character, add it to string

_Str

++ =

_Traits

::to_char_type(

_Meta

); ++

_Chcount

; }

_CATCH_IO_END

}

catch

(...) {

_Myios

setstate

(

ios_base

badbit

true

); }

} *

_Str

_Elem

();

// add terminating null character

_Myios

setstate

(

_Chcount

_State

ios_base

failbit

_State

);

return

this

); }

basic_istream& __CLR_OR_THIS_CALL ignore(streamsize _Count = 1,

basic_istream

ignore

(

streamsize

_Count

int_type

_Metadelim

_Traits

::eof()) {

// ignore up to _Count characters, discarding delimiter

ios_base

iostate

_State

ios_base

goodbit

;

_Chcount

;

const

sentry

_Ok

this

true

);

(

_Ok

_Count

) {

// state okay, use facet to extract

_TRY_IO_BEGIN

try

{

for

(;;) {

// get a metacharacter if more room in buffer

int_type

_Meta

;

(

_Count

(

numeric_limits

streamsize

>::

max

)() && --

_Count

)

break

;

// buffer full, quit

else

(

_Traits

::eq_int_type(

_Traits

::eof(),

_Meta

_Myios

rdbuf

()->sbumpc())) {

// end of file, quit

_State

ios_base

eofbit

;

break

; }

else

{

// got a character, count it

_Chcount

;

(

_Meta

_Metadelim

)

break

;

// got a delimiter, quit

} }

_CATCH_IO_END

}

catch

(...) {

_Myios

setstate

(

ios_base

badbit

true

); }

}

_Myios

setstate

(

_State

);

return

this

); }

basic_istream& __CLR_OR_THIS_CALL read(_Elem *_Str, streamsize _Count)

basic_istream

read

(

_Elem

_Str

streamsize

_Count

)

{

// read up to _Count characters into buffer

ios_base

iostate

_State

ios_base

goodbit

;

_Chcount

;

const

sentry

_Ok

this

true

);

(

_Ok

_Count

) {

// state okay, use facet to extract

_TRY_IO_BEGIN

try

{

const

streamsize

_Num

_Myios

rdbuf

()->sgetn(

_Str

_Count

);

_Chcount

_Num

;

(

_Num

_Count

)

_State

ios_base

eofbit

ios_base

failbit

;

// short read

_CATCH_IO_END

}

catch

(...) {

_Myios

setstate

(

ios_base

badbit

true

); }

}

_Myios

setstate

(

_State

);

return

this

); }

streamsize __CLR_OR_THIS_CALL readsome(_Elem *_Str,

streamsize

readsome

(

_Elem

_Str

streamsize

_Count

) {

// read up to _Count characters into buffer, without blocking

ios_base

iostate

_State

ios_base

goodbit

;

_Chcount

;

const

sentry

_Ok

this

true

);

streamsize

_Num

;

_Ok

)

_State

ios_base

failbit

;

// no buffer, fail

else

((

_Num

_Myios

rdbuf

()->in_avail()) <

)

_State

ios_base

eofbit

;

// no characters available

else

(

_Count

_Num

) {

// read available

read

(

_Str

_Num

_Count

_Num

_Count

); }

_Myios

setstate

(

_State

);

return

(

gcount

()); }

int_type __CLR_OR_THIS_CALL peek()

int_type

peek

()

{

// return next character, unconsumed

ios_base

iostate

_State

ios_base

goodbit

;

_Chcount

;

int_type

_Meta

;

const

sentry

_Ok

this

true

);

_Ok

)

_Meta

_Traits

::eof();

// state not okay, return EOF

else

{

// state okay, read a character

_TRY_IO_BEGIN

try

{

(

_Traits

::eq_int_type(

_Traits

::eof(),

_Meta

_Myios

rdbuf

()->sgetc()))

_State

ios_base

eofbit

;

_CATCH_IO_END

}

catch

(...) {

_Myios

setstate

(

ios_base

badbit

true

); }

}

_Myios

setstate

(

_State

);

return

(

_Meta

); }

basic_istream& __CLR_OR_THIS_CALL putback(_Elem _Ch)

basic_istream

putback

(

_Elem

_Ch

)

{

// put back a character

_Chcount

;

ios_base

iostate

_State

ios_base

goodbit

;

ios_base

iostate

_Oldstate

_Myios

rdstate

();

_Myios

clear

(

_Oldstate

& ~

ios_base

eofbit

);

const

sentry

_Ok

this

true

);

(

_Ok

) {

// state okay, put character back

_TRY_IO_BEGIN

try

{

(

_Traits

::eq_int_type(

_Traits

::eof(),

_Myios

rdbuf

()->sputbackc(

_Ch

)))

_State

ios_base

badbit

_Oldstate

;

_CATCH_IO_END

}

catch

(...) {

_Myios

setstate

(

ios_base

badbit

true

); }

}

_Myios

setstate

(

_State

);

return

this

); }

basic_istream& __CLR_OR_THIS_CALL unget()

basic_istream

unget

()

{

// put back last read character

_Chcount

;

ios_base

iostate

_State

ios_base

goodbit

;

ios_base

iostate

_Oldstate

_Myios

rdstate

();

_Myios

clear

(

_Oldstate

& ~

ios_base

eofbit

);

const

sentry

_Ok

this

true

);

(

_Ok

) {

// state okay, put character back

_TRY_IO_BEGIN

try

{

(

_Traits

::eq_int_type(

_Traits

::eof(),

_Myios

rdbuf

()->sungetc()))

_State

ios_base

badbit

_Oldstate

;

_CATCH_IO_END

}

catch

(...) {

_Myios

setstate

(

ios_base

badbit

true

); }

}

_Myios

setstate

(

_State

);

return

this

); }

_NODISCARD streamsize __CLR_OR_THIS_CALL gcount() const

streamsize

gcount

()

const

{

// get count from last extraction

return

(

_Chcount

); }

int __CLR_OR_THIS_CALL sync()

int

sync

()

{

// synchronize with input source

const

sentry

_Ok

this

true

);

(

_Myios

rdbuf

() ==

nullptr

)

return

);

else

(

_Myios

rdbuf

()->pubsync() == -

) {

// sync failed

_Myios

setstate

(

ios_base

badbit

);

return

); }

else

return

(

); }

basic_istream& __CLR_OR_THIS_CALL seekg(pos_type _Pos)

basic_istream

seekg

(

pos_type

_Pos

)

{

// set input stream position to _Pos

ios_base

iostate

_State

ios_base

goodbit

;

ios_base

iostate

_Oldstate

_Myios

rdstate

();

_Myios

clear

(

_Oldstate

& ~

ios_base

eofbit

);

const

sentry

_Ok

this

true

);

this

fail

() && (

off_type

)

_Myios

rdbuf

()->pubseekpos(

_Pos

ios_base

) == -

)

_Myios

setstate

(

_State

ios_base

failbit

);

return

this

); }

basic_istream& __CLR_OR_THIS_CALL seekg(off_type _Off, ios_base::seekdir _Way)

basic_istream

seekg

(

off_type

_Off

ios_base

seekdir

_Way

)

{

// change input stream position by _Off, according to _Way

ios_base

iostate

_State

ios_base

goodbit

;

ios_base

iostate

_Oldstate

_Myios

rdstate

();

_Myios

clear

(

_Oldstate

& ~

ios_base

eofbit

);

const

sentry

_Ok

this

true

);

this

fail

() && (

off_type

)

_Myios

rdbuf

()->pubseekoff(

_Off

_Way

ios_base

) == -

)

_Myios

setstate

(

_State

ios_base

failbit

);

return

this

); }

pos_type __CLR_OR_THIS_CALL tellg()

pos_type

tellg

()

{

// return input stream position

const

sentry

_Ok

this

true

);

this

fail

())

return

(

_Myios

rdbuf

()->pubseekoff(

ios_base

cur

ios_base

));

else

return

(

pos_type

)); }

private

streamsize

_Chcount

;

// the character count

};

#pragma vtordisp(pop) // compiler bug workaround

#pragma vtordisp(pop)

#ifndef _NATIVE_WCHAR_T_DEFINED

template<class _Elem,

class _Traits> inline

basic_istream<_Elem, _Traits>& operator>>(

basic_istream<_Elem, _Traits>& _Istr, _Elem& _Ch);

/* NOTE:

If you are not using native wchar_t, the following explicit

specialization will mask the member function (above) that treats

an unsigned short as an integer.

To read or write unsigned shorts as integers with wchar_t streams,

make wchar_t a native type with the command line option /Zc:wchar_t.

template<> inline

basic_istream<unsigned short, char_traits<unsigned short> >&

__CLR_OR_THIS_CALL basic_istream<unsigned short,

char_traits<unsigned short> >::operator>>(unsigned short& _Ch)

{ // extract a character

return (_STD operator>>(*this, _Ch));

}

#endif /* _NATIVE_WCHAR_T_DEFINED */

#if defined(_DLL_CPPLIB)

#if !defined(_CRTBLD) || defined(__FORCE_INSTANCE)

template class _CRTIMP2_PURE_IMPORT basic_istream<char, char_traits<char> >;

template

class

__declspec

(dllimport)

basic_istream

char

char_traits

char

> >;

template class _CRTIMP2_PURE_IMPORT basic_istream<wchar_t, char_traits<wchar_t> >; #endif /* !defined(_CRTBLD) || defined(__FORCE_INSTANCE) */

template

class

__declspec

(dllimport)

basic_istream

wchar_t

char_traits

wchar_t

> >;

#ifdef __FORCE_INSTANCE

template class _CRTIMP2_PURE_IMPORT basic_istream<unsigned short,

char_traits<unsigned short> >;

#endif /* __FORCE_INSTANCE */ #endif /* defined(_DLL_CPPLIB) */

// CLASS TEMPLATE basic_iostream

template

class

_Elem

class

_Traits

class

basic_iostream

public

basic_istream

_Elem

_Traits

public

basic_ostream

_Elem

_Traits

> {

// control insertions and extractions from a stream buffer

public

typedef

basic_istream

_Elem

_Traits

_Myis

;

typedef

basic_ostream

_Elem

_Traits

_Myos

;

typedef

basic_ios

_Elem

_Traits

_Myios

;

typedef

_Elem

char_type

;

typedef

_Traits

traits_type

;

typedef

typename

_Traits

::int_type

int_type

;

typedef

typename

_Traits

::pos_type

pos_type

;

typedef

typename

_Traits

::off_type

off_type

;

explicit __CLR_OR_THIS_CALL basic_iostream(basic_streambuf<_Elem, _Traits> *_Strbuf)

explicit

basic_iostream

(

basic_streambuf

_Elem

_Traits

> *

_Strbuf

)

_Myis

(

_Strbuf

false

_Myos

(

_Noinit

false

) {

// construct from stream buffer pointer

}

protected

__CLR_OR_THIS_CALL basic_iostream(basic_iostream&& _Right)

basic_iostream

(

basic_iostream

_Right

)

_Myis

(

_Right

rdbuf

(),

false

_Myos

(

_Noinit

false

) {

// construct by moving _Right

_Myios

init

();

_Myios::move(_STD move(_Right));

_Myios

move

(::

std

move

(

_Right

));

}

basic_iostream& __CLR_OR_THIS_CALL operator=(basic_iostream&& _Right)

basic_iostream

operator

(

basic_iostream

_Right

)

{

// move from _Right

this

swap

(

_Right

);

return

this

); }

void __CLR_OR_THIS_CALL swap(basic_iostream& _Right)

void

swap

(

basic_iostream

_Right

)

{

// swap with _Right

if (this != _STD addressof(_Right))

(

this

std

addressof

(

_Right

))

_Myios

swap

(

_Right

); }

public

__CLR_OR_THIS_CALL basic_iostream(const basic_iostream&) = delete;

basic_iostream

(

const

basic_iostream

&) =

delete

;

basic_iostream& __CLR_OR_THIS_CALL operator=(const basic_iostream&) = delete;

basic_iostream

operator

(

const

basic_iostream

&) =

delete

;

virtual __CLR_OR_THIS_CALL ~basic_iostream() noexcept

virtual

basic_iostream

()

noexcept

{

// destroy the object

} };

#if defined(_DLL_CPPLIB)

#if !defined(_CRTBLD) || defined(__FORCE_INSTANCE)

template class _CRTIMP2_PURE_IMPORT basic_iostream<char, char_traits<char> >;

template

class

__declspec

(dllimport)

basic_iostream

char

char_traits

char

> >;

template class _CRTIMP2_PURE_IMPORT basic_iostream<wchar_t, char_traits<wchar_t> >; #endif /* !defined(_CRTBLD) || defined(__FORCE_INSTANCE) */

template

class

__declspec

(dllimport)

basic_iostream

wchar_t

char_traits

wchar_t

> >;

#ifdef __FORCE_INSTANCE

template class _CRTIMP2_PURE_IMPORT basic_iostream<unsigned short,

char_traits<unsigned short> >;

#endif /* __FORCE_INSTANCE */ #endif /* defined(_DLL_CPPLIB) */

// EXTRACTORS

template

class

_Elem

class

_Traits

inline

basic_istream

_Elem

_Traits

operator

(

basic_istream

_Elem

_Traits

_Istr

_Elem

_Str

) {

// extract NTBS

typedef

basic_istream

_Elem

_Traits

_Myis

;

typedef

ctype

_Elem

_Ctype

;

ios_base

iostate

_State

ios_base

goodbit

;

_Elem

_Str0

_Str

;

const

typename

_Myis

sentry

_Ok

(

_Istr

);

(

_Ok

) {

// state okay, extract characters

const _Ctype& _Ctype_fac = _STD use_facet<_Ctype>(_Istr.getloc());

const

_Ctype

_Ctype_fac

= ::

std

use_facet

_Ctype

_Istr

getloc

());

_TRY_IO_BEGIN

try

{

streamsize

_Count

_Istr

width

() ?

_Istr

width

() : (

numeric_limits

streamsize

>::

max

)();

typename

_Myis

int_type

_Meta

_Istr

rdbuf

()->sgetc();

_Elem

_Ch

;

for

(;

_Count

;

_Meta

_Istr

rdbuf

()->snextc())

(

_Traits

::eq_int_type(

_Traits

::eof(),

_Meta

)) {

// end of file, quit

_State

ios_base

eofbit

;

break

; }

else

(

_Ctype_fac

(

_Ctype

space

_Ch

_Traits

::to_char_type(

_Meta

)) ||

_Ch

_Elem

())

break

;

// whitespace or nul, quit

else

_Str

++ =

_Traits

::to_char_type(

_Meta

);

// add it to string

_CATCH_IO_(_Istr)

}

catch

(...) { (

_Istr

setstate

(

ios_base

badbit

true

); }

} *

_Str

_Elem

();

// add terminating null character

_Istr

width

(

);

_Istr

setstate

(

_Str

_Str0

_State

ios_base

failbit

_State

);

return

(

_Istr

); }

template

class

_Elem

class

_Traits

inline

basic_istream

_Elem

_Traits

operator

(

basic_istream

_Elem

_Traits

_Istr

_Elem

_Ch

) {

// extract a character

typedef

basic_istream

_Elem

_Traits

_Myis

;

typename

_Myis

int_type

_Meta

;

ios_base

iostate

_State

ios_base

goodbit

;

const

typename

_Myis

sentry

_Ok

(

_Istr

);

(

_Ok

) {

// state okay, extract characters

_TRY_IO_BEGIN

try

{

_Meta

_Istr

rdbuf

()->sbumpc();

(

_Traits

::eq_int_type(

_Traits

::eof(),

_Meta

))

_State

ios_base

eofbit

ios_base

failbit

;

// end of file

else

_Ch

_Traits

::to_char_type(

_Meta

);

// got a character

_CATCH_IO_(_Istr)

}

catch

(...) { (

_Istr

setstate

(

ios_base

badbit

true

); }

}

_Istr

setstate

(

_State

);

return

(

_Istr

); }

template

class

_Traits

inline

basic_istream

char

_Traits

operator

(

basic_istream

char

_Traits

_Istr

signed

char

_Str

) {

// extract a signed char NTBS

return

(

_Istr

>> (

char

_Str

); }

template

class

_Traits

inline

basic_istream

char

_Traits

operator

(

basic_istream

char

_Traits

_Istr

signed

char

_Ch

) {

// extract a signed char

return

(

_Istr

>> (

char

_Ch

); }

template

class

_Traits

inline

basic_istream

char

_Traits

operator

(

basic_istream

char

_Traits

_Istr

unsigned

char

_Str

) {

// extract an unsigned char NTBS

return

(

_Istr

>> (

char

_Str

); }

template

class

_Traits

inline

basic_istream

char

_Traits

operator

(

basic_istream

char

_Traits

_Istr

unsigned

char

_Ch

) {

// extract an unsigned char

return

(

_Istr

>> (

char

_Ch

); }

template

class

_Istr

class

_Ty

class

void

struct

_Can_stream_in

false_type

{ };

template

class

_Istr

class

_Ty

struct _Can_stream_in<_Istr, _Ty, void_t<decltype(_STD declval<_Istr&>() >> _STD declval<_Ty>())>>

struct

_Can_stream_in

_Istr

_Ty

void_t

decltype

(::

std

declval

_Istr

&>() >> ::

std

declval

_Ty

>())>>

true_type

{ };

template

class

_Istr

class

_Ty

enable_if_t

conjunction_v

// avoid infinite recursion

negation

is_lvalue_reference

_Istr

>>,

is_base_of

ios_base

_Istr

_Can_stream_in

_Istr

_Ty

>>,

int

> =

inline

_Istr

operator

(

_Istr

_Is

_Ty

_Val

) {

// extract from rvalue stream

_Is >> _STD forward<_Ty>(_Val);

_Is

>> ::

std

forward

_Ty

_Val

);

return (_STD move(_Is));

return

(::

std

move

(

_Is

));

}

// MANIPULATORS

template

class

_Elem

class

_Traits

inline

basic_istream

_Elem

_Traits

__CLRCALL_OR_CDECL ws(basic_istream<_Elem, _Traits>& _Istr)

__cdecl

(

basic_istream

_Elem

_Traits

_Istr

)

{

// consume whitespace

const

typename

basic_istream

_Elem

_Traits

>::

sentry

_Ok

(

_Istr

true

);

(

_Ok

) {

// state okay, extract characters

ios_base

iostate

_State

ios_base

goodbit

;

const auto& _Ctype_fac = _STD use_facet<ctype<_Elem>>(_Istr.getloc());

const

auto

_Ctype_fac

= ::

std

use_facet

ctype

_Elem

>>(

_Istr

getloc

());

_TRY_IO_BEGIN

try

{

for

(

typename

_Traits

::int_type

_Meta

_Istr

rdbuf

()->sgetc(); ;

_Meta

_Istr

rdbuf

()->snextc()) {

(

_Traits

::eq_int_type(

_Traits

::eof(),

_Meta

)) {

// end of file, quit

_State

ios_base

eofbit

;

break

; }

else

_Ctype_fac

(

ctype

_Elem

>::

space

_Traits

::to_char_type(

_Meta

))) {

break

;

// not whitespace, quit

} }

_CATCH_IO_(_Istr)

}

catch

(...) { (

_Istr

setstate

(

ios_base

badbit

true

); }

_Istr

setstate

(

_State

); }

return

(

_Istr

); }

_STD_END

}

#pragma pop_macro("new")

_STL_RESTORE_CLANG_WARNINGS

#pragma warning(pop)

#pragma pack(pop) #endif /* RC_INVOKED */ #endif /* _ISTREAM_ */

#pragma pack(pop)