Inheritance diagram for basic_istream< _Elem, _Traits >:

Classes
class	_Sentry_base

class	sentry

Public Types
typedef basic_istream< _Elem, _Traits >	_Myt

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

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 void(__CLRCALL_OR_CDECL *	event_callback) (event, ios_base &, int)

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_istream (_Mysb *_Strbuf, bool _Isstd=false)

__CLR_OR_THIS_CALL	basic_istream (_Uninitialized)

__CLR_OR_THIS_CALL	basic_istream (const _Myt &)=delete

_Myt &__CLR_OR_THIS_CALL	operator= (const _Myt &)=delete

virtual __CLR_OR_THIS_CALL	~basic_istream () _NOEXCEPT

bool __CLR_OR_THIS_CALL	_Ipfx (bool _Noskip=false)

bool __CLR_OR_THIS_CALL	ipfx (bool _Noskip=false)

void __CLR_OR_THIS_CALL	isfx ()

_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>> (_LONGLONG &_Val)

_Myt &__CLR_OR_THIS_CALL	operator>> (_ULONGLONG &_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>> (void *&_Val)

_Myt &__CLR_OR_THIS_CALL	operator>> (_Mysb *_Strbuf)

int_type __CLR_OR_THIS_CALL	get ()

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

_Myt &__CLR_OR_THIS_CALL	get (_Elem *_Str, streamsize _Count, _Elem _Delim)

_Myt &__CLR_OR_THIS_CALL	get (_Elem &_Ch)

_Myt &__CLR_OR_THIS_CALL	get (_Mysb &_Strbuf)

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

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

_Myt &__CLR_OR_THIS_CALL	getline (_Elem *_Str, streamsize _Count, _Elem _Delim)

_Myt &__CLR_OR_THIS_CALL	ignore (streamsize _Count=1, int_type _Metadelim=_Traits::eof())

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

streamsize __CLR_OR_THIS_CALL	readsome (_Elem *_Str, streamsize _Count)

int_type __CLR_OR_THIS_CALL	peek ()

_Myt &__CLR_OR_THIS_CALL	putback (_Elem _Ch)

_Myt &__CLR_OR_THIS_CALL	unget ()

streamsize __CLR_OR_THIS_CALL	gcount () const

int __CLR_OR_THIS_CALL	sync ()

_Myt &__CLR_OR_THIS_CALL	seekg (pos_type _Pos)

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

pos_type __CLR_OR_THIS_CALL	tellg ()

template<>
basic_istream< 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	setstate (iostate _State, bool _Reraise=false)

_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
	_IOS_BITMASK (_Fmtflags, fmtflags)

	_IOS_BITMASK (_Iostate, iostate)

	_IOS_BITMASK (_Openmode, openmode)

	_IOS_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)

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)

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)

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_istream (_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 ()

Private Attributes
streamsize	_Chcount

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 constexpr _Fmtflags	skipws

static constexpr _Fmtflags	unitbuf

static constexpr _Fmtflags	uppercase

static constexpr _Fmtflags	showbase

static constexpr _Fmtflags	showpoint

static constexpr _Fmtflags	showpos

static constexpr _Fmtflags	left

static constexpr _Fmtflags	right

static constexpr _Fmtflags	internal

static constexpr _Fmtflags	dec

static constexpr _Fmtflags	oct

static constexpr _Fmtflags	hex

static constexpr _Fmtflags	scientific

static constexpr _Fmtflags	fixed

static constexpr _Fmtflags	hexfloat

static constexpr _Fmtflags	boolalpha

static constexpr _Fmtflags	_Stdio

static constexpr _Fmtflags	adjustfield

static constexpr _Fmtflags	basefield

static constexpr _Fmtflags	floatfield

static constexpr _Iostate	goodbit

static constexpr _Iostate	eofbit

static constexpr _Iostate	failbit

static constexpr _Iostate	badbit

static constexpr _Openmode	in

static constexpr _Openmode	out

static constexpr _Openmode	ate

static constexpr _Openmode	app

static constexpr _Openmode	trunc

static constexpr _Openmode	_Nocreate

static constexpr _Openmode	_Noreplace

static constexpr _Openmode	binary

static constexpr _Seekdir	beg

static constexpr _Seekdir	cur

static constexpr _Seekdir	end

Member Typedef Documentation

template<class _Elem, class _Traits>

typedef ctype<_Elem> basic_istream< _Elem, _Traits >::_Ctype

template<class _Elem, class _Traits>

typedef istreambuf_iterator<_Elem, _Traits> basic_istream< _Elem, _Traits >::_Iter

template<class _Elem, class _Traits>

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

template<class _Elem, class _Traits>

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

template<class _Elem, class _Traits>

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

template<class _Elem, class _Traits>

typedef num_get<_Elem, _Iter> basic_istream< _Elem, _Traits >::_Nget

template<class _Elem, class _Traits>

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

template<class _Elem, class _Traits>

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

template<class _Elem, class _Traits>

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

Constructor & Destructor Documentation

template<class _Elem, class _Traits>

__CLR_OR_THIS_CALL basic_istream< _Elem, _Traits >::basic_istream	(	_Mysb *	_Strbuf,
		bool	_Isstd = `false`
	)

inlineexplicit

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

template<class _Elem, class _Traits>

__CLR_OR_THIS_CALL basic_istream< _Elem, _Traits >::basic_istream ( _Uninitialized )

inline

         {   // construct uninitialized
         this->_Addstd(this);
         }

template<class _Elem, class _Traits>

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

inlineprotected

         : _Chcount(_Right._Chcount)
         {   // construct by moving _Right
         _Myios::init();
         _Myios::move(_STD move(_Right));
         _Right._Chcount = 0;
         }

template<class _Elem, class _Traits>

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

delete

template<class _Elem, class _Traits>

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

inlinevirtual

81 { // destroy the object

82 }

Member Function Documentation

template<class _Elem, class _Traits>

bool __CLR_OR_THIS_CALL basic_istream< _Elem, _Traits >::_Ipfx ( bool _Noskip = false )

inline

         {   // test stream state and skip whitespace as needed
         if (this->good())
             {   // state okay, flush tied stream and skip whitespace
             if (_Myios::tie() != 0)
                 _Myios::tie()->flush();
 
             if (!_Noskip && this->flags() & ios_base::skipws)
                 {   // skip whitespace
                 const _Ctype& _Ctype_fac = _USE(this->getloc(), _Ctype);
 
                 _TRY_IO_BEGIN
                 int_type _Meta = _Myios::rdbuf()->sgetc();
 
                 for (; ; _Meta = _Myios::rdbuf()->snextc())
                     if (_Traits::eq_int_type(_Traits::eof(), _Meta))
                         {   // end of file, quit
                         _Myios::setstate(ios_base::eofbit);
                         break;
                         }
                     else if (!_Ctype_fac.is(_Ctype::space,
                         _Traits::to_char_type(_Meta)))
                         break;  // not whitespace, quit
                 _CATCH_IO_END
                 }
 
             if (this->good())
                 return (true);
             }
         _Myios::setstate(ios_base::failbit);
         return (false);
         }

template<class _Elem, class _Traits>

streamsize __CLR_OR_THIS_CALL basic_istream< _Elem, _Traits >::gcount ( ) const

inline

         {   // get count from last extraction
         return (_Chcount);
         }

template<class _Elem, class _Traits>

int_type __CLR_OR_THIS_CALL basic_istream< _Elem, _Traits >::get ( )

inline

         {   // extract a metacharacter
         int_type _Meta = 0;
         ios_base::iostate _State = ios_base::goodbit;
         _Chcount = 0;
         const sentry _Ok(*this, true);
 
         if (!_Ok)
             _Meta = _Traits::eof(); // state not okay, return EOF
         else
             {   // state okay, extract a character
             _TRY_IO_BEGIN
             _Meta = _Myios::rdbuf()->sgetc();
 
             if (_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
             }
 
         _Myios::setstate(_State);
         return (_Meta);
         }

template<class _Elem, class _Traits>

_Myt& __CLR_OR_THIS_CALL basic_istream< _Elem, _Traits >::get	(	_Elem *	_Str,
		streamsize	_Count
	)

inline

         {   // get up to _Count characters into NTCS
         return (get(_Str, _Count, _Myios::widen('\n')));
         }

template<class _Elem, class _Traits>

_Myt& __CLR_OR_THIS_CALL basic_istream< _Elem, _Traits >::get	(	_Elem *	_Str,
		streamsize	_Count,
		_Elem	_Delim
	)

inline

         {   // get up to _Count characters into NTCS, stop before _Delim
         ios_base::iostate _State = ios_base::goodbit;
         _Chcount = 0;
         const sentry _Ok(*this, true);
 
         if (_Ok && 0 < _Count)
             {   // state okay, extract characters
             _TRY_IO_BEGIN
             int_type _Meta = _Myios::rdbuf()->sgetc();
 
             for (; 0 < --_Count; _Meta = _Myios::rdbuf()->snextc())
                 if (_Traits::eq_int_type(_Traits::eof(), _Meta))
                     {   // end of file, quit
                     _State |= ios_base::eofbit;
                     break;
                     }
                 else if (_Traits::to_char_type(_Meta) == _Delim)
                     break;  // got a delimiter, quit
                 else
                     {   // got a character, add it to string
                     _DEBUG_POINTER(_Str);
                     *_Str++ = _Traits::to_char_type(_Meta);
                     ++_Chcount;
                     }
             _CATCH_IO_END
             }
 
         _Myios::setstate(_Chcount == 0
             ? _State | ios_base::failbit : _State);
         *_Str = _Elem();    // add terminating null character
         return (*this);
         }

template<class _Elem, class _Traits>

_Myt& __CLR_OR_THIS_CALL basic_istream< _Elem, _Traits >::get ( _Elem & _Ch )

inline

         {   // get a character
         int_type _Meta = get();
         if (!_Traits::eq_int_type(_Traits::eof(), _Meta))
             _Ch = _Traits::to_char_type(_Meta);
         return (*this);
         }

template<class _Elem, class _Traits>

_Myt& __CLR_OR_THIS_CALL basic_istream< _Elem, _Traits >::get ( _Mysb & _Strbuf )

inline

         {   // extract up to newline and insert into stream buffer
         return (get(_Strbuf, _Myios::widen('\n')));
         }

template<class _Elem, class _Traits>

_Myt& __CLR_OR_THIS_CALL basic_istream< _Elem, _Traits >::get	(	_Mysb &	_Strbuf,
		_Elem	_Delim
	)

inline

         {   // extract up to delimiter and insert into stream buffer
         ios_base::iostate _State = ios_base::goodbit;
         _Chcount = 0;
         const sentry _Ok(*this, true);
 
         if (_Ok)
             {   // state okay, use facet to extract
             _TRY_IO_BEGIN
             int_type _Meta = _Myios::rdbuf()->sgetc();
 
             for (; ; _Meta = _Myios::rdbuf()->snextc())
                 if (_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
                         _Elem _Ch = _Traits::to_char_type(_Meta);
                         if (_Ch == _Delim
                             || _Traits::eq_int_type(_Traits::eof(),
                                 _Strbuf.sputc(_Ch)))
                             break;
                     _CATCH_ALL
                         break;
                     _CATCH_END
                     ++_Chcount;
                     }
             _CATCH_IO_END
             }
 
         if (_Chcount == 0)
             _State |= ios_base::failbit;
         _Myios::setstate(_State);
         return (*this);
         }

template<class _Elem, class _Traits>

_Myt& __CLR_OR_THIS_CALL basic_istream< _Elem, _Traits >::getline	(	_Elem *	_Str,
		streamsize	_Count
	)

inline

         {   // get up to _Count characters into NTCS, discard newline
         return (getline(_Str, _Count, _Myios::widen('\n')));
         }

template<class _Elem, class _Traits>

_Myt& __CLR_OR_THIS_CALL basic_istream< _Elem, _Traits >::getline	(	_Elem *	_Str,
		streamsize	_Count,
		_Elem	_Delim
	)

inline

         {   // get up to _Count characters into NTCS, discard _Delim
         ios_base::iostate _State = ios_base::goodbit;
         _Chcount = 0;
         const sentry _Ok(*this, true);
 
         if (_Ok && 0 < _Count)
             {   // state okay, use facet to extract
             int_type _Metadelim = _Traits::to_int_type(_Delim);
 
             _TRY_IO_BEGIN
             int_type _Meta = _Myios::rdbuf()->sgetc();
 
             for (; ; _Meta = _Myios::rdbuf()->snextc())
                 if (_Traits::eq_int_type(_Traits::eof(), _Meta))
                     {   // end of file, quit
                     _State |= ios_base::eofbit;
                     break;
                     }
                 else if (_Meta == _Metadelim)
                     {   // got a delimiter, discard it and quit
                     ++_Chcount;
                     _Myios::rdbuf()->sbumpc();
                     break;
                     }
                 else if (--_Count <= 0)
                     {   // buffer full, quit
                     _State |= ios_base::failbit;
                     break;
                     }
                 else
                     {   // got a character, add it to string
                     _DEBUG_POINTER(_Str);
                     *_Str++ = _Traits::to_char_type(_Meta);
                     ++_Chcount;
                     }
             _CATCH_IO_END
             }
 
         *_Str = _Elem();    // add terminating null character
         _Myios::setstate(_Chcount == 0 ? _State | ios_base::failbit : _State);
         return (*this);
         }

template<class _Elem, class _Traits>

_Myt& __CLR_OR_THIS_CALL basic_istream< _Elem, _Traits >::ignore	(	streamsize	_Count = `1`,
		int_type	_Metadelim = `_Traits::eof()`
	)

inline

         {   // ignore up to _Count characters, discarding delimiter
         ios_base::iostate _State = ios_base::goodbit;
         _Chcount = 0;
         const sentry _Ok(*this, true);
 
         if (_Ok && 0 < _Count)
             {   // state okay, use facet to extract
             _TRY_IO_BEGIN
             for (; ; )
                 {   // get a metacharacter if more room in buffer
                 int_type _Meta;
                 if (_Count != (numeric_limits<streamsize>::max)()
                     && --_Count < 0)
                     break;  // buffer full, quit
                 else if (_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;
                     if (_Meta == _Metadelim)
                         break;  // got a delimiter, quit
                     }
                 }
             _CATCH_IO_END
             }
 
         _Myios::setstate(_State);
         return (*this);
         }

template<class _Elem, class _Traits>

bool __CLR_OR_THIS_CALL basic_istream< _Elem, _Traits >::ipfx ( bool _Noskip = false )

inline

         {   // test stream state and skip whitespace as needed (retained)
         return (_Ipfx(_Noskip));
         }

template<class _Elem, class _Traits>

void __CLR_OR_THIS_CALL basic_istream< _Elem, _Traits >::isfx ( )

inline

172 { // perform any wrapup (retained)

173 }

template<class _Elem, class _Traits>

_Myt& __CLR_OR_THIS_CALL basic_istream< _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_istream< _Elem, _Traits >::operator= ( const _Myt & )

delete

template<class _Elem, class _Traits>

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

inline

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

template<class _Elem, class _Traits>

_Myt& __CLR_OR_THIS_CALL basic_istream< _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_istream< _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_istream< _Elem, _Traits >::operator>> ( bool & _Val )

inline

         {   // extract a boolean
         ios_base::iostate _State = ios_base::goodbit;
         const sentry _Ok(*this);
 
         if (_Ok)
             {   // state okay, use facet to extract
             const _Nget& _Nget_fac = _USE(this->getloc(), _Nget);
 
             _TRY_IO_BEGIN
             _Nget_fac.get(_Iter(_Myios::rdbuf()), _Iter(0),
                 *this, _State, _Val);
             _CATCH_IO_END
             }
 
         _Myios::setstate(_State);
         return (*this);
         }

template<class _Elem, class _Traits>

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

inline

         {   // extract a short
         ios_base::iostate _State = ios_base::goodbit;
         const sentry _Ok(*this);
 
         if (_Ok)
             {   // state okay, use facet to extract
             long _Tmp = 0;
             const _Nget& _Nget_fac = _USE(this->getloc(), _Nget);
 
             _TRY_IO_BEGIN
             _Nget_fac.get(_Iter(_Myios::rdbuf()), _Iter(0),
                 *this, _State, _Tmp);
             _CATCH_IO_END
 
             if (_State & ios_base::failbit
                 || _Tmp < SHRT_MIN || SHRT_MAX < _Tmp)
                 _State |= ios_base::failbit;
             else
                 _Val = (short)_Tmp;
             }
 
         _Myios::setstate(_State);
         return (*this);
         }

template<class _Elem, class _Traits>

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

inline

         {   // extract an unsigned short
         ios_base::iostate _State = ios_base::goodbit;
         const sentry _Ok(*this);
 
         if (_Ok)
             {   // state okay, use facet to extract
             const _Nget& _Nget_fac = _USE(this->getloc(), _Nget);
 
             _TRY_IO_BEGIN
             _Nget_fac.get(_Iter(_Myios::rdbuf()), _Iter(0),
                 *this, _State, _Val);
             _CATCH_IO_END
             }
 
         _Myios::setstate(_State);
         return (*this);
         }

template<class _Elem, class _Traits>

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

inline

         {   // extract an int
         ios_base::iostate _State = ios_base::goodbit;
         const sentry _Ok(*this);
 
         if (_Ok)
             {   // state okay, use facet to extract
             long _Tmp = 0;
             const _Nget& _Nget_fac = _USE(this->getloc(), _Nget);
 
             _TRY_IO_BEGIN
             _Nget_fac.get(_Iter(_Myios::rdbuf()), _Iter(0),
                 *this, _State, _Tmp);
             _CATCH_IO_END
 
             if (_State & ios_base::failbit
                 || _Tmp < INT_MIN || INT_MAX < _Tmp)
                 _State |= ios_base::failbit;
             else
                 _Val = _Tmp;
             }
 
         _Myios::setstate(_State);
         return (*this);
         }

template<class _Elem, class _Traits>

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

inline

         {   // extract an unsigned int
         ios_base::iostate _State = ios_base::goodbit;
         const sentry _Ok(*this);
         if (_Ok)
             {   // state okay, use facet to extract
             const _Nget& _Nget_fac = _USE(this->getloc(), _Nget);
 
             _TRY_IO_BEGIN
             _Nget_fac.get(_Iter(_Myios::rdbuf()), _Iter(0),
                 *this, _State, _Val);
             _CATCH_IO_END
             }
 
         _Myios::setstate(_State);
         return (*this);
         }

template<class _Elem, class _Traits>

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

inline

         {   // extract a long
         ios_base::iostate _State = ios_base::goodbit;
         const sentry _Ok(*this);
 
         if (_Ok)
             {   // state okay, use facet to extract
             const _Nget& _Nget_fac = _USE(this->getloc(), _Nget);
             _TRY_IO_BEGIN
             _Nget_fac.get(_Iter(_Myios::rdbuf()), _Iter(0),
                 *this, _State, _Val);
             _CATCH_IO_END
             }
 
         _Myios::setstate(_State);
         return (*this);
         }

template<class _Elem, class _Traits>

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

inline

         {   // extract an unsigned long
         ios_base::iostate _State = ios_base::goodbit;
         const sentry _Ok(*this);
 
         if (_Ok)
             {   // state okay, use facet to extract
             const _Nget& _Nget_fac = _USE(this->getloc(), _Nget);
 
             _TRY_IO_BEGIN
             _Nget_fac.get(_Iter(_Myios::rdbuf()), _Iter(0),
                 *this, _State, _Val);
             _CATCH_IO_END
             }
 
         _Myios::setstate(_State);
         return (*this);
         }

template<class _Elem, class _Traits>

_Myt& __CLR_OR_THIS_CALL basic_istream< _Elem, _Traits >::operator>> ( _LONGLONG & _Val )

inline

         {   // extract a long long
         ios_base::iostate _State = ios_base::goodbit;
         const sentry _Ok(*this);
 
         if (_Ok)
             {   // state okay, use facet to extract
             const _Nget& _Nget_fac = _USE(this->getloc(), _Nget);
 
             _TRY_IO_BEGIN
             _Nget_fac.get(_Iter(_Myios::rdbuf()), _Iter(0),
                 *this, _State, _Val);
             _CATCH_IO_END
             }
 
         _Myios::setstate(_State);
         return (*this);
         }

template<class _Elem, class _Traits>

_Myt& __CLR_OR_THIS_CALL basic_istream< _Elem, _Traits >::operator>> ( _ULONGLONG & _Val )

inline

         {   // extract an unsigned long long
         ios_base::iostate _State = ios_base::goodbit;
         const sentry _Ok(*this);
         if (_Ok)
             {   // state okay, use facet to extract
             const _Nget& _Nget_fac = _USE(this->getloc(), _Nget);
 
             _TRY_IO_BEGIN
             _Nget_fac.get(_Iter(_Myios::rdbuf()), _Iter(0),
                 *this, _State, _Val);
             _CATCH_IO_END
             }
 
         _Myios::setstate(_State);
         return (*this);
         }

template<class _Elem, class _Traits>

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

inline

         {   // extract a float
         ios_base::iostate _State = ios_base::goodbit;
         const sentry _Ok(*this);
 
         if (_Ok)
             {   // state okay, use facet to extract
             const _Nget& _Nget_fac = _USE(this->getloc(), _Nget);
 
             _TRY_IO_BEGIN
             _Nget_fac.get(_Iter(_Myios::rdbuf()), _Iter(0),
                 *this, _State, _Val);
             _CATCH_IO_END
             }
 
         _Myios::setstate(_State);
         return (*this);
         }

template<class _Elem, class _Traits>

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

inline

         {   // extract a double
         ios_base::iostate _State = ios_base::goodbit;
         const sentry _Ok(*this);
         if (_Ok)
             {   // state okay, use facet to extract
             const _Nget& _Nget_fac = _USE(this->getloc(), _Nget);
 
             _TRY_IO_BEGIN
             _Nget_fac.get(_Iter(_Myios::rdbuf()), _Iter(0),
                 *this, _State, _Val);
             _CATCH_IO_END
             }
 
         _Myios::setstate(_State);
         return (*this);
         }

template<class _Elem, class _Traits>

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

inline

         {   // extract a long double
         ios_base::iostate _State = ios_base::goodbit;
         const sentry _Ok(*this);
 
         if (_Ok)
             {   // state okay, use facet to extract
             const _Nget& _Nget_fac = _USE(this->getloc(), _Nget);
             _TRY_IO_BEGIN
             _Nget_fac.get(_Iter(_Myios::rdbuf()), _Iter(0),
                 *this, _State, _Val);
             _CATCH_IO_END
             }
 
         _Myios::setstate(_State);
         return (*this);
         }

template<class _Elem, class _Traits>

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

inline

         {   // extract a void pointer
         ios_base::iostate _State = ios_base::goodbit;
         const sentry _Ok(*this);
 
         if (_Ok)
             {   // state okay, use facet to extract
             const _Nget& _Nget_fac = _USE(this->getloc(), _Nget);
 
             _TRY_IO_BEGIN
             _Nget_fac.get(_Iter(_Myios::rdbuf()), _Iter(0),
                 *this, _State, _Val);
             _CATCH_IO_END
             }
 
         _Myios::setstate(_State);
         return (*this);
         }

template<class _Elem, class _Traits>

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

inline

         {   // extract until end-of-file into a stream buffer
         ios_base::iostate _State = ios_base::goodbit;
         bool _Copied = false;
         const sentry _Ok(*this);
 
         if (_Ok && _Strbuf != 0)
             {   // state okay, extract characters
             _TRY_IO_BEGIN
             int_type _Meta = _Myios::rdbuf()->sgetc();
 
             for (; ; _Meta = _Myios::rdbuf()->snextc())
                 if (_Traits::eq_int_type(_Traits::eof(), _Meta))
                     {   // end of file, quit
                     _State |= ios_base::eofbit;
                     break;
                     }
                 else
                     {   // got a character, insert it into buffer
                     _TRY_BEGIN
                         if (_Traits::eq_int_type(_Traits::eof(),
                             _Strbuf->sputc(_Traits::to_char_type(_Meta))))
                             break;
                     _CATCH_ALL
                         break;
                     _CATCH_END
                     _Copied = true;
                     }
             _CATCH_IO_END
             }
 
         _Myios::setstate(!_Copied ? _State | ios_base::failbit : _State);
         return (*this);
         }

template<>

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

inline

     {   // extract a character
     return (_STD operator>>(*this, _Ch));
     }

template<class _Elem, class _Traits>

int_type __CLR_OR_THIS_CALL basic_istream< _Elem, _Traits >::peek ( )

inline

         {   // return next character, unconsumed
         ios_base::iostate _State = ios_base::goodbit;
         _Chcount = 0;
         int_type _Meta = 0;
         const sentry _Ok(*this, true);
 
         if (!_Ok)
             _Meta = _Traits::eof(); // state not okay, return EOF
         else
             {   // state okay, read a character
             _TRY_IO_BEGIN
             if (_Traits::eq_int_type(_Traits::eof(),
                 _Meta = _Myios::rdbuf()->sgetc()))
                 _State |= ios_base::eofbit;
             _CATCH_IO_END
             }
 
         _Myios::setstate(_State);
         return (_Meta);
         }

template<class _Elem, class _Traits>

_Myt& __CLR_OR_THIS_CALL basic_istream< _Elem, _Traits >::putback ( _Elem _Ch )

inline

         {   // put back a character
         _Chcount = 0;
         ios_base::iostate _State = ios_base::goodbit;
         ios_base::iostate _Oldstate = _Myios::rdstate();
         _Myios::clear(_Oldstate & ~ios_base::eofbit);
         const sentry _Ok(*this, true);
 
         if (_Ok)
             {   // state okay, put character back
             _TRY_IO_BEGIN
             if (_Traits::eq_int_type(_Traits::eof(),
                 _Myios::rdbuf()->sputbackc(_Ch)))
                 _State |= ios_base::badbit | _Oldstate;
             _CATCH_IO_END
             }
 
         _Myios::setstate(_State);
         return (*this);
         }

template<class _Elem, class _Traits>

_Myt& __CLR_OR_THIS_CALL basic_istream< _Elem, _Traits >::read	(	_Elem *	_Str,
		streamsize	_Count
	)

inline

         {   // read up to _Count characters into buffer
         ios_base::iostate _State = ios_base::goodbit;
         _Chcount = 0;
         const sentry _Ok(*this, true);
 
         if (_Ok && 0 < _Count)
             {   // state okay, use facet to extract
             _TRY_IO_BEGIN
             _DEBUG_POINTER(_Str);
             const streamsize _Num = _Myios::rdbuf()->sgetn(_Str, _Count);
             _Chcount += _Num;
             if (_Num != _Count)
                 _State |= ios_base::eofbit | ios_base::failbit; // short read
             _CATCH_IO_END
             }
 
         _Myios::setstate(_State);
         return (*this);
         }

template<class _Elem, class _Traits>

streamsize __CLR_OR_THIS_CALL basic_istream< _Elem, _Traits >::readsome	(	_Elem *	_Str,
		streamsize	_Count
	)

inline

         {   // read up to _Count characters into buffer, without blocking
         ios_base::iostate _State = ios_base::goodbit;
         _Chcount = 0;
         const sentry _Ok(*this, true);
         streamsize _Num;
 
         if (!_Ok)
             _State |= ios_base::failbit;    // no buffer, fail
         else if ((_Num = _Myios::rdbuf()->in_avail()) < 0)
             _State |= ios_base::eofbit; // no characters available
         else if (0 < _Count && 0 < _Num)
             {   // validate _Str and read
             _DEBUG_POINTER(_Str);
             read(_Str, _Num < _Count ? _Num : _Count);  // read available
             }
 
         _Myios::setstate(_State);
         return (gcount());
         }

template<class _Elem, class _Traits>

_Myt& __CLR_OR_THIS_CALL basic_istream< _Elem, _Traits >::seekg ( pos_type _Pos )

inline

         {   // 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);
 
         if (!this->fail()
             && (off_type)_Myios::rdbuf()->pubseekpos(_Pos,
                 ios_base::in) == _BADOFF)
             _Myios::setstate(_State | ios_base::failbit);
         return (*this);
         }

template<class _Elem, class _Traits>

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

inline

         {   // 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);
 
         if (!this->fail()
             && (off_type)_Myios::rdbuf()->pubseekoff(_Off, _Way,
                 ios_base::in) == _BADOFF)
             _Myios::setstate(_State | ios_base::failbit);
         return (*this);
         }

template<class _Elem, class _Traits>

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

inlineprotected

         {   // swap with _Right
         _Myios::swap(_Right);
         _STD swap(_Chcount, _Right._Chcount);
         }

template<class _Elem, class _Traits>

int __CLR_OR_THIS_CALL basic_istream< _Elem, _Traits >::sync ( )

inline

         {   // synchronize with input source
         const sentry _Ok(*this, true);
 
         if (_Myios::rdbuf() == 0)
             return (-1);
         else if (_Myios::rdbuf()->pubsync() == -1)
             {   // sync failed
             _Myios::setstate(ios_base::badbit);
             return (-1);
             }
         else
             return (0);
         }

template<class _Elem, class _Traits>

pos_type __CLR_OR_THIS_CALL basic_istream< _Elem, _Traits >::tellg ( )

inline

         {   // return input stream position
         const sentry _Ok(*this, true);
 
         if (!this->fail())
             return (_Myios::rdbuf()->pubseekoff(0,
                 ios_base::cur, ios_base::in));
         else
             return (pos_type(_BADOFF));
         }

template<class _Elem, class _Traits>

_Myt& __CLR_OR_THIS_CALL basic_istream< _Elem, _Traits >::unget ( )

inline

         {   // put back last read character
         _Chcount = 0;
         ios_base::iostate _State = ios_base::goodbit;
         ios_base::iostate _Oldstate = _Myios::rdstate();
         _Myios::clear(_Oldstate & ~ios_base::eofbit);
         const sentry _Ok(*this, true);
 
         if (_Ok)
             {   // state okay, put character back
             _TRY_IO_BEGIN
             if (_Traits::eq_int_type(_Traits::eof(),
                 _Myios::rdbuf()->sungetc()))
                 _State |= ios_base::badbit | _Oldstate;
             _CATCH_IO_END
             }
 
         _Myios::setstate(_State);
         return (*this);
         }

Member Data Documentation

template<class _Elem, class _Traits>

streamsize basic_istream< _Elem, _Traits >::_Chcount

private

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

VS2015/inc/iosfwd
VS2015/inc/istream

Classes

Public Types

Public Member Functions

Protected Member Functions

Private Attributes

Additional Inherited Members

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation