basic_ostream< _Elem, _Traits > Class Template Reference

Inheritance diagram for basic_ostream< _Elem, _Traits >:

Classes
class	_Sentry_base
class	sentry

Public Types
typedef basic_ostream< _Elem, _Traits >	_Myt
typedef basic_ios< _Elem, _Traits >	_Myios
typedef basic_streambuf< _Elem, _Traits >	_Mysb
typedef ostreambuf_iterator< _Elem, _Traits >	_Iter
typedef num_put< _Elem, _Iter >	_Nput
typedef _Traits::int_type	int_type
typedef _Traits::pos_type	pos_type
typedef _Traits::off_type	off_type
Public Types inherited from basic_ios< _Elem, _Traits >
typedef basic_ios< _Elem, _Traits >	_Myt
typedef basic_ostream< _Elem, _Traits >	_Myos
typedef basic_streambuf< _Elem, _Traits >	_Mysb
typedef ctype< _Elem >	_Ctype
typedef _Elem	char_type
typedef _Traits	traits_type
typedef _Traits::int_type	int_type
typedef _Traits::pos_type	pos_type
typedef _Traits::off_type	off_type
Public Types inherited from ios_base
enum	event { erase_event, imbue_event, copyfmt_event }
typedef _STD streamoff	streamoff
typedef _STD streampos	streampos
typedef void(__CLRCALL_OR_CDECL *	event_callback) (event, ios_base &, int)
typedef unsigned int	io_state
typedef unsigned int	open_mode
typedef unsigned int	seek_dir
Public Types inherited from _Iosb< int >
enum	_Dummy_enum
enum	_Fmtflags
enum	_Iostate
enum	_Openmode
enum	_Seekdir
enum

Public Member Functions
__CLR_OR_THIS_CALL	basic_ostream (basic_streambuf< _Elem, _Traits > *_Strbuf, bool _Isstd=false)
__CLR_OR_THIS_CALL	basic_ostream (_Uninitialized, bool _Addit=true)
__CLR_OR_THIS_CALL	basic_ostream (const _Myt &)=delete
_Myt &__CLR_OR_THIS_CALL	operator= (const _Myt &)=delete
virtual __CLR_OR_THIS_CALL	~basic_ostream () _NOEXCEPT
bool __CLR_OR_THIS_CALL	opfx ()
void __CLR_OR_THIS_CALL	osfx ()
void __CLR_OR_THIS_CALL	_Osfx ()
_Myt &__CLR_OR_THIS_CALL	operator<< (_Myt &(__cdecl *_Pfn)(_Myt &))
_Myt &__CLR_OR_THIS_CALL	operator<< (_Myios &(__cdecl *_Pfn)(_Myios &))
_Myt &__CLR_OR_THIS_CALL	operator<< (ios_base &(__cdecl *_Pfn)(ios_base &))
_Myt &__CLR_OR_THIS_CALL	operator<< (_Bool _Val)
_Myt &__CLR_OR_THIS_CALL	operator<< (short _Val)
_Myt &__CLR_OR_THIS_CALL	operator<< (unsigned short _Val)
_Myt &__CLR_OR_THIS_CALL	operator<< (int _Val)
_Myt &__CLR_OR_THIS_CALL	operator<< (unsigned int _Val)
_Myt &__CLR_OR_THIS_CALL	operator<< (long _Val)
_Myt &__CLR_OR_THIS_CALL	operator<< (unsigned long _Val)
_Myt &__CLR_OR_THIS_CALL	operator<< (float _Val)
_Myt &__CLR_OR_THIS_CALL	operator<< (double _Val)
_Myt &__CLR_OR_THIS_CALL	operator<< (long double _Val)
_Myt &__CLR_OR_THIS_CALL	operator<< (const void *_Val)
_Myt &__CLR_OR_THIS_CALL	operator<< (_Mysb *_Strbuf)
_Myt &__CLR_OR_THIS_CALL	put (_Elem _Ch)
_Myt &__CLR_OR_THIS_CALL	write (const _Elem *_Str, streamsize _Count)
_Myt &__CLR_OR_THIS_CALL	flush ()
_Myt &__CLR_OR_THIS_CALL	seekp (pos_type _Pos)
_Myt &__CLR_OR_THIS_CALL	seekp (off_type _Off, ios_base::seekdir _Way)
pos_type __CLR_OR_THIS_CALL	tellp ()
template<>
basic_ostream< unsigned short, char_traits< unsigned short > > &__CLR_OR_THIS_CALL	operator<< (unsigned short _Ch)
Public Member Functions inherited from basic_ios< _Elem, _Traits >
__CLR_OR_THIS_CALL	basic_ios (_Mysb *_Strbuf)
virtual __CLR_OR_THIS_CALL	~basic_ios () _NOEXCEPT
void __CLR_OR_THIS_CALL	clear (iostate _State=goodbit, bool _Reraise=false)
void __CLR_OR_THIS_CALL	clear (io_state _State)
void __CLR_OR_THIS_CALL	setstate (iostate _State, bool _Reraise=false)
void __CLR_OR_THIS_CALL	setstate (io_state _State)
_Myt &__CLR_OR_THIS_CALL	copyfmt (const _Myt &_Right)
_Myos *__CLR_OR_THIS_CALL	tie () const
_Myos *__CLR_OR_THIS_CALL	tie (_Myos *_Newtie)
_Mysb *__CLR_OR_THIS_CALL	rdbuf () const
_Mysb *__CLR_OR_THIS_CALL	rdbuf (_Mysb *_Strbuf)
locale __CLR_OR_THIS_CALL	imbue (const locale &_Loc)
_Elem __CLR_OR_THIS_CALL	fill () const
_Elem __CLR_OR_THIS_CALL	fill (_Elem _Newfill)
char __CLR_OR_THIS_CALL	narrow (_Elem _Ch, char _Dflt= '\0') const
_Elem __CLR_OR_THIS_CALL	widen (char _Byte) const
void __CLR_OR_THIS_CALL	move (_Myt &_Right)
void __CLR_OR_THIS_CALL	move (_Myt &&_Right)
void __CLR_OR_THIS_CALL	swap (_Myt &_Right) _NOEXCEPT
void __CLR_OR_THIS_CALL	set_rdbuf (_Mysb *_Strbuf)
__CLR_OR_THIS_CALL	basic_ios (const _Myt &)=delete
_Myt &__CLR_OR_THIS_CALL	operator= (const _Myt &)=delete
Public Member Functions inherited from ios_base
	_BITMASK (_Fmtflags, fmtflags)
	_BITMASK (_Iostate, iostate)
	_BITMASK (_Openmode, openmode)
	_BITMASK (_Seekdir, seekdir)
__CLR_OR_THIS_CALL	operator bool () const
bool __CLR_OR_THIS_CALL	operator! () const
void __CLR_OR_THIS_CALL	clear (iostate _State, bool _Reraise)
void __CLR_OR_THIS_CALL	clear (iostate _State=goodbit)
void __CLR_OR_THIS_CALL	clear (io_state _State)
iostate __CLR_OR_THIS_CALL	rdstate () const
void __CLR_OR_THIS_CALL	setstate (iostate _State, bool _Exreraise)
void __CLR_OR_THIS_CALL	setstate (iostate _State)
void __CLR_OR_THIS_CALL	setstate (io_state _State)
bool __CLR_OR_THIS_CALL	good () const
bool __CLR_OR_THIS_CALL	eof () const
bool __CLR_OR_THIS_CALL	fail () const
bool __CLR_OR_THIS_CALL	bad () const
iostate __CLR_OR_THIS_CALL	exceptions () const
void __CLR_OR_THIS_CALL	exceptions (iostate _Newexcept)
void __CLR_OR_THIS_CALL	exceptions (io_state _State)
fmtflags __CLR_OR_THIS_CALL	flags () const
fmtflags __CLR_OR_THIS_CALL	flags (fmtflags _Newfmtflags)
fmtflags __CLR_OR_THIS_CALL	setf (fmtflags _Newfmtflags)
fmtflags __CLR_OR_THIS_CALL	setf (fmtflags _Newfmtflags, fmtflags _Mask)
void __CLR_OR_THIS_CALL	unsetf (fmtflags _Mask)
streamsize __CLR_OR_THIS_CALL	precision () const
streamsize __CLR_OR_THIS_CALL	precision (streamsize _Newprecision)
streamsize __CLR_OR_THIS_CALL	width () const
streamsize __CLR_OR_THIS_CALL	width (streamsize _Newwidth)
locale __CLR_OR_THIS_CALL	getloc () const
locale __CLR_OR_THIS_CALL	imbue (const locale &_Loc)
long &__CLR_OR_THIS_CALL	iword (int _Idx)
void *&__CLR_OR_THIS_CALL	pword (int _Idx)
void __CLR_OR_THIS_CALL	register_callback (event_callback _Pfn, int _Idx)
ios_base &__CLR_OR_THIS_CALL	copyfmt (const ios_base &_Other)
void __CLR_OR_THIS_CALL	swap (ios_base &_Right)
virtual __CLR_OR_THIS_CALL	~ios_base () _NOEXCEPT
	ios_base (const ios_base &)=delete
ios_base &	operator= (const ios_base &)=delete

Protected Member Functions
__CLR_OR_THIS_CALL	basic_ostream (_Myt &&_Right)
_Myt &__CLR_OR_THIS_CALL	operator= (_Myt &&_Right)
void __CLR_OR_THIS_CALL	swap (_Myt &_Right)
Protected Member Functions inherited from basic_ios< _Elem, _Traits >
void __CLR_OR_THIS_CALL	init (_Mysb *_Strbuf=0, bool _Isstd=false)
__CLR_OR_THIS_CALL	basic_ios ()
Protected Member Functions inherited from ios_base
__CLR_OR_THIS_CALL	ios_base ()
void __CLR_OR_THIS_CALL	_Init ()

Additional Inherited Members
Static Public Member Functions inherited from ios_base
static int __CLRCALL_OR_CDECL	xalloc ()
static bool __CLRCALL_OR_CDECL	sync_with_stdio (bool _Newsync=true)
static _MRTIMP2_PURE_NPURE void __CLRCALL_PURE_OR_CDECL	_Addstd (ios_base *)
Public Attributes inherited from ios_base
size_t	_Stdstr
Static Public Attributes inherited from _Iosb< int >
static const _Fmtflags	skipws
static const _Fmtflags	unitbuf
static const _Fmtflags	uppercase
static const _Fmtflags	showbase
static const _Fmtflags	showpoint
static const _Fmtflags	showpos
static const _Fmtflags	left
static const _Fmtflags	right
static const _Fmtflags	internal
static const _Fmtflags	dec
static const _Fmtflags	oct
static const _Fmtflags	hex
static const _Fmtflags	scientific
static const _Fmtflags	fixed
static const _Fmtflags	hexfloat
static const _Fmtflags	boolalpha
static const _Fmtflags	_Stdio
static const _Fmtflags	adjustfield
static const _Fmtflags	basefield
static const _Fmtflags	floatfield
static const _Iostate	goodbit
static const _Iostate	eofbit
static const _Iostate	failbit
static const _Iostate	badbit
static const _Iostate	_Hardfail
static const _Openmode	in
static const _Openmode	out
static const _Openmode	ate
static const _Openmode	app
static const _Openmode	trunc
static const _Openmode	_Nocreate
static const _Openmode	_Noreplace
static const _Openmode	binary
static const _Seekdir	beg
static const _Seekdir	cur
static const _Seekdir	end

Member Typedef Documentation

template<class _Elem, class _Traits>

typedef ostreambuf_iterator<_Elem, _Traits> basic_ostream< _Elem, _Traits >::_Iter

template<class _Elem, class _Traits>

typedef basic_ios<_Elem, _Traits> basic_ostream< _Elem, _Traits >::_Myios

template<class _Elem, class _Traits>

typedef basic_streambuf<_Elem, _Traits> basic_ostream< _Elem, _Traits >::_Mysb

template<class _Elem, class _Traits>

typedef basic_ostream<_Elem, _Traits> basic_ostream< _Elem, _Traits >::_Myt

template<class _Elem, class _Traits>

typedef num_put<_Elem, _Iter> basic_ostream< _Elem, _Traits >::_Nput

template<class _Elem, class _Traits>

typedef _Traits::int_type basic_ostream< _Elem, _Traits >::int_type

template<class _Elem, class _Traits>

typedef _Traits::off_type basic_ostream< _Elem, _Traits >::off_type

template<class _Elem, class _Traits>

typedef _Traits::pos_type basic_ostream< _Elem, _Traits >::pos_type

Constructor & Destructor Documentation

template<class _Elem, class _Traits>

__CLR_OR_THIS_CALL basic_ostream< _Elem, _Traits >::basic_ostream ( basic_streambuf< _Elem, _Traits > *  _Strbuf, bool  _Isstd = false  )

inlineexplicit

        {   // construct from a stream buffer pointer
        _Myios::init(_Strbuf, _Isstd);
        }

template<class _Elem, class _Traits>

__CLR_OR_THIS_CALL basic_ostream< _Elem, _Traits >::basic_ostream ( _Uninitialized  , bool  _Addit = true  )

inline

        {   // construct uninitialized
        if (_Addit)
            this->_Addstd(this);    // suppress for basic_iostream
        }

template<class _Elem, class _Traits>

__CLR_OR_THIS_CALL basic_ostream< _Elem, _Traits >::basic_ostream ( _Myt &&  _Right )

inlineprotected

        {   // construct by moving _Right
        _Myios::init();
        _Myios::move(_STD move(_Right));
        }

template<class _Elem, class _Traits>

__CLR_OR_THIS_CALL basic_ostream< _Elem, _Traits >::basic_ostream ( const _Myt &  )

delete

template<class _Elem, class _Traits>

virtual __CLR_OR_THIS_CALL basic_ostream< _Elem, _Traits >::~basic_ostream ( )

inlinevirtual

        {   // destroy the object
        }

Member Function Documentation

template<class _Elem, class _Traits>

void __CLR_OR_THIS_CALL basic_ostream< _Elem, _Traits >::_Osfx ( )

inline

        {   // perform any wrapup
        _TRY_BEGIN
        if (this->good() && this->flags() & ios_base::unitbuf)
            if (_Myios::rdbuf()->pubsync() == -1)   // flush stream as needed
                _Myios::setstate(ios_base::badbit);
        _CATCH_ALL
        _CATCH_END
        }

template<class _Elem, class _Traits>

_Myt& __CLR_OR_THIS_CALL basic_ostream< _Elem, _Traits >::flush ( )

inline

        {   // flush output stream
        if (_Myios::rdbuf() != 0)
            {   // buffer exists, flush it
            const sentry _Ok(*this);

            if (_Ok && _Myios::rdbuf()->pubsync() == -1)
                _Myios::setstate(ios_base::badbit); // sync failed
            }
        return (*this);
        }

template<class _Elem, class _Traits>

_Myt& __CLR_OR_THIS_CALL basic_ostream< _Elem, _Traits >::operator<< ( _Myt &  __cdecl *_Pfn)(_Myt & )

inline

        {   // call basic_ostream manipulator
        _DEBUG_POINTER(_Pfn);
        return ((*_Pfn)(*this));
        }

template<class _Elem, class _Traits>

_Myt& __CLR_OR_THIS_CALL basic_ostream< _Elem, _Traits >::operator<< ( _Myios &  __cdecl *_Pfn)(_Myios & )

inline

        {   // call basic_ios manipulator
        _DEBUG_POINTER(_Pfn);
        (*_Pfn)(*(_Myios *)this);
        return (*this);
        }

template<class _Elem, class _Traits>

_Myt& __CLR_OR_THIS_CALL basic_ostream< _Elem, _Traits >::operator<< ( ios_base &  __cdecl *_Pfn)(ios_base & )

inline

        {   // call ios_base manipulator
        _DEBUG_POINTER(_Pfn);
        (*_Pfn)(*(ios_base *)this);
        return (*this);
        }

template<class _Elem, class _Traits>

_Myt& __CLR_OR_THIS_CALL basic_ostream< _Elem, _Traits >::operator<< ( _Bool  _Val )

inline

        {   // insert a boolean
        ios_base::iostate _State = ios_base::goodbit;
        const sentry _Ok(*this);

        if (_Ok)
            {   // state okay, use facet to insert
            const _Nput& _Nput_fac = _USE(this->getloc(), _Nput);

            _TRY_IO_BEGIN
            if (_Nput_fac.put(_Iter(_Myios::rdbuf()), *this,
                _Myios::fill(), _Val).failed())
                _State |= ios_base::badbit;
            _CATCH_IO_END
            }

        _Myios::setstate(_State);
        return (*this);
        }

template<class _Elem, class _Traits>

_Myt& __CLR_OR_THIS_CALL basic_ostream< _Elem, _Traits >::operator<< ( short  _Val )

inline

        {   // insert a short
        ios_base::iostate _State = ios_base::goodbit;
        const sentry _Ok(*this);

        if (_Ok)
            {   // state okay, use facet to insert
            const _Nput& _Nput_fac = _USE(this->getloc(), _Nput);
            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
            if (_Nput_fac.put(_Iter(_Myios::rdbuf()), *this,
                _Myios::fill(), _Tmp).failed())
                _State |= ios_base::badbit;
            _CATCH_IO_END
            }

        _Myios::setstate(_State);
        return (*this);
        }

template<class _Elem, class _Traits>

_Myt& __CLR_OR_THIS_CALL basic_ostream< _Elem, _Traits >::operator<< ( unsigned short  _Val )

inline

        {   // insert an unsigned short
        ios_base::iostate _State = ios_base::goodbit;
        const sentry _Ok(*this);

        if (_Ok)
            {   // state okay, use facet to insert
            const _Nput& _Nput_fac = _USE(this->getloc(), _Nput);

            _TRY_IO_BEGIN
            if (_Nput_fac.put(_Iter(_Myios::rdbuf()), *this,
                _Myios::fill(), (unsigned long)_Val).failed())
                _State |= ios_base::badbit;
            _CATCH_IO_END
            }

        _Myios::setstate(_State);
        return (*this);
        }

template<class _Elem, class _Traits>

_Myt& __CLR_OR_THIS_CALL basic_ostream< _Elem, _Traits >::operator<< ( int  _Val )

inline

        {   // insert an int
        ios_base::iostate _State = ios_base::goodbit;
        const sentry _Ok(*this);

        if (_Ok)
            {   // state okay, use facet to insert
            const _Nput& _Nput_fac = _USE(this->getloc(), _Nput);
            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
            if (_Nput_fac.put(_Iter(_Myios::rdbuf()), *this,
                _Myios::fill(), _Tmp).failed())
                _State |= ios_base::badbit;
            _CATCH_IO_END
            }

        _Myios::setstate(_State);
        return (*this);
        }

template<class _Elem, class _Traits>

_Myt& __CLR_OR_THIS_CALL basic_ostream< _Elem, _Traits >::operator<< ( unsigned int  _Val )

inline

        {   // insert an unsigned int
        ios_base::iostate _State = ios_base::goodbit;
        const sentry _Ok(*this);

        if (_Ok)
            {   // state okay, use facet to insert
            const _Nput& _Nput_fac = _USE(this->getloc(), _Nput);

            _TRY_IO_BEGIN
            if (_Nput_fac.put(_Iter(_Myios::rdbuf()), *this,
                _Myios::fill(), (unsigned long)_Val).failed())
                _State |= ios_base::badbit;
            _CATCH_IO_END
            }

        _Myios::setstate(_State);
        return (*this);
        }

template<class _Elem, class _Traits>

_Myt& __CLR_OR_THIS_CALL basic_ostream< _Elem, _Traits >::operator<< ( long  _Val )

inline

        {   // insert a long
        ios_base::iostate _State = ios_base::goodbit;
        const sentry _Ok(*this);

        if (_Ok)
            {   // state okay, use facet to insert
            const _Nput& _Nput_fac = _USE(this->getloc(), _Nput);

            _TRY_IO_BEGIN
            if (_Nput_fac.put(_Iter(_Myios::rdbuf()), *this,
                _Myios::fill(), _Val).failed())
                _State |= ios_base::badbit;
            _CATCH_IO_END
            }

        _Myios::setstate(_State);
        return (*this);
        }

template<class _Elem, class _Traits>

_Myt& __CLR_OR_THIS_CALL basic_ostream< _Elem, _Traits >::operator<< ( unsigned long  _Val )

inline

        {   // insert an unsigned long
        ios_base::iostate _State = ios_base::goodbit;
        const sentry _Ok(*this);

        if (_Ok)
            {   // state okay, use facet to insert
            const _Nput& _Nput_fac = _USE(this->getloc(), _Nput);

            _TRY_IO_BEGIN
            if (_Nput_fac.put(_Iter(_Myios::rdbuf()), *this,
                _Myios::fill(), _Val).failed())
                _State |= ios_base::badbit;
            _CATCH_IO_END
            }

        _Myios::setstate(_State);
        return (*this);
        }

template<class _Elem, class _Traits>

_Myt& __CLR_OR_THIS_CALL basic_ostream< _Elem, _Traits >::operator<< ( float  _Val )

inline

        {   // insert a float
        ios_base::iostate _State = ios_base::goodbit;
        const sentry _Ok(*this);

        if (_Ok)
            {   // state okay, use facet to insert
            const _Nput& _Nput_fac = _USE(this->getloc(), _Nput);

            _TRY_IO_BEGIN
            if (_Nput_fac.put(_Iter(_Myios::rdbuf()), *this,
                _Myios::fill(), (double)_Val).failed())
                _State |= ios_base::badbit;
            _CATCH_IO_END
            }

        _Myios::setstate(_State);
        return (*this);
        }

template<class _Elem, class _Traits>

_Myt& __CLR_OR_THIS_CALL basic_ostream< _Elem, _Traits >::operator<< ( double  _Val )

inline

        {   // insert a double
        ios_base::iostate _State = ios_base::goodbit;
        const sentry _Ok(*this);

        if (_Ok)
            {   // state okay, use facet to insert
            const _Nput& _Nput_fac = _USE(this->getloc(), _Nput);

            _TRY_IO_BEGIN
            if (_Nput_fac.put(_Iter(_Myios::rdbuf()), *this,
                _Myios::fill(), _Val).failed())
                _State |= ios_base::badbit;
            _CATCH_IO_END
            }

        _Myios::setstate(_State);
        return (*this);
        }

template<class _Elem, class _Traits>

_Myt& __CLR_OR_THIS_CALL basic_ostream< _Elem, _Traits >::operator<< ( long double  _Val )

inline

        {   // insert a long double
        ios_base::iostate _State = ios_base::goodbit;
        const sentry _Ok(*this);

        if (_Ok)
            {   // state okay, use facet to insert
            const _Nput& _Nput_fac = _USE(this->getloc(), _Nput);

            _TRY_IO_BEGIN
            if (_Nput_fac.put(_Iter(_Myios::rdbuf()), *this,
                _Myios::fill(), _Val).failed())
                _State |= ios_base::badbit;
            _CATCH_IO_END
            }

        _Myios::setstate(_State);
        return (*this);
        }

template<class _Elem, class _Traits>

_Myt& __CLR_OR_THIS_CALL basic_ostream< _Elem, _Traits >::operator<< ( const void *  _Val )

inline

        {   // insert a void pointer
        ios_base::iostate _State = ios_base::goodbit;
        const sentry _Ok(*this);

        if (_Ok)
            {   // state okay, use facet to insert
            const _Nput& _Nput_fac = _USE(this->getloc(), _Nput);

            _TRY_IO_BEGIN
            if (_Nput_fac.put(_Iter(_Myios::rdbuf()), *this,
                _Myios::fill(), _Val).failed())
                _State |= ios_base::badbit;
            _CATCH_IO_END
            }

        _Myios::setstate(_State);
        return (*this);
        }

template<class _Elem, class _Traits>

_Myt& __CLR_OR_THIS_CALL basic_ostream< _Elem, _Traits >::operator<< ( _Mysb *  _Strbuf )

inline

        {   // insert until end-of-file from a stream buffer
        ios_base::iostate _State = ios_base::goodbit;
        bool _Copied = false;
        const sentry _Ok(*this);

        if (_Ok && _Strbuf != 0)
            for (int_type _Meta = _Traits::eof(); ; _Copied = true)
                {   // extract another character from stream buffer
                _TRY_BEGIN
                _Meta = _Traits::eq_int_type(_Traits::eof(), _Meta)
                    ? _Strbuf->sgetc() : _Strbuf->snextc();
                _CATCH_ALL
                    _Myios::setstate(ios_base::failbit);
                    _RERAISE;
                _CATCH_END

                if (_Traits::eq_int_type(_Traits::eof(), _Meta))
                    break;  // end of file, quit

                _TRY_IO_BEGIN
                    if (_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
                }

        this->width(0);
        _Myios::setstate(_Strbuf == 0 ? ios_base::badbit
            : !_Copied ? _State | ios_base::failbit : _State);
        return (*this);
        }

template<>

basic_ostream< unsigned short, char_traits< unsigned short > > &__CLR_OR_THIS_CALL basic_ostream< unsigned short, char_traits< unsigned short > >::operator<< ( unsigned short  _Ch )

inline

    {   // 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);
    }

template<class _Elem, class _Traits>

_Myt& __CLR_OR_THIS_CALL basic_ostream< _Elem, _Traits >::operator= ( _Myt &&  _Right )

inlineprotected

        {   // move from _Right
        this->swap(_Right);
        return (*this);
        }

template<class _Elem, class _Traits>

_Myt& __CLR_OR_THIS_CALL basic_ostream< _Elem, _Traits >::operator= ( const _Myt &  )

delete

template<class _Elem, class _Traits>

bool __CLR_OR_THIS_CALL basic_ostream< _Elem, _Traits >::opfx ( )

inline

        {   // test stream state and flush tie stream as needed (retained)
        if (this->good() && _Myios::tie() != 0 && _Myios::tie() != this)
            _Myios::tie()->flush();
        return (this->good());
        }

template<class _Elem, class _Traits>

void __CLR_OR_THIS_CALL basic_ostream< _Elem, _Traits >::osfx ( )

inline

        {   // perform any wrapup (retained)
        _Osfx();
        }

template<class _Elem, class _Traits>

_Myt& __CLR_OR_THIS_CALL basic_ostream< _Elem, _Traits >::put ( _Elem  _Ch )

inline

        {   // insert a character
        ios_base::iostate _State = ios_base::goodbit;
        const sentry _Ok(*this);

        if (!_Ok)
            _State |= ios_base::badbit;
        else
            {   // state okay, insert character
            _TRY_IO_BEGIN
            if (_Traits::eq_int_type(_Traits::eof(),
                _Myios::rdbuf()->sputc(_Ch)))
                _State |= ios_base::badbit;
            _CATCH_IO_END
            }

        _Myios::setstate(_State);
        return (*this);
        }

template<class _Elem, class _Traits>

_Myt& __CLR_OR_THIS_CALL basic_ostream< _Elem, _Traits >::seekp ( pos_type  _Pos )

inline

        {   // set output stream position to _Pos
        const sentry _Ok(*this);

        if (!this->fail()
            && (off_type)_Myios::rdbuf()->pubseekpos(_Pos,
                ios_base::out) == _BADOFF)
            _Myios::setstate(ios_base::failbit);
        return (*this);
        }

template<class _Elem, class _Traits>

_Myt& __CLR_OR_THIS_CALL basic_ostream< _Elem, _Traits >::seekp ( off_type  _Off, ios_base::seekdir  _Way  )

inline

        {   // change output stream position by _Off, according to _Way
        const sentry _Ok(*this);

        if (!this->fail()
            && (off_type)_Myios::rdbuf()->pubseekoff(_Off, _Way,
                ios_base::out) == _BADOFF)
            _Myios::setstate(ios_base::failbit);
        return (*this);
        }

template<class _Elem, class _Traits>

void __CLR_OR_THIS_CALL basic_ostream< _Elem, _Traits >::swap ( _Myt &  _Right )

inlineprotected

        {   // swap with _Right
        if (this != &_Right)
            _Myios::swap(_Right);
        }

template<class _Elem, class _Traits>

pos_type __CLR_OR_THIS_CALL basic_ostream< _Elem, _Traits >::tellp ( )

inline

        {   // return output stream position
        const sentry _Ok(*this);

        if (!this->fail())
            return (_Myios::rdbuf()->pubseekoff(0,
                ios_base::cur, ios_base::out));
        else
            return (pos_type(_BADOFF));
        }

template<class _Elem, class _Traits>

_Myt& __CLR_OR_THIS_CALL basic_ostream< _Elem, _Traits >::write ( const _Elem *  _Str, streamsize  _Count  )

inline

        {   // insert _Count characters from array _Str
 #if _ITERATOR_DEBUG_LEVEL == 2
        if (0 < _Count)
            _DEBUG_POINTER(_Str);
 #endif /* _ITERATOR_DEBUG_LEVEL == 2 */

        ios_base::iostate _State = ios_base::goodbit;
        const sentry _Ok(*this);

        if (!_Ok)
            _State |= ios_base::badbit;
        else
            {   // state okay, insert characters
            _TRY_IO_BEGIN
            if (_Myios::rdbuf()->sputn(_Str, _Count) != _Count)
                _State |= ios_base::badbit;
            _CATCH_IO_END
            }

        _Myios::setstate(_State);
        return (*this);
        }

---

The documentation for this class was generated from the following files:

• VS2013/inc/iosfwd
• VS2013/inc/ostream