Inheritance diagram for basic_filebuf< _Elem, _Traits >:

Public Types
enum	_Initfl { _Newfl, _Openfl, _Closefl }

typedef basic_filebuf< _Elem, _Traits >	_Myt

typedef basic_streambuf< _Elem, _Traits >	_Mysb

typedef _Traits::state_type	_Myst

typedef codecvt< _Elem, char, typename _Traits::state_type >	_Cvt

typedef _Traits::int_type	int_type

typedef _Traits::pos_type	pos_type

typedef _Traits::off_type	off_type

Public Types inherited from basic_streambuf< _Elem, _Traits >
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 Member Functions
	basic_filebuf (_Filet *_File=0)

virtual __CLR_OR_THIS_CALL	~basic_filebuf () _NOEXCEPT

	basic_filebuf (_Uninitialized)

	basic_filebuf (_Myt &&_Right)

_Myt &	operator= (_Myt &&_Right)

void	_Assign_rv (_Myt &&_Right)

void	swap (_Myt &_Right)

	basic_filebuf (const _Myt &)=delete

_Myt &	operator= (const _Myt &)=delete

bool	is_open () const

_Myt *	open (const char *_Filename, ios_base::openmode _Mode, int _Prot=(int) ios_base::_Openprot)

_Myt *	open (const string &_Str, ios_base::openmode _Mode, int _Prot=(int) ios_base::_Openprot)

_Myt *	open (const char *_Filename, ios_base::open_mode _Mode)

_Myt *	open (const wchar_t *_Filename, ios_base::openmode _Mode, int _Prot=(int) ios_base::_Openprot)

_Myt *	open (const wstring &_Str, ios_base::openmode _Mode, int _Prot=(int) ios_base::_Openprot)

_Myt *	open (const wchar_t *_Filename, ios_base::open_mode _Mode)

_Myt *	close ()

virtual void __CLR_OR_THIS_CALL	_Lock ()

virtual void __CLR_OR_THIS_CALL	_Unlock ()

Public Member Functions inherited from basic_streambuf< _Elem, _Traits >
virtual __CLR_OR_THIS_CALL	~basic_streambuf () _NOEXCEPT

pos_type __CLR_OR_THIS_CALL	pubseekoff (off_type _Off, ios_base::seekdir _Way, ios_base::openmode _Mode=ios_base::in\|ios_base::out)

pos_type __CLR_OR_THIS_CALL	pubseekoff (off_type _Off, ios_base::seek_dir _Way, ios_base::open_mode _Mode)

pos_type __CLR_OR_THIS_CALL	pubseekpos (pos_type _Pos, ios_base::openmode _Mode=ios_base::in\|ios_base::out)

pos_type __CLR_OR_THIS_CALL	pubseekpos (pos_type _Pos, ios_base::open_mode _Mode)

_Myt *__CLR_OR_THIS_CALL	pubsetbuf (_Elem *_Buffer, streamsize _Count)

locale __CLR_OR_THIS_CALL	pubimbue (const locale &_Newlocale)

locale __CLR_OR_THIS_CALL	getloc () const

streamsize __CLR_OR_THIS_CALL	in_avail ()

int __CLR_OR_THIS_CALL	pubsync ()

int_type __CLR_OR_THIS_CALL	sbumpc ()

int_type __CLR_OR_THIS_CALL	sgetc ()

streamsize __CLR_OR_THIS_CALL	sgetn (_Elem *_Ptr, streamsize _Count)

int_type __CLR_OR_THIS_CALL	snextc ()

int_type __CLR_OR_THIS_CALL	sputbackc (_Elem _Ch)

void __CLR_OR_THIS_CALL	stossc ()

int_type __CLR_OR_THIS_CALL	sungetc ()

int_type __CLR_OR_THIS_CALL	sputc (_Elem _Ch)

streamsize __CLR_OR_THIS_CALL	sputn (const _Elem *_Ptr, streamsize _Count)

Protected Member Functions
virtual int_type __CLR_OR_THIS_CALL	overflow (int_type _Meta=_Traits::eof())

virtual int_type __CLR_OR_THIS_CALL	pbackfail (int_type _Meta=_Traits::eof())

virtual int_type __CLR_OR_THIS_CALL	underflow ()

virtual int_type __CLR_OR_THIS_CALL	uflow ()

virtual pos_type __CLR_OR_THIS_CALL	seekoff (off_type _Off, ios_base::seekdir _Way, ios_base::openmode=(ios_base::openmode)(ios_base::in\|ios_base::out))

virtual pos_type __CLR_OR_THIS_CALL	seekpos (pos_type _Pos, ios_base::openmode=(ios_base::openmode)(ios_base::in\|ios_base::out))

virtual _Mysb *__CLR_OR_THIS_CALL	setbuf (_Elem *_Buffer, streamsize _Count)

virtual int __CLR_OR_THIS_CALL	sync ()

virtual void __CLR_OR_THIS_CALL	imbue (const locale &_Loc)

void	_Init (_Filet *_File, _Initfl _Which)

bool	_Endwrite ()

void	_Initcvt (const _Cvt *_Newpcvt)

Protected Member Functions inherited from basic_streambuf< _Elem, _Traits >
__CLR_OR_THIS_CALL	basic_streambuf ()

__CLR_OR_THIS_CALL	basic_streambuf (_Uninitialized)

__CLR_OR_THIS_CALL	basic_streambuf (const _Myt &_Right)

_Myt &__CLR_OR_THIS_CALL	operator= (const _Myt &_Right)

void __CLR_OR_THIS_CALL	swap (_Myt &_Right)

_Elem *__CLR_OR_THIS_CALL	eback () const

_Elem *__CLR_OR_THIS_CALL	gptr () const

_Elem *__CLR_OR_THIS_CALL	pbase () const

_Elem *__CLR_OR_THIS_CALL	pptr () const

_Elem *__CLR_OR_THIS_CALL	egptr () const

void __CLR_OR_THIS_CALL	gbump (int _Off)

void __CLR_OR_THIS_CALL	setg (_Elem _First, _Elem _Next, _Elem *_Last)

_Elem *__CLR_OR_THIS_CALL	epptr () const

_Elem *__CLR_OR_THIS_CALL	_Gndec ()

_Elem *__CLR_OR_THIS_CALL	_Gninc ()

_Elem *__CLR_OR_THIS_CALL	_Gnpreinc ()

streamsize __CLR_OR_THIS_CALL	_Gnavail () const

void __CLR_OR_THIS_CALL	pbump (int _Off)

void __CLR_OR_THIS_CALL	setp (_Elem _First, _Elem _Last)

void __CLR_OR_THIS_CALL	setp (_Elem _First, _Elem _Next, _Elem *_Last)

_Elem *__CLR_OR_THIS_CALL	_Pninc ()

streamsize __CLR_OR_THIS_CALL	_Pnavail () const

void __CLR_OR_THIS_CALL	_Init ()

void __CLR_OR_THIS_CALL	_Init (_Elem _Gf, _Elem _Gn, int _Gc, _Elem _Pf, _Elem _Pn, int _Pc)

virtual streamsize __CLR_OR_THIS_CALL	showmanyc ()

virtual streamsize __CLR_OR_THIS_CALL	xsgetn (_Elem *_Ptr, streamsize _Count)

virtual streamsize __CLR_OR_THIS_CALL	xsputn (const _Elem *_Ptr, streamsize _Count)

Private Member Functions
void	_Reset_back ()

void	_Set_back ()

Private Attributes
_Elem *	_Set_eback

_Elem *	_Set_egptr

const _Cvt *	_Pcvt

_Elem	_Mychar

bool	_Wrotesome

_Traits::state_type	_State

bool	_Closef

_Filet *	_Myfile

Additional Inherited Members
Protected Attributes inherited from basic_streambuf< _Elem, _Traits >
locale *	_Plocale

Member Typedef Documentation

template<class _Elem, class _Traits>

typedef codecvt<_Elem, char, typename _Traits::state_type> basic_filebuf< _Elem, _Traits >::_Cvt

template<class _Elem, class _Traits>

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

template<class _Elem, class _Traits>

typedef _Traits::state_type basic_filebuf< _Elem, _Traits >::_Myst

template<class _Elem, class _Traits>

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

template<class _Elem, class _Traits>

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

template<class _Elem, class _Traits>

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

template<class _Elem, class _Traits>

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

Member Enumeration Documentation

template<class _Elem, class _Traits>

enum basic_filebuf::_Initfl

Enumerator
_Newfl
_Openfl
_Closefl

254 { // reasons for a call to _Init

255 _Newfl, _Openfl, _Closefl};

basic_filebuf::_Newfl

Definition: fstream:255

basic_filebuf::_Closefl

Definition: fstream:255

basic_filebuf::_Openfl

Definition: fstream:255

Constructor & Destructor Documentation

template<class _Elem, class _Traits>

basic_filebuf< _Elem, _Traits >::basic_filebuf ( _Filet * _File = 0 )

inline

         : _Mysb()
         {   // construct from pointer to C stream
         _Init(_File, _Newfl);
         }

template<class _Elem, class _Traits>

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

inlinevirtual

         {   // destroy the object
         if (_Myfile != 0)
             _Reset_back();  // revert from _Mychar buffer
         if (_Closef)
             close();
         }

template<class _Elem, class _Traits>

basic_filebuf< _Elem, _Traits >::basic_filebuf ( _Uninitialized )

inline

         : _Mysb(_Noinit)
         {   // construct uninitialized
         }

template<class _Elem, class _Traits>

basic_filebuf< _Elem, _Traits >::basic_filebuf ( _Myt && _Right )

inline

         {   // construct by copying _Right
         _Init(_Right._Myfile, _Newfl);  // match buffering styles
         _Init((_Filet *)0, _Closefl);   // then make *this look closed
         _Assign_rv(_STD forward<_Myt>(_Right));
         }

template<class _Elem, class _Traits>

basic_filebuf< _Elem, _Traits >::basic_filebuf ( const _Myt & )

delete

Member Function Documentation

template<class _Elem, class _Traits>

void basic_filebuf< _Elem, _Traits >::_Assign_rv ( _Myt && _Right )

inline

         {   // assign by moving _Right
         if (this != &_Right)
             {   // different, worth moving
             close();
             this->swap(_Right);
             }
         }

template<class _Elem, class _Traits>

bool basic_filebuf< _Elem, _Traits >::_Endwrite ( )

inlineprotected

         {   // put shift to initial conversion state, as needed
         if (_Pcvt == 0 || !_Wrotesome)
             return (true);
         else
             {   // may have to put
             const int _STRING_INC = 8;
             char *_Dest;
             if (_Traits::eq_int_type(_Traits::eof(), overflow()))
                 return (false);
 
             string _Str(_STRING_INC, '\0');
             for (; ; )
                 switch (_Pcvt->unshift(_State,
                     &*_Str.begin(), &*_Str.begin() + _Str.size(), _Dest))
                 {   // test result of homing conversion
                 case codecvt_base::ok:
                     _Wrotesome = false; // homed successfully
 
                 case codecvt_base::partial: // fall through
                     {   // put any generated bytes
                     size_t _Count = _Dest - &*_Str.begin();
                     if (0 < _Count && _Count !=
                         fwrite(&*_Str.begin(), 1, _Count, _Myfile))
                         return (false); // write failed
                     if (!_Wrotesome)
                         return (true);
                     if (_Count == 0)
                         _Str.append(_STRING_INC, '\0'); // try with more space
                     break;
                     }
 
                 case codecvt_base::noconv:
                     return (true);  // nothing to do
 
                 default:
                     return (false); // conversion failed
                 }
             }
         }

template<class _Elem, class _Traits>

void basic_filebuf< _Elem, _Traits >::_Init	(	_Filet *	_File,
		_Initfl	_Which
	)

inlineprotected

         {   // initialize to C stream _File after {new, open, close}
         __PURE_APPDOMAIN_GLOBAL static _Myst _Stinit;   // initial state
 
         _Closef = _Which == _Openfl;
         _Wrotesome = false;
 
         _Mysb::_Init(); // initialize stream buffer base object
 
  #ifndef _IORCNT
   #define _IORCNT   _IOCNT  /* read and write counts are the same */
   #define _IOWCNT _IOCNT
  #endif /* _IORCNT */
 
   #pragma warning(push)
   #pragma warning(disable: 6240)    /* prefast noise VSW 489858 */
         if (_File != 0 && sizeof (_Elem) == 1)
   #pragma warning(pop)
 
             {   // point inside C stream with [first, first + count) buffer
             _Elem **_Pb = (_Elem **)&_File->_IOBASE;
             _Elem **_Pn = (_Elem **)&_File->_IOPTR;
             int *_Nr = (int *)&_File->_IORCNT;
             int *_Nw = (int *)&_File->_IOWCNT;
             _Mysb::_Init(_Pb, _Pn, _Nr, _Pb, _Pn, _Nw);
             }
 
         _Myfile = _File;
         _State = _Stinit;
         _Pcvt = 0;  // pointer to codecvt facet
         }

template<class _Elem, class _Traits>

void basic_filebuf< _Elem, _Traits >::_Initcvt ( const _Cvt * _Newpcvt )

inlineprotected

         {   // initialize codecvt pointer
         if (_Newpcvt->always_noconv())
             _Pcvt = 0;  // nothing to do
         else
             {   // set up for nontrivial codecvt facet
             _Pcvt = _Newpcvt;
             _Mysb::_Init(); // reset any buffering
             }
         }

template<class _Elem, class _Traits>

virtual void __CLR_OR_THIS_CALL basic_filebuf< _Elem, _Traits >::_Lock ( )

inlinevirtual

Reimplemented from basic_streambuf< _Elem, _Traits >.

         {   // lock file instead of stream buffer
         if (_Myfile)
             _CSTD _lock_file(_Myfile);
         }

template<class _Elem, class _Traits>

void basic_filebuf< _Elem, _Traits >::_Reset_back ( )

inlineprivate

         {   // restore buffer after putback
         if (_Mysb::eback() == &_Mychar)
             _Mysb::setg(_Set_eback, _Set_eback, _Set_egptr);
         }

template<class _Elem, class _Traits>

void basic_filebuf< _Elem, _Traits >::_Set_back ( )

inlineprivate

         {   // set up putback area
         if (_Mysb::eback() != &_Mychar)
             {   // save current get buffer
             _Set_eback = _Mysb::eback();
             _Set_egptr = _Mysb::egptr();
             }
         _Mysb::setg(&_Mychar, &_Mychar, &_Mychar + 1);
         }

template<class _Elem, class _Traits>

virtual void __CLR_OR_THIS_CALL basic_filebuf< _Elem, _Traits >::_Unlock ( )

inlinevirtual

Reimplemented from basic_streambuf< _Elem, _Traits >.

         {   // unlock file instead of stream buffer
         if (_Myfile)
             _CSTD _unlock_file(_Myfile);
         }

template<class _Elem, class _Traits>

_Myt* basic_filebuf< _Elem, _Traits >::close ( )

inline

         {   // close the C stream
         _Myt *_Ans = this;
         if (_Myfile == 0)
             _Ans = 0;
         else
             {   // put any homing sequence and close file
             if (!_Endwrite())
                 _Ans = 0;
             if (fclose(_Myfile) != 0)
                 _Ans = 0;
             }
         _Init(0, _Closefl);
         return (_Ans);
         }

template<class _Elem, class _Traits>

virtual void __CLR_OR_THIS_CALL basic_filebuf< _Elem, _Traits >::imbue ( const locale & _Loc )

inlineprotectedvirtual

Reimplemented from basic_streambuf< _Elem, _Traits >.

         {   // set locale to argument (capture nontrivial codecvt facet)
         _Initcvt(&_USE(_Loc, _Cvt));
         }

template<class _Elem, class _Traits>

bool basic_filebuf< _Elem, _Traits >::is_open ( ) const

inline

         {   // test if C stream has been opened
         return (_Myfile != 0);
         }

template<class _Elem, class _Traits>

_Myt* basic_filebuf< _Elem, _Traits >::open	(	const char *	_Filename,
		ios_base::openmode	_Mode,
		int	_Prot = `(int)ios_base::_Openprot`
	)

inline

         {   // open a C stream with specified mode
         _Filet *_File;
         if (_Myfile != 0 || (_File = _Fiopen(_Filename, _Mode, _Prot)) == 0)
             return (0); // open failed
 
         _Init(_File, _Openfl);
         _Initcvt(&_USE(_Mysb::getloc(), _Cvt));
         return (this);  // open succeeded
         }

template<class _Elem, class _Traits>

_Myt* basic_filebuf< _Elem, _Traits >::open	(	const string &	_Str,
		ios_base::openmode	_Mode,
		int	_Prot = `(int)ios_base::_Openprot`
	)

inline

         {   // open a C stream with specified mode
         return (open(_Str.c_str(), _Mode, _Prot));
         }

template<class _Elem, class _Traits>

_Myt* basic_filebuf< _Elem, _Traits >::open	(	const char *	_Filename,
		ios_base::open_mode	_Mode
	)

inline

         {   // open a C stream with specified mode (old style)
         return (open(_Filename, (ios_base::openmode)_Mode));
         }

template<class _Elem, class _Traits>

_Myt* basic_filebuf< _Elem, _Traits >::open	(	const wchar_t *	_Filename,
		ios_base::openmode	_Mode,
		int	_Prot = `(int)ios_base::_Openprot`
	)

inline

         {   // open a wide-named C stream -- EXTENSION
         _Filet *_File;
         if (_Myfile != 0 || (_File = _Fiopen(_Filename, _Mode, _Prot)) == 0)
             return (0); // open failed
 
         _Init(_File, _Openfl);
         _Initcvt(&_USE(_Mysb::getloc(), _Cvt));
         return (this);  // open succeeded
         }

template<class _Elem, class _Traits>

_Myt* basic_filebuf< _Elem, _Traits >::open	(	const wstring &	_Str,
		ios_base::openmode	_Mode,
		int	_Prot = `(int)ios_base::_Openprot`
	)

inline

         {   // open a wide-named C stream -- EXTENSION
         return (open(_Str.c_str(), _Mode, _Prot));
         }

template<class _Elem, class _Traits>

_Myt* basic_filebuf< _Elem, _Traits >::open	(	const wchar_t *	_Filename,
		ios_base::open_mode	_Mode
	)

inline

         {   // open a wide-named C stream (old style) -- EXTENSION
         return (open(_Filename, (ios_base::openmode)_Mode));
         }

template<class _Elem, class _Traits>

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

inline

         {   // assign from _Right
         _Assign_rv(_STD forward<_Myt>(_Right));
         return (*this);
         }

template<class _Elem, class _Traits>

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

delete

template<class _Elem, class _Traits>

virtual int_type __CLR_OR_THIS_CALL basic_filebuf< _Elem, _Traits >::overflow ( int_type _Meta = _Traits::eof() )

inlineprotectedvirtual

Reimplemented from basic_streambuf< _Elem, _Traits >.

         {   // put an element to stream
         if (_Traits::eq_int_type(_Traits::eof(), _Meta))
             return (_Traits::not_eof(_Meta));   // EOF, return success code
         else if (_Mysb::pptr() != 0
             && _Mysb::pptr() < _Mysb::epptr())
             {   // room in buffer, store it
             *_Mysb::_Pninc() = _Traits::to_char_type(_Meta);
             return (_Meta);
             }
         else if (_Myfile == 0)
             return (_Traits::eof());    // no open C stream, fail
         _Reset_back();  // revert from _Mychar buffer
         if (_Pcvt == 0)
             return (_Fputc(_Traits::to_char_type(_Meta), _Myfile)
                 ? _Meta : _Traits::eof());  // no codecvt facet, put as is
         else
             {   // put using codecvt facet
             const int _STRING_INC = 8;
             const _Elem _Ch = _Traits::to_char_type(_Meta);
             const _Elem *_Src;
             char *_Dest;
 
             string _Str(_STRING_INC, '\0');
             for (; ; )
                 switch (_Pcvt->out(_State,
                     &_Ch, &_Ch + 1, _Src,
                     &*_Str.begin(), &*_Str.begin() + _Str.size(), _Dest))
                 {   // test result of converting one element
                 case codecvt_base::partial:
                 case codecvt_base::ok:
                     {   // converted something, try to put it out
                     size_t _Count = _Dest - &*_Str.begin();
                     if (0 < _Count && _Count !=
                         fwrite(&*_Str.begin(), 1, _Count, _Myfile))
                         return (_Traits::eof());    // write failed
 
                     _Wrotesome = true;  // write succeeded
                     if (_Src != &_Ch)
                         return (_Meta); // converted whole element
 
                     if (0 < _Count)
                         ;
                     else if (_Str.size() < 4 * _STRING_INC)
                         _Str.append(_STRING_INC, '\0'); // try with more space
                     else
                         return (_Traits::eof());    // conversion failed
                     break;
                     }
 
                 case codecvt_base::noconv:
                     return (_Fputc(_Ch, _Myfile) ? _Meta
                         : _Traits::eof());  // no conversion, put as is
 
                 default:
                     return (_Traits::eof());    // conversion failed
                 }
             }
     }

template<class _Elem, class _Traits>

virtual int_type __CLR_OR_THIS_CALL basic_filebuf< _Elem, _Traits >::pbackfail ( int_type _Meta = _Traits::eof() )

inlineprotectedvirtual

Reimplemented from basic_streambuf< _Elem, _Traits >.

         {   // put an element back to stream
         if (_Mysb::gptr() != 0
             && _Mysb::eback() < _Mysb::gptr()
             && (_Traits::eq_int_type(_Traits::eof(), _Meta)
             || _Traits::eq_int_type(_Traits::to_int_type(_Mysb::gptr()[-1]),
                 _Meta)))
             {   // just back up position
             _Mysb::_Gndec();
             return (_Traits::not_eof(_Meta));
             }
         else if (_Myfile == 0 || _Traits::eq_int_type(_Traits::eof(), _Meta))
             return (_Traits::eof());    // no open C stream or EOF, fail
         else if (_Pcvt == 0 && _Ungetc(_Traits::to_char_type(_Meta), _Myfile))
             return (_Meta); // no facet and unget succeeded, return
         else if (_Mysb::gptr() != &_Mychar)
             {   // putback to _Mychar
             _Mychar = _Traits::to_char_type(_Meta);
             _Set_back();    // switch to _Mychar buffer
             return (_Meta);
             }
         else
             return (_Traits::eof());    // nowhere to put back
     }

template<class _Elem, class _Traits>

virtual pos_type __CLR_OR_THIS_CALL basic_filebuf< _Elem, _Traits >::seekoff	(	off_type	_Off,
		ios_base::seekdir	_Way,
		ios_base::openmode	= `(ios_base::openmode)(ios_base::in \| ios_base::out)`
	)

inlineprotectedvirtual

Reimplemented from basic_streambuf< _Elem, _Traits >.

         {   // change position by _Off
         fpos_t _Fileposition;
 
         if (_Mysb::gptr() == &_Mychar   // something putback
             && _Way == ios_base::cur    // a relative seek
             && _Pcvt == 0)  // not converting
             _Off -= (off_type)sizeof (_Elem);   // back up over _Elem bytes
 
         if (_Myfile == 0 || !_Endwrite()
             || ((_Off != 0 || _Way != ios_base::cur)
                 && _FSEEK_OFF(_Myfile, _Off, _Way) != 0)
             || fgetpos(_Myfile, &_Fileposition) != 0)
             return (pos_type(_BADOFF)); // report failure
 
         _Reset_back();  // revert from _Mychar buffer, discarding any putback
         return (_POS_TYPE_FROM_STATE(pos_type, _State,
             _Fileposition));    // return new position
         }

template<class _Elem, class _Traits>

virtual pos_type __CLR_OR_THIS_CALL basic_filebuf< _Elem, _Traits >::seekpos	(	pos_type	_Pos,
		ios_base::openmode	= `(ios_base::openmode)(ios_base::in \| ios_base::out)`
	)

inlineprotectedvirtual

Reimplemented from basic_streambuf< _Elem, _Traits >.

         {   // change position to _Pos
         fpos_t _Fileposition = _POS_TYPE_TO_FPOS_T(_Pos);
         off_type _Off = (off_type)_Pos - (off_type)_FPOSOFF(_Fileposition);
 
         if (_Myfile == 0 || !_Endwrite()
             || fsetpos(_Myfile, &_Fileposition) != 0
             || (_Off != 0 && _FSEEK_OFF(_Myfile, _Off, SEEK_CUR) != 0)
             || fgetpos(_Myfile, &_Fileposition) != 0)
             return (pos_type(_BADOFF)); // report failure
 
         _State = _POS_TYPE_TO_STATE(_Pos);
 
         _Reset_back();  // revert from _Mychar buffer, discarding any putback
         return (_POS_TYPE_FROM_STATE(pos_type, _State,
             _Fileposition));    // return new position
         }

template<class _Elem, class _Traits>

virtual _Mysb* __CLR_OR_THIS_CALL basic_filebuf< _Elem, _Traits >::setbuf	(	_Elem *	_Buffer,
		streamsize	_Count
	)

inlineprotectedvirtual

Reimplemented from basic_streambuf< _Elem, _Traits >.

         {   // offer _Buffer to C stream
         if (_Myfile == 0 || setvbuf(_Myfile, (char *)_Buffer,
             _Buffer == 0 && _Count == 0 ? _IONBF : _IOFBF,
             (size_t)_Count * sizeof (_Elem)) != 0)
             return (0); // failed
         else
             {   // new buffer, reinitialize pointers
             _Init(_Myfile, _Openfl);
             return (this);
             }
         }

template<class _Elem, class _Traits>

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

inline

         {   // swap with _Right
         if (this != &_Right)
             {   // different, worth swapping
             // save values altered by _Init
             _Filet *_Myfile_sav = _Myfile;
             const _Cvt *_Pcvt_sav = _Pcvt;
             typename _Traits::state_type _State_sav = _State;
             bool _Wrotesome_sav = _Wrotesome;
             bool _Closef_sav = _Closef;
             bool _Set_eback_sav = _Mysb::eback() == &_Mychar;
             bool _Set_eback_live = _Mysb::gptr() == &_Mychar;
 
             _Elem *_Pfirst = _Mysb::pbase();
             _Elem *_Pnext = _Mysb::pptr();
             _Elem *_Pend = _Mysb::epptr();
             _Elem *_Gfirst = _Mysb::eback();
             _Elem *_Gnext = _Mysb::gptr();
             _Elem *_Gend = _Mysb::egptr();
 
             // reinitialize *this
             _Init(_Right._Myfile, _Right._Myfile != 0 ? _Openfl : _Newfl);
             _Mysb::setp(_Right.pbase(), _Right.pptr(), _Right.epptr());
             if (_Right.eback() != &_Right._Mychar)
                 _Mysb::setg(_Right.eback(), _Right.gptr(), _Right.egptr());
             else if (_Right.gptr() != &_Right._Mychar)
                 _Mysb::setg(&_Mychar, &_Mychar + 1, &_Mychar + 1);
             else
                 _Mysb::setg(&_Mychar, &_Mychar, &_Mychar + 1);
 
             _Pcvt = _Right._Pcvt;
             _State = _Right._State;
             _Wrotesome = _Right._Wrotesome;
             _Closef = _Right._Closef;
 
             // reinitialize _Right
             _Right._Init(_Myfile_sav, _Myfile_sav != 0 ? _Openfl : _Newfl);
             _Right.setp(_Pfirst, _Pnext, _Pend);
             if (!_Set_eback_sav)
                 _Right.setg(_Gfirst, _Gnext, _Gend);
             else if (!_Set_eback_live)
                 _Right.setg(&_Right._Mychar, &_Right._Mychar + 1,
                     &_Right._Mychar + 1);
             else
                 _Right.setg(&_Right._Mychar, &_Right._Mychar,
                     &_Right._Mychar + 1);
 
             _Right._Pcvt = _Pcvt_sav;
             _Right._State = _State_sav;
             _Right._Wrotesome = _Wrotesome_sav;
             _Right._Closef = _Closef_sav;
 
             // swap ancillary data
             _STD swap(_Set_eback, _Right._Set_eback);
             _STD swap(_Set_egptr, _Right._Set_egptr);
 
             _STD swap(_Mychar, _Right._Mychar);
             _STD swap(_Mysb::_Plocale, _Right._Plocale);
             }
         }

template<class _Elem, class _Traits>

virtual int __CLR_OR_THIS_CALL basic_filebuf< _Elem, _Traits >::sync ( )

inlineprotectedvirtual

Reimplemented from basic_streambuf< _Elem, _Traits >.

         {   // synchronize C stream with external file
         return (_Myfile == 0
             || _Traits::eq_int_type(_Traits::eof(), overflow())
             || 0 <= fflush(_Myfile) ? 0 : -1);
         }

template<class _Elem, class _Traits>

virtual int_type __CLR_OR_THIS_CALL basic_filebuf< _Elem, _Traits >::uflow ( )

inlineprotectedvirtual

Reimplemented from basic_streambuf< _Elem, _Traits >.

         {   // get an element from stream, point past it
         if (_Mysb::gptr() != 0
             && _Mysb::gptr() < _Mysb::egptr())
             return (_Traits::to_int_type(
                 *_Mysb::_Gninc())); // return buffered
         else if (_Myfile == 0)
             return (_Traits::eof());    // no open C stream, fail
         _Reset_back();  // revert from _Mychar buffer
         if (_Pcvt == 0)
             {   // no codecvt facet, just get it
             _Elem _Ch = 0;
             return (_Fgetc(_Ch, _Myfile) ? _Traits::to_int_type(_Ch)
                 : _Traits::eof());
             }
         else
             {   // build string until codecvt succeeds
             string _Str;
 
             for (; ; )
                 {   // get using codecvt facet
                 _Elem _Ch, *_Dest;
                 const char *_Src;
                 int _Nleft;
                 int _Meta = fgetc(_Myfile);
 
                 if (_Meta == EOF)
                     return (_Traits::eof());    // partial char?
 
                 _Str.append(1, (char)_Meta);    // append byte and convert
                 switch (_Pcvt->in(_State,
                     &*_Str.begin(), &*_Str.begin() + _Str.size(), _Src,
                     &_Ch, &_Ch + 1, _Dest))
                     {   // test result of converting one element
                 case codecvt_base::partial:
                 case codecvt_base::ok:
                     if (_Dest != &_Ch)
                         {   // got an element, put back excess and deliver it
                         _Nleft = (int)(&*_Str.begin() + _Str.size() - _Src);
                         for (; 0 < _Nleft; )
                             ungetc(_Src[--_Nleft], _Myfile);
                         return (_Traits::to_int_type(_Ch));
                         }
                     else
                         _Str.erase((size_t)0,   // partial, discard used input
                             (size_t)(_Src - &*_Str.begin()));
                     break;
 
                 case codecvt_base::noconv:
                     if (_Str.size() < sizeof (_Elem))
                         break;  // no conversion, but need more chars
 
                     _CRT_SECURE_MEMCPY(&_Ch, sizeof (_Elem), &*_Str.begin(),
                         sizeof (_Elem));    // copy raw bytes to element
 
                     return (_Traits::to_int_type(_Ch)); // return result
 
                 default:
                     return (_Traits::eof());    // conversion failed
                     }
                 }
             }
         }

template<class _Elem, class _Traits>

virtual int_type __CLR_OR_THIS_CALL basic_filebuf< _Elem, _Traits >::underflow ( )

inlineprotectedvirtual

Reimplemented from basic_streambuf< _Elem, _Traits >.

         {   // get an element from stream, but don't point past it
         int_type _Meta;
         if (_Mysb::gptr() != 0
             && _Mysb::gptr() < _Mysb::egptr())
             return (_Traits::to_int_type(*_Mysb::gptr()));  // return buffered
         else if (_Traits::eq_int_type(_Traits::eof(), _Meta = uflow()))
             return (_Meta); // uflow failed, return EOF
         else
             {   // get a char, don't point past it
             pbackfail(_Meta);
             return (_Meta);
             }
         }

Member Data Documentation

template<class _Elem, class _Traits>

bool basic_filebuf< _Elem, _Traits >::_Closef

private

template<class _Elem, class _Traits>

_Elem basic_filebuf< _Elem, _Traits >::_Mychar

private

template<class _Elem, class _Traits>

_Filet* basic_filebuf< _Elem, _Traits >::_Myfile

private

template<class _Elem, class _Traits>

const _Cvt* basic_filebuf< _Elem, _Traits >::_Pcvt

private

template<class _Elem, class _Traits>

_Elem* basic_filebuf< _Elem, _Traits >::_Set_eback

private

template<class _Elem, class _Traits>

_Elem* basic_filebuf< _Elem, _Traits >::_Set_egptr

private

template<class _Elem, class _Traits>

_Traits::state_type basic_filebuf< _Elem, _Traits >::_State

private

template<class _Elem, class _Traits>

bool basic_filebuf< _Elem, _Traits >::_Wrotesome

private

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

VS2013/inc/fstream

Public Types

Public Member Functions

Protected Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Member Typedef Documentation

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation