ios_base Class Reference

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

        {   // constants for ios events
        erase_event, imbue_event, copyfmt_event};

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

        {   // default constructor
        }

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 != _STD addressof(_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 != _STD addressof(_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:

• VS2017/inc/xiosbase