Inheritance diagram for ios_base:

Classes
struct	_Fnarray

struct	_Iosarray

class	failure

class	Init

Public Types
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
	_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

Static Public Member Functions
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
size_t	_Stdstr

Protected Member Functions
__CLR_OR_THIS_CALL	ios_base ()

void __CLR_OR_THIS_CALL	_Init ()

Private Member Functions
void __CLR_OR_THIS_CALL	_Callfns (event _Ev)

_Iosarray &__CLR_OR_THIS_CALL	_Findarr (int _Idx)

void __CLR_OR_THIS_CALL	_Tidy ()

Static Private Member Functions
static _MRTIMP2_PURE_NPURE void __CLRCALL_PURE_OR_CDECL	_Ios_base_dtor (ios_base *)

Private Attributes
iostate	_Mystate

iostate	_Except

fmtflags	_Fmtfl

streamsize	_Prec

streamsize	_Wide

_Iosarray *	_Arr

_Fnarray *	_Calls

locale *	_Ploc

Static Private Attributes
static __PURE_APPDOMAIN_GLOBAL int	_Index

static __PURE_APPDOMAIN_GLOBAL bool	_Sync

Additional Inherited Members
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

typedef void(__CLRCALL_OR_CDECL * ios_base::event_callback) (event, ios_base &, int)

Member Enumeration Documentation

enum ios_base::event

Enumerator
erase_event
imbue_event
copyfmt_event

214 { // constants for ios events

215 erase_event, imbue_event, copyfmt_event};

ios_base::erase_event

Definition: xiosbase:215

ios_base::imbue_event

Definition: xiosbase:215

ios_base::copyfmt_event

Definition: xiosbase:215

Constructor & Destructor Documentation

virtual __CLR_OR_THIS_CALL ios_base::~ios_base ( )

inlinevirtual

         {   // destroy the object
         _Ios_base_dtor(this);
         }

__CLR_OR_THIS_CALL ios_base::ios_base ( )

inlineprotected

534 { // default constructor

535 }

ios_base::ios_base ( const ios_base & )

delete

Member Function Documentation

static _MRTIMP2_PURE_NPURE void __CLRCALL_PURE_OR_CDECL ios_base::_Addstd ( ios_base * )

static

void __CLR_OR_THIS_CALL ios_base::_Callfns ( event _Ev )

inlineprivate

         {   // call all event handlers, reporting event
         for (_Fnarray *_Pfa = _Calls; _Pfa != 0; _Pfa = _Pfa->_Next)
             (*_Pfa->_Pfn)(_Ev, *this, _Pfa->_Index);
         }

_Iosarray& __CLR_OR_THIS_CALL ios_base::_Findarr ( int _Idx )

inlineprivate

         {   // locate or make a variable array element
         _Iosarray *_Ptr1, *_Ptr2;
 
         for (_Ptr1 = _Arr, _Ptr2 = 0; _Ptr1 != 0; _Ptr1 = _Ptr1->_Next)
             if (_Ptr1->_Index == _Idx)
                 return (*_Ptr1);    // found element, return it
             else if (_Ptr2 == 0 && _Ptr1->_Lo == 0 && _Ptr1->_Vp == 0)
                 _Ptr2 = _Ptr1;  // found recycling candidate
 
         if (_Ptr2 != 0)
             {   // recycle existing element
             _Ptr2->_Index = _Idx;
             return (*_Ptr2);
             }
 
         _Arr = new _Iosarray(_Idx, _Arr);   // make a new element
         return (*_Arr);
         }

void __CLR_OR_THIS_CALL ios_base::_Init ( )

inlineprotected

         {   // initialize a new ios_base
         _Ploc = 0;
         _Stdstr = 0;
         _Except = goodbit;
         _Fmtfl = (fmtflags)(skipws | dec);
         _Prec = 6;
         _Wide = 0;
         _Arr = 0;
         _Calls = 0;
         clear(goodbit);
         _Ploc = new locale;
         }

static _MRTIMP2_PURE_NPURE void __CLRCALL_PURE_OR_CDECL ios_base::_Ios_base_dtor ( ios_base * )

staticprivate

ios_base::_IOS_BITMASK	(	_Fmtflags	,
		fmtflags
	)

ios_base::_IOS_BITMASK	(	_Iostate	,
		iostate
	)

ios_base::_IOS_BITMASK	(	_Openmode	,
		openmode
	)

ios_base::_IOS_BITMASK	(	_Seekdir	,
		seekdir
	)

void __CLR_OR_THIS_CALL ios_base::_Tidy ( )

inlineprivate

         {   // discard storage for an ios_base
         _Callfns(erase_event);
         _Iosarray *_Ptr1, *_Ptr2;
 
         for (_Ptr1 = _Arr; _Ptr1 != 0; _Ptr1 = _Ptr2)
             {   // delete array element
             _Ptr2 = _Ptr1->_Next;
             delete _Ptr1;
             }
         _Arr = 0;
 
         _Fnarray *_Pfa1, *_Pfa2;
         for (_Pfa1 = _Calls; _Pfa1 != 0; _Pfa1 = _Pfa2)
             {   // delete callback element
             _Pfa2 = _Pfa1->_Next;
             delete _Pfa1;
             }
         _Calls = 0;
         }

bool __CLR_OR_THIS_CALL ios_base::bad ( ) const

inline

         {   // test if badbit is set in stream state
         return (((int)rdstate() & (int)badbit) != 0);
         }

void __CLR_OR_THIS_CALL ios_base::clear	(	iostate	_State,
		bool	_Reraise
	)

inline

         {   // set state, possibly reraise exception
         _Mystate = (iostate)(_State & _Statmask);
         if ((_Mystate & _Except) == 0)
             ;
         else if (_Reraise)
             _RERAISE;
         else if (_Mystate & _Except & badbit)
             _THROW_NCEE(failure, "ios_base::badbit set");
         else if (_Mystate & _Except & failbit)
             _THROW_NCEE(failure, "ios_base::failbit set");
         else
             _THROW_NCEE(failure, "ios_base::eofbit set");
         }

void __CLR_OR_THIS_CALL ios_base::clear ( iostate _State = goodbit )

inline

         {   // set state to argument
         clear(_State, false);
         }

ios_base& __CLR_OR_THIS_CALL ios_base::copyfmt ( const ios_base & _Other )

inline

         {   // copy format stuff
         if (this != &_Other)
             {   // copy all but _Mystate
             _Tidy();
             *_Ploc = *_Other._Ploc;
             _Fmtfl = _Other._Fmtfl;
             _Prec = _Other._Prec;
             _Wide = _Other._Wide;
             _Iosarray *_Ptr = _Other._Arr;
 
             for (_Arr = 0; _Ptr != 0; _Ptr = _Ptr->_Next)
                 if (_Ptr->_Lo != 0 || _Ptr->_Vp != 0)
                     {   // copy over nonzero array values
                     iword(_Ptr->_Index) = _Ptr->_Lo;
                     pword(_Ptr->_Index) = _Ptr->_Vp;
                     }
 
             for (_Fnarray *_Pfa = _Other._Calls; _Pfa != 0;
                 _Pfa = _Pfa->_Next)
                 register_callback(_Pfa->_Pfn, _Pfa->_Index);
 
             _Callfns(copyfmt_event);    // call callbacks
             exceptions(_Other._Except); // cause any throw at end
             }
         return (*this);
         }

bool __CLR_OR_THIS_CALL ios_base::eof ( ) const

inline

         {   // test if eofbit is set in stream state
         return ((int)rdstate() & (int)eofbit);
         }

iostate __CLR_OR_THIS_CALL ios_base::exceptions ( ) const

inline

         {   // return exception mask
         return (_Except);
         }

void __CLR_OR_THIS_CALL ios_base::exceptions ( iostate _Newexcept )

inline

         {   // set exception mask to argument
         _Except = (iostate)((int)_Newexcept & (int)_Statmask);
         clear(_Mystate);
         }

bool __CLR_OR_THIS_CALL ios_base::fail ( ) const

inline

         {   // test if badbit or failbit is set in stream state
         return (((int)rdstate()
             & ((int)badbit | (int)failbit)) != 0);
         }

fmtflags __CLR_OR_THIS_CALL ios_base::flags ( ) const

inline

         {   // return format flags
         return (_Fmtfl);
         }

fmtflags __CLR_OR_THIS_CALL ios_base::flags ( fmtflags _Newfmtflags )

inline

         {   // set format flags to argument
         fmtflags _Oldfmtflags = _Fmtfl;
         _Fmtfl = (fmtflags)((int)_Newfmtflags & (int)_Fmtmask);
         return (_Oldfmtflags);
         }

locale __CLR_OR_THIS_CALL ios_base::getloc ( ) const

inline

         {   // get locale
         return (*_Ploc);
         }

bool __CLR_OR_THIS_CALL ios_base::good ( ) const

inline

         {   // test if no state bits are set
         return (rdstate() == goodbit);
         }

locale __CLR_OR_THIS_CALL ios_base::imbue ( const locale & _Loc )

inline

         {   // set locale to argument
         locale _Oldlocale = *_Ploc;
         *_Ploc = _Loc;
         _Callfns(imbue_event);
         return (_Oldlocale);
         }

long& __CLR_OR_THIS_CALL ios_base::iword ( int _Idx )

inline

         {   // return reference to long element
         return (_Findarr(_Idx)._Lo);
         }

__CLR_OR_THIS_CALL ios_base::operator bool ( ) const

inlineexplicit

         {   // test if no stream operation has failed
         return (!fail());
         }

bool __CLR_OR_THIS_CALL ios_base::operator! ( ) const

inline

         {   // test if any stream operation has failed
         return (fail());
         }

ios_base& ios_base::operator= ( const ios_base & )

delete

streamsize __CLR_OR_THIS_CALL ios_base::precision ( ) const

inline

         {   // return precision
         return (_Prec);
         }

streamsize __CLR_OR_THIS_CALL ios_base::precision ( streamsize _Newprecision )

inline

         {   // set precision to argument
         streamsize _Oldprecision = _Prec;
         _Prec = _Newprecision;
         return (_Oldprecision);
         }

void*& __CLR_OR_THIS_CALL ios_base::pword ( int _Idx )

inline

         {   // return reference to pointer element
         return (_Findarr(_Idx)._Vp);
         }

iostate __CLR_OR_THIS_CALL ios_base::rdstate ( ) const

inline

         {   // return stream state
         return (_Mystate);
         }

void __CLR_OR_THIS_CALL ios_base::register_callback	(	event_callback	_Pfn,
		int	_Idx
	)

inline

         {   // register event handler
         _Calls = new _Fnarray(_Idx, _Pfn, _Calls);
         }

fmtflags __CLR_OR_THIS_CALL ios_base::setf ( fmtflags _Newfmtflags )

inline

         {   // merge in format flags argument
         ios_base::fmtflags _Oldfmtflags = _Fmtfl;
         _Fmtfl = (fmtflags)((int)_Fmtfl
             | ((int)_Newfmtflags & (int)_Fmtmask));
         return (_Oldfmtflags);
         }

fmtflags __CLR_OR_THIS_CALL ios_base::setf	(	fmtflags	_Newfmtflags,
		fmtflags	_Mask
	)

inline

         {   // merge in format flags argument under mask argument
         ios_base::fmtflags _Oldfmtflags = _Fmtfl;
         _Fmtfl = (fmtflags)(((int)_Fmtfl & (int)~_Mask)
             | ((int)_Newfmtflags & (int)_Mask & (int)_Fmtmask));
         return (_Oldfmtflags);
         }

void __CLR_OR_THIS_CALL ios_base::setstate	(	iostate	_State,
		bool	_Exreraise
	)

inline

         {   // merge in state argument, possibly reraise exception
         if (_State != goodbit)
             clear((iostate)((int)rdstate() | (int)_State), _Exreraise);
         }

void __CLR_OR_THIS_CALL ios_base::setstate ( iostate _State )

inline

         {   // merge in state argument
         if (_State != goodbit)
             clear((iostate)((int)rdstate() | (int)_State), false);
         }

void __CLR_OR_THIS_CALL ios_base::swap ( ios_base & _Right )

inline

         {   // swap with _Right
         if (this != &_Right)
             {   // different, do the move
             _STD swap(_Mystate, _Right._Mystate);
             _STD swap(_Except, _Right._Except);
             _STD swap(_Fmtfl, _Right._Fmtfl);
             _STD swap(_Prec, _Right._Prec);
             _STD swap(_Wide, _Right._Wide);
 
             _STD swap(_Arr, _Right._Arr);
             _STD swap(_Calls, _Right._Calls);
             _STD swap(_Ploc, _Right._Ploc);
             }
         }

static bool __CLRCALL_OR_CDECL ios_base::sync_with_stdio ( bool _Newsync = true )

inlinestatic

         {   // set C/C++ synchronization flag from argument
         _BEGIN_LOCK(_LOCK_STREAM)   // lock thread to ensure atomicity
             const bool _Oldsync = _Sync;
             _Sync = _Newsync;
             return (_Oldsync);
         _END_LOCK()
         }

void __CLR_OR_THIS_CALL ios_base::unsetf ( fmtflags _Mask )

inline

         {   // clear format flags under mask argument
         _Fmtfl = (fmtflags)((int)_Fmtfl & (int)~_Mask);
         }

streamsize __CLR_OR_THIS_CALL ios_base::width ( ) const

inline

         {   // return width
         return (_Wide);
         }

streamsize __CLR_OR_THIS_CALL ios_base::width ( streamsize _Newwidth )

inline

         {   // set width to argument
         streamsize _Oldwidth = _Wide;
         _Wide = _Newwidth;
         return (_Oldwidth);
         }

static int __CLRCALL_OR_CDECL ios_base::xalloc ( )

inlinestatic

         {   // allocate new iword/pword index
         _BEGIN_LOCK(_LOCK_STREAM)   // lock thread to ensure atomicity
             return (_Index++);
         _END_LOCK()
         }

Member Data Documentation

_Iosarray* ios_base::_Arr

private

_Fnarray* ios_base::_Calls

private

iostate ios_base::_Except

private

fmtflags ios_base::_Fmtfl

private

__PURE_APPDOMAIN_GLOBAL int ios_base::_Index

staticprivate

iostate ios_base::_Mystate

private

locale* ios_base::_Ploc

private

streamsize ios_base::_Prec

private

size_t ios_base::_Stdstr

__PURE_APPDOMAIN_GLOBAL bool ios_base::_Sync

staticprivate

streamsize ios_base::_Wide

private

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

VS2015/inc/xiosbase

Classes

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Protected Member Functions

Private Member Functions

Static Private Member Functions

Private Attributes

Static Private Attributes

Additional Inherited Members

Member Typedef Documentation

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation