ostream

// ostream standard header

#pragma once

#ifndef _OSTREAM_

#define _OSTREAM_

#ifndef RC_INVOKED #include <ios>

#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

{

// I/O EXCEPTION MACROS

#if _HAS_EXCEPTIONS

#define _TRY_IO_BEGIN _TRY_BEGIN /* begin try block */

#define _CATCH_IO_END _CATCH_ALL /* catch block for _Myios */ \

_Myios::setstate(ios_base::badbit, true); /* set badbit and rethrow */ \

_CATCH_END

#define _CATCH_IO_(x) _CATCH_ALL /* catch block for basic_ios x */ \

(x).setstate(ios_base::badbit, true); /* set badbit and rethrow */ \

_CATCH_END

#else /* _HAS_EXCEPTIONS */

#define _TRY_IO_BEGIN { /* begin try block */

#define _CATCH_IO_END } /* catch block for _Myios */

#define _CATCH_IO_(x) } /* catch block for basic_ios x */ #endif /* _HAS_EXCEPTIONS */

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

#pragma vtordisp(push,

)

// CLASS TEMPLATE basic_ostream

template

class

_Elem

class

_Traits

class

basic_ostream

virtual

public

basic_ios

_Elem

_Traits

> {

// control insertions into a stream buffer

public

typedef

basic_ios

_Elem

_Traits

_Myios

;

typedef

basic_streambuf

_Elem

_Traits

_Mysb

;

typedef

ostreambuf_iterator

_Elem

_Traits

_Iter

;

typedef

num_put

_Elem

_Iter

_Nput

;

explicit __CLR_OR_THIS_CALL basic_ostream(

explicit

basic_ostream

(

basic_streambuf

_Elem

_Traits

> *

_Strbuf

bool

_Isstd

false

) {

// construct from a stream buffer pointer

_Myios

init

(

_Strbuf

_Isstd

); }

__CLR_OR_THIS_CALL basic_ostream(_Uninitialized, bool _Addit = true)

basic_ostream

(

_Uninitialized

bool

_Addit

true

)

{

// construct uninitialized

(

_Addit

)

this

_Addstd

(

this

);

// suppress for basic_iostream

}

protected

__CLR_OR_THIS_CALL basic_ostream(basic_ostream&& _Right)

basic_ostream

(

basic_ostream

_Right

)

{

// construct by moving _Right

_Myios

init

();

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

_Myios

move

(::

std

move

(

_Right

));

}

basic_ostream& __CLR_OR_THIS_CALL operator=(basic_ostream&& _Right)

basic_ostream

operator

(

basic_ostream

_Right

)

{

// move from _Right

this

swap

(

_Right

);

return

this

); }

void __CLR_OR_THIS_CALL swap(basic_ostream& _Right)

void

swap

(

basic_ostream

_Right

)

{

// swap with _Right

if (this != _STD addressof(_Right))

(

this

std

addressof

(

_Right

))

_Myios

swap

(

_Right

); }

public

__CLR_OR_THIS_CALL basic_ostream(const basic_ostream&) = delete;

basic_ostream

(

const

basic_ostream

&) =

delete

;

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

basic_ostream

operator

(

const

basic_ostream

&) =

delete

;

virtual __CLR_OR_THIS_CALL ~basic_ostream() noexcept

virtual

basic_ostream

()

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

_Sentry_base

{

// stores thread lock and reference to output stream

public

__CLR_OR_THIS_CALL _Sentry_base(basic_ostream& _Ostr)

_Sentry_base

(

basic_ostream

_Ostr

)

: _Myostr(

_Ostr

) {

// lock the stream buffer, if there

(

_Myostr

rdbuf

() !=

nullptr

)

_Myostr

rdbuf

()->_Lock(); }

__CLR_OR_THIS_CALL ~_Sentry_base() noexcept

_Sentry_base

()

noexcept

{

// destroy after unlocking

(

_Myostr

rdbuf

() !=

nullptr

)

_Myostr

rdbuf

()->_Unlock(); }

basic_ostream

_Myostr

;

// the output stream, for _Unlock call at destruction

_Sentry_base

operator

(

const

_Sentry_base

&) =

delete

; };

class

sentry

public

_Sentry_base

{

// stores thread lock and state of stream

public

explicit __CLR_OR_THIS_CALL sentry(basic_ostream& _Ostr)

explicit

sentry

(

basic_ostream

_Ostr

)

_Sentry_base

(

_Ostr

) {

// construct locking and testing stream

(

_Ostr

good

() &&

_Ostr

tie

() !=

nullptr

_Ostr

tie

() != &

_Ostr

)

_Ostr

tie

()->flush();

_Ok

_Ostr

good

();

// store test only after flushing tie

}

#ifdef __clang__

#pragma clang diagnostic push

#pragma clang diagnostic ignored "-Wdeprecated-declarations"

#else /* ^^^ clang ^^^ / vvv not clang vvv */

#pragma warning(push)

#pragma warning(disable: 4996) // was declared deprecated #endif /* __clang__ */

#pragma warning(disable:

4996

)

__CLR_OR_THIS_CALL ~sentry() noexcept

sentry

()

noexcept

{

// destroy the object

#if _HAS_EXCEPTIONS

if (!_STD uncaught_exception()) // TRANSITION, OS#15518458

(!::

std

uncaught_exception

())

// TRANSITION, OS#15518458

{

this

_Myostr

_Osfx

(); }

#else /* _HAS_EXCEPTIONS */

this->_Myostr._Osfx(); #endif /* _HAS_EXCEPTIONS */

}

#ifdef __clang__

#pragma clang diagnostic pop

#else /* ^^^ clang ^^^ / vvv not clang vvv */

#pragma warning(pop) #endif /* __clang__ */

#pragma warning(pop)

explicit __CLR_OR_THIS_CALL operator bool() const

explicit

operator

bool

()

const

{

// test if stream state okay

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 stream state okay at construction

};

bool __CLR_OR_THIS_CALL opfx()

bool

opfx

()

{

// test stream state and flush tie stream as needed (retained)

(

this

good

() &&

_Myios

tie

() !=

nullptr

_Myios

tie

() !=

this

)

_Myios

tie

()->flush();

return

(

this

good

()); }

void __CLR_OR_THIS_CALL osfx()

void

osfx

()

{

// perform any wrapup (retained)

_Osfx

(); }

void __CLR_OR_THIS_CALL _Osfx()

void

_Osfx

()

{

// perform any wrapup

_TRY_BEGIN

try

{

(

this

good

() &&

this

flags

() &

ios_base

unitbuf

)

(

_Myios

rdbuf

()->pubsync() == -

)

// flush stream as needed

_Myios

setstate

(

ios_base

badbit

);

_CATCH_ALL

}

catch

(...) {

_CATCH_END

}

#ifdef _M_CEE_PURE

basic_ostream& __CLR_OR_THIS_CALL operator<<(basic_ostream& (__clrcall *_Pfn)(basic_ostream&))

{ // call basic_ostream manipulator

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

}

basic_ostream& __CLR_OR_THIS_CALL operator<<(_Myios& (__clrcall *_Pfn)(_Myios&))

{ // call basic_ios manipulator

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

return (*this);

}

basic_ostream& __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_ostream& __CLR_OR_THIS_CALL operator<<(basic_ostream& (__cdecl *_Pfn)(basic_ostream&))

basic_ostream

operator

(

basic_ostream

& (

__cdecl

_Pfn

)(

basic_ostream

&))

{

// call basic_ostream manipulator

return

((*

_Pfn

)(*

this

)); }

basic_ostream& __CLR_OR_THIS_CALL operator<<(_Myios& (__cdecl *_Pfn)(_Myios&))

basic_ostream

operator

(

_Myios

& (

__cdecl

_Pfn

)(

_Myios

&))

{

// call basic_ios manipulator

_Pfn

)(*(

_Myios

this

);

return

this

); }

basic_ostream& __CLR_OR_THIS_CALL operator<<(ios_base& (__cdecl *_Pfn)(ios_base&))

basic_ostream

operator

(

ios_base

& (

__cdecl

_Pfn

)(

ios_base

&))

{

// call ios_base manipulator

_Pfn

)(*(

ios_base

this

);

return

this

); }

basic_ostream& __CLR_OR_THIS_CALL operator<<(bool _Val)

basic_ostream

operator

(

bool

_Val

)

{

// insert a boolean

ios_base

iostate

_State

ios_base

goodbit

;

const

sentry

_Ok

this

);

(

_Ok

) {

// state okay, use facet to insert

const _Nput& _Nput_fac = _STD use_facet<_Nput>(this->getloc());

const

_Nput

_Nput_fac

= ::

std

use_facet

_Nput

this

getloc

());

_TRY_IO_BEGIN

try

{

(

_Nput_fac

put

(

_Iter

(

_Myios

rdbuf

()), *

this

_Myios

fill

(),

_Val

).failed())

_State

ios_base

badbit

;

_CATCH_IO_END

}

catch

(...) {

_Myios

setstate

(

ios_base

badbit

true

); }

}

_Myios

setstate

(

_State

);

return

this

); }

basic_ostream& __CLR_OR_THIS_CALL operator<<(short _Val)

basic_ostream

operator

(

short

_Val

)

{

// insert a short

ios_base

iostate

_State

ios_base

goodbit

;

const

sentry

_Ok

this

);

(

_Ok

) {

// state okay, use facet to insert

const _Nput& _Nput_fac = _STD use_facet<_Nput>(this->getloc());

const

_Nput

_Nput_fac

= ::

std

use_facet

_Nput

this

getloc

());

ios_base

fmtflags

_Bfl

this

flags

() &

ios_base

basefield

;

long

_Tmp

= (

_Bfl

ios_base

oct

_Bfl

ios_base

hex

) ? (

long

)(

unsigned

short

)

_Val

: (

long

)

_Val

;

_TRY_IO_BEGIN

try

{

(

_Nput_fac

put

(

_Iter

(

_Myios

rdbuf

()), *

this

_Myios

fill

(),

_Tmp

).failed())

_State

ios_base

badbit

;

_CATCH_IO_END

}

catch

(...) {

_Myios

setstate

(

ios_base

badbit

true

); }

}

_Myios

setstate

(

_State

);

return

this

); }

/* NOTE: If you are not using native wchar_t, the unsigned short inserter 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_ostream& __CLR_OR_THIS_CALL operator<<(unsigned short _Val)

basic_ostream

operator

(

unsigned

short

_Val

)

{

// insert an unsigned short

ios_base

iostate

_State

ios_base

goodbit

;

const

sentry

_Ok

this

);

(

_Ok

) {

// state okay, use facet to insert

const _Nput& _Nput_fac = _STD use_facet<_Nput>(this->getloc());

const

_Nput

_Nput_fac

= ::

std

use_facet

_Nput

this

getloc

());

_TRY_IO_BEGIN

try

{

(

_Nput_fac

put

(

_Iter

(

_Myios

rdbuf

()), *

this

_Myios

fill

(), (

unsigned

long

)

_Val

).failed())

_State

ios_base

badbit

;

_CATCH_IO_END

}

catch

(...) {

_Myios

setstate

(

ios_base

badbit

true

); }

}

_Myios

setstate

(

_State

);

return

this

); }

basic_ostream& __CLR_OR_THIS_CALL operator<<(int _Val)

basic_ostream

operator

(

int

_Val

)

{

// insert an int

ios_base

iostate

_State

ios_base

goodbit

;

const

sentry

_Ok

this

);

(

_Ok

) {

// state okay, use facet to insert

const _Nput& _Nput_fac = _STD use_facet<_Nput>(this->getloc());

const

_Nput

_Nput_fac

= ::

std

use_facet

_Nput

this

getloc

());

ios_base

fmtflags

_Bfl

this

flags

() &

ios_base

basefield

;

long

_Tmp

= (

_Bfl

ios_base

oct

_Bfl

ios_base

hex

) ? (

long

)(

unsigned

int

)

_Val

: (

long

)

_Val

;

_TRY_IO_BEGIN

try

{

(

_Nput_fac

put

(

_Iter

(

_Myios

rdbuf

()), *

this

_Myios

fill

(),

_Tmp

).failed())

_State

ios_base

badbit

;

_CATCH_IO_END

}

catch

(...) {

_Myios

setstate

(

ios_base

badbit

true

); }

}

_Myios

setstate

(

_State

);

return

this

); }

basic_ostream& __CLR_OR_THIS_CALL operator<<(unsigned int _Val)

basic_ostream

operator

(

unsigned

int

_Val

)

{

// insert an unsigned int

ios_base

iostate

_State

ios_base

goodbit

;

const

sentry

_Ok

this

);

(

_Ok

) {

// state okay, use facet to insert

const _Nput& _Nput_fac = _STD use_facet<_Nput>(this->getloc());

const

_Nput

_Nput_fac

= ::

std

use_facet

_Nput

this

getloc

());

_TRY_IO_BEGIN

try

{

(

_Nput_fac

put

(

_Iter

(

_Myios

rdbuf

()), *

this

_Myios

fill

(), (

unsigned

long

)

_Val

).failed())

_State

ios_base

badbit

;

_CATCH_IO_END

}

catch

(...) {

_Myios

setstate

(

ios_base

badbit

true

); }

}

_Myios

setstate

(

_State

);

return

this

); }

basic_ostream& __CLR_OR_THIS_CALL operator<<(long _Val)

basic_ostream

operator

(

long

_Val

)

{

// insert a long

ios_base

iostate

_State

ios_base

goodbit

;

const

sentry

_Ok

this

);

(

_Ok

) {

// state okay, use facet to insert

const _Nput& _Nput_fac = _STD use_facet<_Nput>(this->getloc());

const

_Nput

_Nput_fac

= ::

std

use_facet

_Nput

this

getloc

());

_TRY_IO_BEGIN

try

{

(

_Nput_fac

put

(

_Iter

(

_Myios

rdbuf

()), *

this

_Myios

fill

(),

_Val

).failed())

_State

ios_base

badbit

;

_CATCH_IO_END

}

catch

(...) {

_Myios

setstate

(

ios_base

badbit

true

); }

}

_Myios

setstate

(

_State

);

return

this

); }

basic_ostream& __CLR_OR_THIS_CALL operator<<(unsigned long _Val)

basic_ostream

operator

(

unsigned

long

_Val

)

{

// insert an unsigned long

ios_base

iostate

_State

ios_base

goodbit

;

const

sentry

_Ok

this

);

(

_Ok

) {

// state okay, use facet to insert

const _Nput& _Nput_fac = _STD use_facet<_Nput>(this->getloc());

const

_Nput

_Nput_fac

= ::

std

use_facet

_Nput

this

getloc

());

_TRY_IO_BEGIN

try

{

(

_Nput_fac

put

(

_Iter

(

_Myios

rdbuf

()), *

this

_Myios

fill

(),

_Val

).failed())

_State

ios_base

badbit

;

_CATCH_IO_END

}

catch

(...) {

_Myios

setstate

(

ios_base

badbit

true

); }

}

_Myios

setstate

(

_State

);

return

this

); }

basic_ostream& __CLR_OR_THIS_CALL operator<<(long long _Val)

basic_ostream

operator

(

long

_Val

)

{

// insert a long long

ios_base

iostate

_State

ios_base

goodbit

;

const

sentry

_Ok

this

);

(

_Ok

) {

// state okay, use facet to insert

const _Nput& _Nput_fac = _STD use_facet<_Nput>(this->getloc());

const

_Nput

_Nput_fac

= ::

std

use_facet

_Nput

this

getloc

());

_TRY_IO_BEGIN

try

{

(

_Nput_fac

put

(

_Iter

(

_Myios

rdbuf

()), *

this

_Myios

fill

(),

_Val

).failed())

_State

ios_base

badbit

;

_CATCH_IO_END

}

catch

(...) {

_Myios

setstate

(

ios_base

badbit

true

); }

}

_Myios

setstate

(

_State

);

return

this

); }

basic_ostream& __CLR_OR_THIS_CALL operator<<(unsigned long long _Val)

basic_ostream

operator

(

unsigned

long

_Val

)

{

// insert an unsigned long long

ios_base

iostate

_State

ios_base

goodbit

;

const

sentry

_Ok

this

);

(

_Ok

) {

// state okay, use facet to insert

const _Nput& _Nput_fac = _STD use_facet<_Nput>(this->getloc());

const

_Nput

_Nput_fac

= ::

std

use_facet

_Nput

this

getloc

());

_TRY_IO_BEGIN

try

{

(

_Nput_fac

put

(

_Iter

(

_Myios

rdbuf

()), *

this

_Myios

fill

(),

_Val

).failed())

_State

ios_base

badbit

;

_CATCH_IO_END

}

catch

(...) {

_Myios

setstate

(

ios_base

badbit

true

); }

}

_Myios

setstate

(

_State

);

return

this

); }

basic_ostream& __CLR_OR_THIS_CALL operator<<(float _Val)

basic_ostream

operator

(

float

_Val

)

{

// insert a float

ios_base

iostate

_State

ios_base

goodbit

;

const

sentry

_Ok

this

);

(

_Ok

) {

// state okay, use facet to insert

const _Nput& _Nput_fac = _STD use_facet<_Nput>(this->getloc());

const

_Nput

_Nput_fac

= ::

std

use_facet

_Nput

this

getloc

());

_TRY_IO_BEGIN

try

{

(

_Nput_fac

put

(

_Iter

(

_Myios

rdbuf

()), *

this

_Myios

fill

(), (

double

)

_Val

).failed())

_State

ios_base

badbit

;

_CATCH_IO_END

}

catch

(...) {

_Myios

setstate

(

ios_base

badbit

true

); }

}

_Myios

setstate

(

_State

);

return

this

); }

basic_ostream& __CLR_OR_THIS_CALL operator<<(double _Val)

basic_ostream

operator

(

double

_Val

)

{

// insert a double

ios_base

iostate

_State

ios_base

goodbit

;

const

sentry

_Ok

this

);

(

_Ok

) {

// state okay, use facet to insert

const _Nput& _Nput_fac = _STD use_facet<_Nput>(this->getloc());

const

_Nput

_Nput_fac

= ::

std

use_facet

_Nput

this

getloc

());

_TRY_IO_BEGIN

try

{

(

_Nput_fac

put

(

_Iter

(

_Myios

rdbuf

()), *

this

_Myios

fill

(),

_Val

).failed())

_State

ios_base

badbit

;

_CATCH_IO_END

}

catch

(...) {

_Myios

setstate

(

ios_base

badbit

true

); }

}

_Myios

setstate

(

_State

);

return

this

); }

basic_ostream& __CLR_OR_THIS_CALL operator<<(long double _Val)

basic_ostream

operator

(

long

double

_Val

)

{

// insert a long double

ios_base

iostate

_State

ios_base

goodbit

;

const

sentry

_Ok

this

);

(

_Ok

) {

// state okay, use facet to insert

const _Nput& _Nput_fac = _STD use_facet<_Nput>(this->getloc());

const

_Nput

_Nput_fac

= ::

std

use_facet

_Nput

this

getloc

());

_TRY_IO_BEGIN

try

{

(

_Nput_fac

put

(

_Iter

(

_Myios

rdbuf

()), *

this

_Myios

fill

(),

_Val

).failed())

_State

ios_base

badbit

;

_CATCH_IO_END

}

catch

(...) {

_Myios

setstate

(

ios_base

badbit

true

); }

}

_Myios

setstate

(

_State

);

return

this

); }

basic_ostream& __CLR_OR_THIS_CALL operator<<(const void *_Val)

basic_ostream

operator

(

const

void

_Val

)

{

// insert a void pointer

ios_base

iostate

_State

ios_base

goodbit

;

const

sentry

_Ok

this

);

(

_Ok

) {

// state okay, use facet to insert

const _Nput& _Nput_fac = _STD use_facet<_Nput>(this->getloc());

const

_Nput

_Nput_fac

= ::

std

use_facet

_Nput

this

getloc

());

_TRY_IO_BEGIN

try

{

(

_Nput_fac

put

(

_Iter

(

_Myios

rdbuf

()), *

this

_Myios

fill

(),

_Val

).failed())

_State

ios_base

badbit

;

_CATCH_IO_END

}

catch

(...) {

_Myios

setstate

(

ios_base

badbit

true

); }

}

_Myios

setstate

(

_State

);

return

this

); }

#if _HAS_CXX17 // LWG 2221 "No formatted output operator for nullptr"

template<class = void> // TRANSITION, ABI

basic_ostream& operator<<(nullptr_t)

{ // insert a null pointer

return (*this << "nullptr");

} #endif // _HAS_CXX17

basic_ostream& __CLR_OR_THIS_CALL operator<<(_Mysb *_Strbuf)

basic_ostream

operator

(

_Mysb

_Strbuf

)

{

// insert until end-of-file from a stream buffer

ios_base

iostate

_State

ios_base

goodbit

;

bool

_Copied

false

;

const

sentry

_Ok

this

);

(

_Ok

_Strbuf

nullptr

)

for

(

int_type

_Meta

_Traits

::eof(); ;

_Copied

true

) {

// extract another character from stream buffer

_TRY_BEGIN

try

{

_Meta

_Traits

::eq_int_type(

_Traits

::eof(),

_Meta

) ?

_Strbuf

sgetc

() :

_Strbuf

snextc

();

_CATCH_ALL

}

catch

(...) {

_Myios

setstate

(

ios_base

failbit

);

_RERAISE;

throw

;

_CATCH_END

}

(

_Traits

::eq_int_type(

_Traits

::eof(),

_Meta

))

break

;

// end of file, quit

_TRY_IO_BEGIN

try

{

(

_Traits

::eq_int_type(

_Traits

::eof(),

_Myios

rdbuf

()->sputc(

_Traits

::to_char_type(

_Meta

)))) {

// insertion failed, quit

_State

ios_base

badbit

;

break

; }

_CATCH_IO_END

}

catch

(...) {

_Myios

setstate

(

ios_base

badbit

true

); }

}

this

width

(

);

_Myios

setstate

(

_Strbuf

nullptr

ios_base

badbit

: !

_Copied

_State

ios_base

failbit

_State

);

return

this

); }

basic_ostream& __CLR_OR_THIS_CALL put(_Elem _Ch)

basic_ostream

put

(

_Elem

_Ch

)

{

// insert a character

ios_base

iostate

_State

ios_base

goodbit

;

const

sentry

_Ok

this

);

_Ok

)

_State

ios_base

badbit

;

else

{

// state okay, insert character

_TRY_IO_BEGIN

try

{

(

_Traits

::eq_int_type(

_Traits

::eof(),

_Myios

rdbuf

()->sputc(

_Ch

)))

_State

ios_base

badbit

;

_CATCH_IO_END

}

catch

(...) {

_Myios

setstate

(

ios_base

badbit

true

); }

}

_Myios

setstate

(

_State

);

return

this

); }

basic_ostream& __CLR_OR_THIS_CALL write(const _Elem *_Str,

basic_ostream

write

(

const

_Elem

_Str

streamsize

_Count

) {

// insert _Count characters from array _Str

ios_base

iostate

_State

ios_base

goodbit

;

const

sentry

_Ok

this

);

_Ok

)

_State

ios_base

badbit

;

else

(

_Count

) {

// state okay, insert characters

_TRY_IO_BEGIN

try

{

(

_Myios

rdbuf

()->sputn(

_Str

_Count

) !=

_Count

)

_State

ios_base

badbit

;

_CATCH_IO_END

}

catch

(...) {

_Myios

setstate

(

ios_base

badbit

true

); }

}

_Myios

setstate

(

_State

);

return

this

); }

basic_ostream& __CLR_OR_THIS_CALL flush()

basic_ostream

flush

()

{

// flush output stream

(

_Myios

rdbuf

() !=

nullptr

) {

// buffer exists, flush it

const

sentry

_Ok

this

);

(

_Ok

_Myios

rdbuf

()->pubsync() == -

)

_Myios

setstate

(

ios_base

badbit

);

// sync failed

}

return

this

); }

basic_ostream& __CLR_OR_THIS_CALL seekp(pos_type _Pos)

basic_ostream

seekp

(

pos_type

_Pos

)

{

// set output stream position to _Pos

const

sentry

_Ok

this

);

this

fail

() && (

off_type

)

_Myios

rdbuf

()->pubseekpos(

_Pos

ios_base

out

) == -

)

_Myios

setstate

(

ios_base

failbit

);

return

this

); }

basic_ostream& __CLR_OR_THIS_CALL seekp(off_type _Off, ios_base::seekdir _Way)

basic_ostream

seekp

(

off_type

_Off

ios_base

seekdir

_Way

)

{

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

const

sentry

_Ok

this

);

this

fail

() && (

off_type

)

_Myios

rdbuf

()->pubseekoff(

_Off

_Way

ios_base

out

) == -

)

_Myios

setstate

(

ios_base

failbit

);

return

this

); }

pos_type __CLR_OR_THIS_CALL tellp()

pos_type

tellp

()

{

// return output stream position

const

sentry

_Ok

this

);

this

fail

())

return

(

_Myios

rdbuf

()->pubseekoff(

ios_base

cur

ios_base

out

));

else

return

(

pos_type

)); } };

#pragma vtordisp(pop) // compiler bug workaround

#pragma vtordisp(pop)

#ifndef _NATIVE_WCHAR_T_DEFINED

/* 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_ostream<unsigned short, char_traits<unsigned short> >&

__CLR_OR_THIS_CALL basic_ostream<unsigned short,

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

{ // extract a character

typedef char_traits<unsigned short> _Traits;

ios_base::iostate _State = ios_base::goodbit;

const sentry _Ok(*this);

if (_Ok)

{ // state okay, insert

streamsize _Pad = this->width() <= 1 ? 0 : this->width() - 1;

_TRY_IO_BEGIN

if ((this->flags() & ios_base::adjustfield) != ios_base::left)

for (; _State == ios_base::goodbit && 0 < _Pad;

--_Pad) // pad on left

if (_Traits::eq_int_type(_Traits::eof(),

this->rdbuf()->sputc(this->fill())))

_State |= ios_base::badbit;

if (_State == ios_base::goodbit

&& _Traits::eq_int_type(_Traits::eof(),

this->rdbuf()->sputc(_Ch)))

_State |= ios_base::badbit;

for (; _State == ios_base::goodbit && 0 < _Pad;

--_Pad) // pad on right

if (_Traits::eq_int_type(_Traits::eof(),

this->rdbuf()->sputc(this->fill())))

_State |= ios_base::badbit;

_CATCH_IO_END

}

this->width(0);

_Myios::setstate(_State);

return (*this);

}

#endif /* _NATIVE_WCHAR_T_DEFINED */

#if defined(_DLL_CPPLIB)

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

template class _CRTIMP2_PURE_IMPORT basic_ostream<char,

template

class

__declspec

(dllimport)

basic_ostream

char

char_traits

char

> >;

template class _CRTIMP2_PURE_IMPORT basic_ostream<wchar_t,

template

class

__declspec

(dllimport)

basic_ostream

wchar_t

char_traits

wchar_t

> >;

#endif /* !defined(_CRTBLD) || defined(__FORCE_INSTANCE) */

#ifdef __FORCE_INSTANCE

template class _CRTIMP2_PURE_IMPORT basic_ostream<unsigned short,

char_traits<unsigned short> >;

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

// INSERTERS

template

class

_Elem

class

_Traits

inline

basic_ostream

_Elem

_Traits

operator

(

basic_ostream

_Elem

_Traits

_Ostr

const

char

_Val

) {

// insert NTBS

ios_base

iostate

_State

ios_base

goodbit

;

streamsize _Count = (streamsize)_CSTD strlen(_Val); // may overflow

streamsize

_Count

= (

streamsize

)::

strlen

(

_Val

);

// may overflow

streamsize

_Pad

_Ostr

width

() <=

_Ostr

width

() <=

_Count

_Ostr

width

() -

_Count

;

const

typename

basic_ostream

_Elem

_Traits

>::

sentry

_Ok

(

_Ostr

);

_Ok

)

_State

ios_base

badbit

;

else

{

// state okay, insert characters

_TRY_IO_BEGIN

try

{

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

const

ctype

_Elem

_Ctype_fac

= ::

std

use_facet

ctype

_Elem

>>(

_Ostr

getloc

());

((

_Ostr

flags

() &

ios_base

adjustfield

) !=

ios_base

left

)

for

(;

_Pad

; --

_Pad

)

// pad on left

(

_Traits

::eq_int_type(

_Traits

::eof(),

_Ostr

rdbuf

()->sputc(

_Ostr

fill

()))) {

// insertion failed, quit

_State

ios_base

badbit

;

break

; }

for

(;

_State

ios_base

goodbit

_Count

; --

_Count

, ++

_Val

)

(

_Traits

::eq_int_type(

_Traits

::eof(),

_Ostr

rdbuf

()->sputc(

_Ctype_fac

widen

_Val

))))

_State

ios_base

badbit

;

(

_State

ios_base

goodbit

)

for

(;

_Pad

; --

_Pad

)

// pad on right

(

_Traits

::eq_int_type(

_Traits

::eof(),

_Ostr

rdbuf

()->sputc(

_Ostr

fill

()))) {

// insertion failed, quit

_State

ios_base

badbit

;

break

; }

_Ostr

width

(

);

_CATCH_IO_(_Ostr)

}

catch

(...) { (

_Ostr

setstate

(

ios_base

badbit

true

); }

}

_Ostr

setstate

(

_State

);

return

(

_Ostr

); }

template

class

_Elem

class

_Traits

inline

basic_ostream

_Elem

_Traits

operator

(

basic_ostream

_Elem

_Traits

_Ostr

char

_Ch

) {

// insert a character

ios_base

iostate

_State

ios_base

goodbit

;

const

typename

basic_ostream

_Elem

_Traits

>::

sentry

_Ok

(

_Ostr

);

(

_Ok

) {

// state okay, insert

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

const

ctype

_Elem

_Ctype_fac

= ::

std

use_facet

ctype

_Elem

>>(

_Ostr

getloc

());

streamsize

_Pad

_Ostr

width

() <=

_Ostr

width

() -

;

_TRY_IO_BEGIN

try

{

((

_Ostr

flags

() &

ios_base

adjustfield

) !=

ios_base

left

)

for

(;

_State

ios_base

goodbit

_Pad

; --

_Pad

)

// pad on left

(

_Traits

::eq_int_type(

_Traits

::eof(),

_Ostr

rdbuf

()->sputc(

_Ostr

fill

())))

_State

ios_base

badbit

;

(

_State

ios_base

goodbit

_Traits

::eq_int_type(

_Traits

::eof(),

_Ostr

rdbuf

()->sputc(

_Ctype_fac

widen

(

_Ch

))))

_State

ios_base

badbit

;

for

(;

_State

ios_base

goodbit

_Pad

; --

_Pad

)

// pad on right

(

_Traits

::eq_int_type(

_Traits

::eof(),

_Ostr

rdbuf

()->sputc(

_Ostr

fill

())))

_State

ios_base

badbit

;

_CATCH_IO_(_Ostr)

}

catch

(...) { (

_Ostr

setstate

(

ios_base

badbit

true

); }

}

_Ostr

width

(

);

_Ostr

setstate

(

_State

);

return

(

_Ostr

); }

template

class

_Traits

inline

basic_ostream

char

_Traits

operator

(

basic_ostream

char

_Traits

_Ostr

const

char

_Val

) {

// insert NTBS into char stream

typedef

char

_Elem

;

typedef

basic_ostream

_Elem

_Traits

_Myos

;

ios_base

iostate

_State

ios_base

goodbit

;

streamsize

_Count

= (

streamsize

)

_Traits

::length(

_Val

);

// may overflow

streamsize

_Pad

_Ostr

width

() <=

_Ostr

width

() <=

_Count

_Ostr

width

() -

_Count

;

const

typename

_Myos

sentry

_Ok

(

_Ostr

);

_Ok

)

_State

ios_base

badbit

;

else

{

// state okay, insert

_TRY_IO_BEGIN

try

{

((

_Ostr

flags

() &

ios_base

adjustfield

) !=

ios_base

left

)

for

(;

_Pad

; --

_Pad

)

// pad on left

(

_Traits

::eq_int_type(

_Traits

::eof(),

_Ostr

rdbuf

()->sputc(

_Ostr

fill

()))) {

// insertion failed, quit

_State

ios_base

badbit

;

break

; }

(

_State

ios_base

goodbit

_Ostr

rdbuf

()->sputn(

_Val

_Count

) !=

_Count

)

_State

ios_base

badbit

;

(

_State

ios_base

goodbit

)

for

(;

_Pad

; --

_Pad

)

// pad on right

(

_Traits

::eq_int_type(

_Traits

::eof(),

_Ostr

rdbuf

()->sputc(

_Ostr

fill

()))) {

// insertion failed, quit

_State

ios_base

badbit

;

break

; }

_Ostr

width

(

);

_CATCH_IO_(_Ostr)

}

catch

(...) { (

_Ostr

setstate

(

ios_base

badbit

true

); }

}

_Ostr

setstate

(

_State

);

return

(

_Ostr

); }

template

class

_Traits

inline

basic_ostream

char

_Traits

operator

(

basic_ostream

char

_Traits

_Ostr

char

_Ch

) {

// insert a char into char stream

typedef

char

_Elem

;

typedef

basic_ostream

_Elem

_Traits

_Myos

;

ios_base

iostate

_State

ios_base

goodbit

;

const

typename

_Myos

sentry

_Ok

(

_Ostr

);

(

_Ok

) {

// state okay, insert

streamsize

_Pad

_Ostr

width

() <=

_Ostr

width

() -

;

_TRY_IO_BEGIN

try

{

((

_Ostr

flags

() &

ios_base

adjustfield

) !=

ios_base

left

)

for

(;

_State

ios_base

goodbit

_Pad

; --

_Pad

)

// pad on left

(

_Traits

::eq_int_type(

_Traits

::eof(),

_Ostr

rdbuf

()->sputc(

_Ostr

fill

())))

_State

ios_base

badbit

;

(

_State

ios_base

goodbit

_Traits

::eq_int_type(

_Traits

::eof(),

_Ostr

rdbuf

()->sputc(

_Ch

)))

_State

ios_base

badbit

;

for

(;

_State

ios_base

goodbit

_Pad

; --

_Pad

)

// pad on right

(

_Traits

::eq_int_type(

_Traits

::eof(),

_Ostr

rdbuf

()->sputc(

_Ostr

fill

())))

_State

ios_base

badbit

;

_CATCH_IO_(_Ostr)

}

catch

(...) { (

_Ostr

setstate

(

ios_base

badbit

true

); }

}

_Ostr

width

(

);

_Ostr

setstate

(

_State

);

return

(

_Ostr

); }

template

class

_Elem

class

_Traits

inline

basic_ostream

_Elem

_Traits

operator

(

basic_ostream

_Elem

_Traits

_Ostr

const

_Elem

_Val

) {

// insert NTCS

typedef

basic_ostream

_Elem

_Traits

_Myos

;

ios_base

iostate

_State

ios_base

goodbit

;

streamsize

_Count

= (

streamsize

)

_Traits

::length(

_Val

);

// may overflow

streamsize

_Pad

_Ostr

width

() <=

_Ostr

width

() <=

_Count

_Ostr

width

() -

_Count

;

const

typename

_Myos

sentry

_Ok

(

_Ostr

);

_Ok

)

_State

ios_base

badbit

;

else

{

// state okay, insert

_TRY_IO_BEGIN

try

{

((

_Ostr

flags

() &

ios_base

adjustfield

) !=

ios_base

left

)

for

(;

_Pad

; --

_Pad

)

// pad on left

(

_Traits

::eq_int_type(

_Traits

::eof(),

_Ostr

rdbuf

()->sputc(

_Ostr

fill

()))) {

// insertion failed, quit

_State

ios_base

badbit

;

break

; }

(

_State

ios_base

goodbit

_Ostr

rdbuf

()->sputn(

_Val

_Count

) !=

_Count

)

_State

ios_base

badbit

;

(

_State

ios_base

goodbit

)

for

(;

_Pad

; --

_Pad

)

// pad on right

(

_Traits

::eq_int_type(

_Traits

::eof(),

_Ostr

rdbuf

()->sputc(

_Ostr

fill

()))) {

// insertion failed, quit

_State

ios_base

badbit

;

break

; }

_Ostr

width

(

);

_CATCH_IO_(_Ostr)

}

catch

(...) { (

_Ostr

setstate

(

ios_base

badbit

true

); }

}

_Ostr

setstate

(

_State

);

return

(

_Ostr

); }

template

class

_Elem

class

_Traits

inline

basic_ostream

_Elem

_Traits

operator

(

basic_ostream

_Elem

_Traits

_Ostr

_Elem

_Ch

) {

// insert a character

typedef

basic_ostream

_Elem

_Traits

_Myos

;

ios_base

iostate

_State

ios_base

goodbit

;

const

typename

_Myos

sentry

_Ok

(

_Ostr

);

(

_Ok

) {

// state okay, insert

streamsize

_Pad

_Ostr

width

() <=

_Ostr

width

() -

;

_TRY_IO_BEGIN

try

{

((

_Ostr

flags

() &

ios_base

adjustfield

) !=

ios_base

left

)

for

(;

_State

ios_base

goodbit

_Pad

; --

_Pad

)

// pad on left

(

_Traits

::eq_int_type(

_Traits

::eof(),

_Ostr

rdbuf

()->sputc(

_Ostr

fill

())))

_State

ios_base

badbit

;

(

_State

ios_base

goodbit

_Traits

::eq_int_type(

_Traits

::eof(),

_Ostr

rdbuf

()->sputc(

_Ch

)))

_State

ios_base

badbit

;

for

(;

_State

ios_base

goodbit

_Pad

; --

_Pad

)

// pad on right

(

_Traits

::eq_int_type(

_Traits

::eof(),

_Ostr

rdbuf

()->sputc(

_Ostr

fill

())))

_State

ios_base

badbit

;

_CATCH_IO_(_Ostr)

}

catch

(...) { (

_Ostr

setstate

(

ios_base

badbit

true

); }

}

_Ostr

width

(

);

_Ostr

setstate

(

_State

);

return

(

_Ostr

); }

template

class

_Traits

inline

basic_ostream

char

_Traits

operator

(

basic_ostream

char

_Traits

_Ostr

const

signed

char

_Val

) {

// insert a signed char NTBS

return

(

_Ostr

(

const

char

_Val

); }

template

class

_Traits

inline

basic_ostream

char

_Traits

operator

(

basic_ostream

char

_Traits

_Ostr

signed

char

_Ch

) {

// insert a signed char

return

(

_Ostr

(

char

)

_Ch

); }

template

class

_Traits

inline

basic_ostream

char

_Traits

operator

(

basic_ostream

char

_Traits

_Ostr

const

unsigned

char

_Val

) {

// insert an unsigned char NTBS

return

(

_Ostr

(

const

char

_Val

); }

template

class

_Traits

inline

basic_ostream

char

_Traits

operator

(

basic_ostream

char

_Traits

_Ostr

unsigned

char

_Ch

) {

// insert an unsigned char

return

(

_Ostr

(

char

)

_Ch

); }

template

class

_Ostr

class

_Ty

class

void

struct

_Can_stream_out

false_type

{ };

template

class

_Ostr

class

_Ty

struct _Can_stream_out<_Ostr, _Ty, void_t<decltype(_STD declval<_Ostr&>() << _STD declval<const _Ty&>())>>

struct

_Can_stream_out

_Ostr

_Ty

void_t

decltype

(::

std

declval

_Ostr

&>() << ::

std

declval

const

_Ty

&>())>>

true_type

{ };

template

class

_Ostr

class

_Ty

enable_if_t

conjunction_v

// prevent infinite recursion

negation

is_lvalue_reference

_Ostr

>>,

is_base_of

ios_base

_Ostr

_Can_stream_out

_Ostr

_Ty

>>,

int

> =

inline

_Ostr

operator

(

_Ostr

_Os

const

_Ty

_Val

) {

// insert to rvalue stream

_Os

_Val

;

return (_STD move(_Os));

return

(::

std

move

(

_Os

));

}

// MANIPULATORS

template

class

_Elem

class

_Traits

inline

basic_ostream

_Elem

_Traits

__CLRCALL_OR_CDECL endl(basic_ostream<_Elem, _Traits>& _Ostr)

__cdecl

endl

(

basic_ostream

_Elem

_Traits

_Ostr

)

{

// insert newline and flush stream

_Ostr

put

(

_Ostr

widen

(

'\n'

));

_Ostr

flush

();

return

(

_Ostr

); }

template

class

_Elem

class

_Traits

inline

basic_ostream

_Elem

_Traits

__CLRCALL_OR_CDECL ends(basic_ostream<_Elem, _Traits>& _Ostr)

__cdecl

ends

(

basic_ostream

_Elem

_Traits

_Ostr

)

{

// insert null character

_Ostr

put

(

_Elem

());

return

(

_Ostr

); }

template

class

_Elem

class

_Traits

inline

basic_ostream

_Elem

_Traits

__CLRCALL_OR_CDECL flush(basic_ostream<_Elem, _Traits>& _Ostr)

__cdecl

flush

(

basic_ostream

_Elem

_Traits

_Ostr

)

{

// flush stream

_Ostr

flush

();

return

(

_Ostr

); }

// INSERTER FOR error_category

template

class

_Elem

class

_Traits

inline

basic_ostream

_Elem

_Traits

operator

(

basic_ostream

_Elem

_Traits

_Ostr

const

error_code

_Errcode

) {

// display error code

return

(

_Ostr

_Errcode