basic_filebuf< _CharT, _Traits > Class Template Reference

#include <_fstream.h>

Inheritance diagram for basic_filebuf< _CharT, _Traits >:

Collaboration diagram for basic_filebuf< _CharT, _Traits >:

Public Types
typedef _CharT	char_type
typedef _Traits::int_type	int_type
typedef _Traits::pos_type	pos_type
typedef _Traits::off_type	off_type
typedef _Traits	traits_type
typedef _Traits::state_type	_State_type
typedef basic_streambuf< _CharT, _Traits >	_Base
typedef basic_filebuf< _CharT, _Traits >	_Self
Public Types inherited from basic_streambuf< _CharT, _Traits >
typedef _CharT	char_type
typedef _Traits::int_type	int_type
typedef _Traits::pos_type	pos_type
typedef _Traits::off_type	off_type
typedef _Traits	traits_type

Public Member Functions
	basic_filebuf ()
	~basic_filebuf ()
bool	is_open () const
_Self *	open (const char *__s, ios_base::openmode __m)
_Self *	open (const char *__s, ios_base::openmode __m, long __protection)
_STLP_fd	fd () const
_Self *	open (int __id, ios_base::openmode _Init_mode=ios_base::__default_mode)
_Self *	_M_open (int __id, ios_base::openmode _Init_mode=ios_base::__default_mode)
_Self *	close ()
bool	_M_write (char *__buf, ptrdiff_t __n)
int_type	_M_do_noconv_input ()
Public Member Functions inherited from basic_streambuf< _CharT, _Traits >
virtual	~basic_streambuf ()
char_type *	_M_eback () const
char_type *	_M_gptr () const
char_type *	_M_egptr () const
void	_M_gbump (int __n)
void	_M_setg (char_type *__gbegin, char_type *__gnext, char_type *__gend)
basic_streambuf< _CharT, _Traits > *	pubsetbuf (char_type *__s, streamsize __n)
pos_type	pubseekoff (off_type __offset, ios_base::seekdir __way, ios_base::openmode __mod=ios_base::in|ios_base::out)
pos_type	pubseekpos (pos_type __sp, ios_base::openmode __mod=ios_base::in|ios_base::out)
int	pubsync ()
int_type	sputc (char_type __c)
streamsize	sputn (const char_type *__s, streamsize __n)
streamsize	_M_sputnc (char_type __c, streamsize __n)
streamsize	in_avail ()
int_type	snextc ()
int_type	sbumpc ()
int_type	sgetc ()
streamsize	sgetn (char_type *__s, streamsize __n)
int_type	sputbackc (char_type __c)
int_type	sungetc ()
locale	pubimbue (const locale &)
locale	getloc () const
void	stossc ()

Protected Member Functions
virtual streamsize	showmanyc ()
virtual int_type	underflow ()
virtual int_type	pbackfail (int_type=traits_type::eof())
virtual int_type	overflow (int_type=traits_type::eof())
virtual basic_streambuf< _CharT, _Traits > *	setbuf (char_type *, streamsize)
virtual pos_type	seekoff (off_type, ios_base::seekdir, ios_base::openmode=ios_base::in|ios_base::out)
virtual pos_type	seekpos (pos_type, ios_base::openmode=ios_base::in|ios_base::out)
virtual int	sync ()
virtual void	imbue (const locale &)
Protected Member Functions inherited from basic_streambuf< _CharT, _Traits >
	basic_streambuf ()
char_type *	eback () const
char_type *	gptr () const
char_type *	egptr () const
void	gbump (int __n)
void	setg (char_type *__gbegin, char_type *__gnext, char_type *__gend)
char_type *	pbase () const
char_type *	pptr () const
char_type *	epptr () const
void	pbump (int __n)
void	setp (char_type *__pbegin, char_type *__pend)
virtual basic_streambuf< _CharT, _Traits > *	setbuf (char_type *, streamsize)
virtual pos_type	seekoff (off_type, ios_base::seekdir, ios_base::openmode=ios_base::in|ios_base::out)
virtual pos_type	seekpos (pos_type, ios_base::openmode=ios_base::in|ios_base::out)
virtual int	sync ()
virtual streamsize	showmanyc ()
virtual streamsize	xsgetn (char_type *__s, streamsize __n)
virtual int_type	underflow ()
virtual int_type	uflow ()
virtual int_type	pbackfail (int_type=traits_type::eof())
virtual streamsize	xsputn (const char_type *__s, streamsize __n)
virtual streamsize	_M_xsputnc (char_type __c, streamsize __n)
virtual int_type	overflow (int_type=traits_type::eof())
virtual void	imbue (const locale &)

Private Types
enum	{ _S_pback_buf_size = 8 }
typedef codecvt< _CharT, char, _State_type >	_Codecvt

Private Member Functions
void	_M_exit_putback_mode ()
bool	_M_switch_to_input_mode ()
void	_M_exit_input_mode ()
bool	_M_switch_to_output_mode ()
int_type	_M_input_error ()
int_type	_M_underflow_aux ()
int_type	_M_output_error ()
bool	_M_unshift ()
bool	_M_allocate_buffers (_CharT *__buf, streamsize __n)
bool	_M_allocate_buffers ()
void	_M_deallocate_buffers ()
pos_type	_M_seek_return (off_type __off, _State_type __state)
bool	_M_seek_init (bool __do_unshift)
void	_M_setup_codecvt (const locale &, bool __on_imbue=true)

Private Attributes
_Filebuf_base	_M_base
unsigned char	_M_constant_width
unsigned char	_M_always_noconv
unsigned char	_M_int_buf_dynamic
unsigned char	_M_in_input_mode
unsigned char	_M_in_output_mode
unsigned char	_M_in_error_mode
unsigned char	_M_in_putback_mode
_CharT *	_M_int_buf
_CharT *	_M_int_buf_EOS
char *	_M_ext_buf
char *	_M_ext_buf_EOS
char *	_M_ext_buf_converted
char *	_M_ext_buf_end
_State_type	_M_state
_State_type	_M_end_state
void *	_M_mmap_base
streamoff	_M_mmap_len
_CharT *	_M_saved_eback
_CharT *	_M_saved_gptr
_CharT *	_M_saved_egptr
const _Codecvt *	_M_codecvt
int	_M_width
int	_M_max_width
_CharT	_M_pback_buf [_S_pback_buf_size]

Friends
class	_Underflow< _CharT, _Traits >

Detailed Description

template<class _CharT, class _Traits>
class basic_filebuf< _CharT, _Traits >

Definition at line 152 of file _fstream.h.

Member Typedef Documentation

_Base

template<class _CharT , class _Traits >

typedef basic_streambuf<_CharT, _Traits> basic_filebuf< _CharT, _Traits >::_Base

Definition at line 161 of file _fstream.h.

_Codecvt

template<class _CharT , class _Traits >

typedef codecvt<_CharT, char, _State_type> basic_filebuf< _CharT, _Traits >::_Codecvt

private

Definition at line 319 of file _fstream.h.

_Self

template<class _CharT , class _Traits >

typedef basic_filebuf<_CharT, _Traits> basic_filebuf< _CharT, _Traits >::_Self

Definition at line 162 of file _fstream.h.

_State_type

template<class _CharT , class _Traits >

typedef _Traits::state_type basic_filebuf< _CharT, _Traits >::_State_type

Definition at line 160 of file _fstream.h.

char_type

template<class _CharT , class _Traits >

typedef _CharT basic_filebuf< _CharT, _Traits >::char_type

Definition at line 154 of file _fstream.h.

int_type

template<class _CharT , class _Traits >

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

Definition at line 155 of file _fstream.h.

off_type

template<class _CharT , class _Traits >

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

Definition at line 157 of file _fstream.h.

pos_type

template<class _CharT , class _Traits >

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

Definition at line 156 of file _fstream.h.

traits_type

template<class _CharT , class _Traits >

typedef _Traits basic_filebuf< _CharT, _Traits >::traits_type

Definition at line 158 of file _fstream.h.

Member Enumeration Documentation

anonymous enum

template<class _CharT , class _Traits >

anonymous enum

private

Enumerator
_S_pback_buf_size

Definition at line 326 of file _fstream.h.

{ _S_pback_buf_size = 8 };

Constructor & Destructor Documentation

basic_filebuf()

template<class _CharT , class _Traits >

basic_filebuf< _CharT, _Traits >::basic_filebuf

Definition at line 47 of file _fstream.c.

     :  basic_streambuf<_CharT, _Traits>(), _M_base(),
    _M_constant_width(false), _M_always_noconv(false),
    _M_int_buf_dynamic(false),
    _M_in_input_mode(false), _M_in_output_mode(false),
    _M_in_error_mode(false), _M_in_putback_mode(false),
    _M_int_buf(0), _M_int_buf_EOS(0),
    _M_ext_buf(0), _M_ext_buf_EOS(0),
    _M_ext_buf_converted(0), _M_ext_buf_end(0),
    _M_state(_STLP_DEFAULT_CONSTRUCTED(_State_type)),
    _M_end_state(_STLP_DEFAULT_CONSTRUCTED(_State_type)),
    _M_mmap_base(0), _M_mmap_len(0),
    _M_saved_eback(0), _M_saved_gptr(0), _M_saved_egptr(0),
    _M_codecvt(0),
    _M_width(1), _M_max_width(1)
{
  this->_M_setup_codecvt(locale(), false);
}

~basic_filebuf()

template<class _CharT , class _Traits >

basic_filebuf< _CharT, _Traits >::~basic_filebuf

Definition at line 67 of file _fstream.c.

                                               {
  this->close();
  _M_deallocate_buffers();
}

Member Function Documentation

_M_allocate_buffers() [1/2]

template<class _CharT , class _Traits >

bool basic_filebuf< _CharT, _Traits >::_M_allocate_buffers

private

Definition at line 676 of file _fstream.c.

                                                         {
  // Choose a buffer that's at least 4096 characters long and that's a
  // multiple of the page size.
  streamsize __default_bufsiz =
    ((_M_base.__page_size() + 4095UL) / _M_base.__page_size()) * _M_base.__page_size();
  return _M_allocate_buffers(0, __default_bufsiz);
}

_M_allocate_buffers() [2/2]

template<class _CharT , class _Traits >

bool basic_filebuf< _CharT, _Traits >::_M_allocate_buffers ( _CharT *  __buf, streamsize  __n  )

private

Definition at line 630 of file _fstream.c.

                                                                                      {
  //The major hypothesis in the following implementation is that size_t is unsigned.
  //We also need streamsize byte representation to be larger or equal to the int
  //representation to correctly store the encoding information.
  _STLP_STATIC_ASSERT(!numeric_limits<size_t>::is_signed &&
                      sizeof(streamsize) >= sizeof(int))
 
  if (__buf == 0) {
    streamsize __bufsize = __n * sizeof(_CharT);
    //We first check that the streamsize representation can't overflow a size_t one.
    //If it can, we check that __bufsize is not higher than the size_t max value.
    if ((sizeof(streamsize) > sizeof(size_t)) &&
        (__bufsize > __STATIC_CAST(streamsize, (numeric_limits<size_t>::max)())))
      return false;
    _M_int_buf = __STATIC_CAST(_CharT*, malloc(__STATIC_CAST(size_t, __bufsize)));
    if (!_M_int_buf)
      return false;
    _M_int_buf_dynamic = true;
  }
  else {
    _M_int_buf = __buf;
    _M_int_buf_dynamic = false;
  }
 
  streamsize __ebufsiz = (max)(__n * __STATIC_CAST(streamsize, _M_width),
                               __STATIC_CAST(streamsize, _M_codecvt->max_length()));
 
  _M_ext_buf = 0;
  if ((sizeof(streamsize) < sizeof(size_t)) ||
      ((sizeof(streamsize) == sizeof(size_t)) && numeric_limits<streamsize>::is_signed) ||
      (__ebufsiz <= __STATIC_CAST(streamsize, (numeric_limits<size_t>::max)()))) {
    _M_ext_buf = __STATIC_CAST(char*, malloc(__STATIC_CAST(size_t, __ebufsiz)));
  }
 
  if (!_M_ext_buf) {
    _M_deallocate_buffers();
    return false;
  }
 
  _M_int_buf_EOS = _M_int_buf + __STATIC_CAST(ptrdiff_t, __n);
  _M_ext_buf_EOS = _M_ext_buf + __STATIC_CAST(ptrdiff_t, __ebufsiz);
  return true;
}

_M_deallocate_buffers()

template<class _CharT , class _Traits >

void basic_filebuf< _CharT, _Traits >::_M_deallocate_buffers

private

Definition at line 685 of file _fstream.c.

                                                           {
  if (_M_int_buf_dynamic)
    free(_M_int_buf);
  free(_M_ext_buf);
  _M_int_buf     = 0;
  _M_int_buf_EOS = 0;
  _M_ext_buf     = 0;
  _M_ext_buf_EOS = 0;
}

_M_do_noconv_input()

template<class _CharT , class _Traits >

int_type basic_filebuf< _CharT, _Traits >::_M_do_noconv_input ( )

inline

Definition at line 335 of file _fstream.h.

                       {
    _M_ext_buf_converted = _M_ext_buf_end;
    /* this-> */ _Base::setg((char_type*)_M_ext_buf, (char_type*)_M_ext_buf, (char_type*)_M_ext_buf_end);
    return traits_type::to_int_type(*_M_ext_buf);
  }

_M_exit_input_mode()

template<class _CharT , class _Traits >

void basic_filebuf< _CharT, _Traits >::_M_exit_input_mode

private

Definition at line 118 of file _fstream.c.

                                                        {
  if (_M_mmap_base != 0) {
    _M_base._M_unmap(_M_mmap_base, _M_mmap_len);
    _M_mmap_base = 0;
    _M_mmap_len = 0;
  }
  _M_in_input_mode = false;
}

Referenced by basic_filebuf< _CharT, _Traits >::_M_seek_return().

_M_exit_putback_mode()

template<class _CharT , class _Traits >

void basic_filebuf< _CharT, _Traits >::_M_exit_putback_mode ( )

inlineprivate

Definition at line 228 of file _fstream.h.

                              {
    this->setg(_M_saved_eback, _M_saved_gptr, _M_saved_egptr);
    _M_in_putback_mode = false;
  }

Referenced by _Underflow< _CharT, _Traits >::_M_doit().

_M_input_error()

template<class _CharT , class _Traits >

__BF_int_type__ basic_filebuf< _CharT, _Traits >::_M_input_error

private

Definition at line 485 of file _fstream.c.

                                               {
   this->_M_exit_input_mode();
  _M_in_output_mode = false;
  _M_in_error_mode = true;
  this->setg(0, 0, 0);
  return traits_type::eof();
}

_M_open()

template<class _CharT , class _Traits >

_Self * basic_filebuf< _CharT, _Traits >::_M_open ( int  __id, ios_base::openmode  _Init_mode = ios_base::__default_mode  )

inline

Definition at line 202 of file _fstream.h.

                                                                                 {
    return _M_base._M_open(__id, _Init_mode) ? this : 0;
  }

Referenced by basic_filebuf< _CharT, _Traits >::open().

_M_output_error()

template<class _CharT , class _Traits >

__BF_int_type__ basic_filebuf< _CharT, _Traits >::_M_output_error

private

Definition at line 579 of file _fstream.c.

                                                {
  _M_in_output_mode = false;
  _M_in_input_mode = false;
  _M_in_error_mode = true;
  this->setp(0, 0);
  return traits_type::eof();
}

_M_seek_init()

template<class _CharT , class _Traits >

bool basic_filebuf< _CharT, _Traits >::_M_seek_init ( bool  __do_unshift )

private

Definition at line 700 of file _fstream.c.

                                                                   {
  // If we're in error mode, leave it.
   _M_in_error_mode = false;
 
  // Flush the output buffer if we're in output mode, and (conditionally)
  // emit an unshift sequence.
  if (_M_in_output_mode) {
    bool __ok = !traits_type::eq_int_type(this->overflow(traits_type::eof()),
                                          traits_type::eof());
    if (__do_unshift)
      __ok = __ok && this->_M_unshift();
    if (!__ok) {
      _M_in_output_mode = false;
      _M_in_error_mode = true;
      this->setp(0, 0);
      return false;
    }
  }
 
  // Discard putback characters, if any.
  if (_M_in_input_mode && _M_in_putback_mode)
    _M_exit_putback_mode();
 
  return true;
}

_M_seek_return()

template<class _CharT , class _Traits >

pos_type basic_filebuf< _CharT, _Traits >::_M_seek_return ( off_type  __off, _State_type  __state  )

inlineprivate

Definition at line 247 of file _fstream.h.

                                                               {
    if (__off != -1) {
      if (_M_in_input_mode)
        _M_exit_input_mode();
      _M_in_input_mode = false;
      _M_in_output_mode = false;
      _M_in_putback_mode = false;
      _M_in_error_mode = false;
      this->setg(0, 0, 0);
      this->setp(0, 0);
    }
 
    pos_type __result(__off);
    __result.state(__state);
    return __result;
  }

_M_setup_codecvt()

template<class _CharT , class _Traits >

void basic_filebuf< _CharT, _Traits >::_M_setup_codecvt ( const locale &  __loc, bool  __on_imbue = true  )

private

Definition at line 735 of file _fstream.c.

                                                                                          {
  if (has_facet<_Codecvt>(__loc)) {
    _M_codecvt = &use_facet<_Codecvt>(__loc) ;
    int __encoding    = _M_codecvt->encoding();
 
    _M_width          = (max)(__encoding, 1);
    _M_max_width      = _M_codecvt->max_length();
    _M_constant_width = __encoding > 0;
    _M_always_noconv  = _M_codecvt->always_noconv();
  }
  else {
    _M_codecvt = 0;
    _M_width = _M_max_width = 1;
    _M_constant_width = _M_always_noconv  = false;
    if (__on_imbue) {
      //This call will generate an exception reporting the problem.
      use_facet<_Codecvt>(__loc);
    }
  }
}

Referenced by basic_filebuf< _CharT, _Traits >::basic_filebuf().

_M_switch_to_input_mode()

template<class _CharT , class _Traits >

bool basic_filebuf< _CharT, _Traits >::_M_switch_to_input_mode

private

Definition at line 429 of file _fstream.c.

                                                             {
  if (this->is_open() && (((int)_M_base.__o_mode() & (int)ios_base::in) !=0)
      && (_M_in_output_mode == 0) && (_M_in_error_mode == 0)) {
    if (!_M_int_buf && !_M_allocate_buffers())
      return false;
 
    _M_ext_buf_converted = _M_ext_buf;
    _M_ext_buf_end       = _M_ext_buf;
 
    _M_end_state    = _M_state;
 
    _M_in_input_mode = true;
    return true;
  }
 
  return false;
}

Referenced by _Underflow< _CharT, _Traits >::_M_doit().

_M_switch_to_output_mode()

template<class _CharT , class _Traits >

bool basic_filebuf< _CharT, _Traits >::_M_switch_to_output_mode

private

Definition at line 452 of file _fstream.c.

                                                              {
  if (this->is_open() && (_M_base.__o_mode() & (int)ios_base::out) &&
      _M_in_input_mode == 0 && _M_in_error_mode == 0) {
 
    if (!_M_int_buf && !_M_allocate_buffers())
      return false;
 
    // In append mode, every write does an implicit seek to the end
    // of the file.  Whenever leaving output mode, the end of file
    // get put in the initial shift state.
    if (_M_base.__o_mode() & ios_base::app)
      _M_state = _State_type();
 
    this->setp(_M_int_buf, _M_int_buf_EOS - 1);
    _M_in_output_mode = true;
    return true;
  }
 
  return false;
}

_M_underflow_aux()

template<class _CharT , class _Traits >

__BF_int_type__ basic_filebuf< _CharT, _Traits >::_M_underflow_aux

private

Definition at line 495 of file _fstream.c.

                                                 {
  // We have the state and file position from the end of the internal
  // buffer.  This round, they become the beginning of the internal buffer.
  _M_state    = _M_end_state;
 
  // Fill the external buffer.  Start with any leftover characters that
  // didn't get converted last time.
  if (_M_ext_buf_end > _M_ext_buf_converted)
 
    _M_ext_buf_end = _STLP_STD::copy(_M_ext_buf_converted, _M_ext_buf_end, _M_ext_buf);
    // boris : copy_backward did not work
    //_M_ext_buf_end = copy_backward(_M_ext_buf_converted, _M_ext_buf_end,
    //_M_ext_buf+ (_M_ext_buf_end - _M_ext_buf_converted));
  else
    _M_ext_buf_end = _M_ext_buf;
 
  // Now fill the external buffer with characters from the file.  This is
  // a loop because occasionally we don't get enough external characters
  // to make progress.
  for (;;) {
    ptrdiff_t __n = _M_base._M_read(_M_ext_buf_end, _M_ext_buf_EOS - _M_ext_buf_end);
    if (__n < 0) {
      // Read failed, maybe we should set err bit on associated stream...
      this->setg(0, 0, 0);
      return traits_type::eof();
    }
 
    _M_ext_buf_end += __n;
 
    // If external buffer is empty there is nothing to do.
    if (_M_ext_buf == _M_ext_buf_end) {
      this->setg(0, 0, 0);
      return traits_type::eof();
    }
 
    // Convert the external buffer to internal characters.
    const char* __enext;
    _CharT* __inext;
 
    typename _Codecvt::result __status
      = _M_codecvt->in(_M_end_state,
                       _M_ext_buf, _M_ext_buf_end, __enext,
                       _M_int_buf, _M_int_buf_EOS, __inext);
 
    /* Error conditions:
     * (1) Return value of error.
     * (2) Producing internal characters without consuming external characters.
     * (3) In fixed-width encodings, producing an internal sequence whose length
     * is inconsistent with that of the internal sequence.
     * (4) Failure to produce any characters if we have enough characters in
     * the external buffer, where "enough" means the largest possible width
     * of a single character. */
    if (__status == _Codecvt::noconv)
      return _Noconv_input<_Traits>::_M_doit(this);
    else if (__status == _Codecvt::error ||
            (__inext != _M_int_buf && __enext == _M_ext_buf) ||
            (_M_constant_width && (__inext - _M_int_buf) *  _M_width != (__enext - _M_ext_buf)) ||
            (__inext == _M_int_buf && __enext - _M_ext_buf >= _M_max_width))
      return _M_input_error();
    else if (__inext != _M_int_buf) {
      _M_ext_buf_converted = _M_ext_buf + (__enext - _M_ext_buf);
      this->setg(_M_int_buf, _M_int_buf, __inext);
      return traits_type::to_int_type(*_M_int_buf);
    }
    /* We need to go around the loop again to get more external characters.
     * But if the previous read failed then don't try again for now.
     * Don't enter error mode for a failed read. Error mode is sticky,
     * and we might succeed if we try again. */
    if (__n <= 0) {
      this->setg(0, 0, 0);
      return traits_type::eof();
    }
  }
}

Referenced by _Underflow< _CharT, _Traits >::_M_doit().

_M_unshift()

template<class _CharT , class _Traits >

bool basic_filebuf< _CharT, _Traits >::_M_unshift

private

Definition at line 593 of file _fstream.c.

                                                {
  if (_M_in_output_mode && !_M_constant_width) {
    typename _Codecvt::result __status;
    do {
      char* __enext = _M_ext_buf;
      __status = _M_codecvt->unshift(_M_state,
                                     _M_ext_buf, _M_ext_buf_EOS, __enext);
      if (__status == _Codecvt::noconv ||
          (__enext == _M_ext_buf && __status == _Codecvt::ok))
        return true;
      else if (__status == _Codecvt::error)
        return false;
      else if (!_M_write(_M_ext_buf, __enext - _M_ext_buf))
        return false;
    } while (__status == _Codecvt::partial);
  }
 
  return true;
}

_M_write()

template<class _CharT , class _Traits >

bool basic_filebuf< _CharT, _Traits >::_M_write ( char *  __buf, ptrdiff_t  __n  )

inline

Definition at line 331 of file _fstream.h.

{return _M_base._M_write(__buf, __n); }

close()

template<class _CharT , class _Traits >

basic_filebuf< _CharT, _Traits > * basic_filebuf< _CharT, _Traits >::close

Definition at line 81 of file _fstream.c.

                                      {
  bool __ok = this->is_open();
 
  if (_M_in_output_mode) {
    __ok = __ok && !_Traits::eq_int_type(this->overflow(traits_type::eof()),
                                         traits_type::eof());
    __ok = __ok && this->_M_unshift();
  }
  else if (_M_in_input_mode)
      this->_M_exit_input_mode();
 
  // Note order of arguments.  We close the file even if __ok is false.
  __ok = _M_base._M_close() && __ok;
 
  // Restore the initial state, except that we don't deallocate the buffer
  // or mess with the cached codecvt information.
  _M_state = _M_end_state = _State_type();
  _M_ext_buf_converted = _M_ext_buf_end = 0;
 
  _M_mmap_base = 0;
  _M_mmap_len = 0;
 
  this->setg(0, 0, 0);
  this->setp(0, 0);
 
  _M_saved_eback = _M_saved_gptr = _M_saved_egptr = 0;
 
  _M_in_input_mode = _M_in_output_mode = _M_in_error_mode = _M_in_putback_mode
    = false;
 
  return __ok ? this : 0;
}

fd()

template<class _CharT , class _Traits >

_STLP_fd basic_filebuf< _CharT, _Traits >::fd ( ) const

inline

Definition at line 182 of file _fstream.h.

{ return _M_base.__get_fd(); }

imbue()

template<class _CharT , class _Traits >

void basic_filebuf< _CharT, _Traits >::imbue ( const locale &  __loc )

protectedvirtual

Reimplemented from basic_streambuf< _CharT, _Traits >.

Definition at line 413 of file _fstream.c.

                                                              {
  if (!_M_in_input_mode && !_M_in_output_mode && !_M_in_error_mode) {
    this->_M_setup_codecvt(__loc);
  }
}

is_open()

template<class _CharT , class _Traits >

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

inline

Definition at line 169 of file _fstream.h.

{ return _M_base.__is_open(); }

open() [1/3]

template<class _CharT , class _Traits >

_Self * basic_filebuf< _CharT, _Traits >::open ( const char *  __s, ios_base::openmode  __m  )

inline

Definition at line 171 of file _fstream.h.

                                                     {
    return _M_base._M_open(__s, __m) ? this : 0;
  }

open() [2/3]

template<class _CharT , class _Traits >

_Self * basic_filebuf< _CharT, _Traits >::open ( const char *  __s, ios_base::openmode  __m, long  __protection  )

inline

Definition at line 177 of file _fstream.h.

                                 {
    return _M_base._M_open(__s, __m, __protection) ? this : 0;
  }

open() [3/3]

template<class _CharT , class _Traits >

_Self * basic_filebuf< _CharT, _Traits >::open ( int  __id, ios_base::openmode  _Init_mode = ios_base::__default_mode  )

inline

Definition at line 184 of file _fstream.h.

                                                                              {
    return this->_M_open(__id, _Init_mode);
  }

overflow()

template<class _CharT , class _Traits >

__BF_int_type__ basic_filebuf< _CharT, _Traits >::overflow ( int_type  __c = traits_type::eof() )

protectedvirtual

Reimplemented from basic_streambuf< _CharT, _Traits >.

Definition at line 208 of file _fstream.c.

                                                     {
  // Switch to output mode, if necessary.
  if (!_M_in_output_mode)
    if (!_M_switch_to_output_mode())
      return traits_type::eof();
 
  _CharT* __ibegin = this->_M_int_buf;
  _CharT* __iend   = this->pptr();
  this->setp(_M_int_buf, _M_int_buf_EOS - 1);
 
  // Put __c at the end of the internal buffer.
  if (!traits_type::eq_int_type(__c, traits_type::eof()))
    *__iend++ = _Traits::to_char_type(__c);
 
  // For variable-width encodings, output may take more than one pass.
  while (__ibegin != __iend) {
    const _CharT* __inext = __ibegin;
    char* __enext         = _M_ext_buf;
    typename _Codecvt::result __status
      = _M_codecvt->out(_M_state, __ibegin, __iend, __inext,
                        _M_ext_buf, _M_ext_buf_EOS, __enext);
    if (__status == _Codecvt::noconv) {
      return _Noconv_output<_Traits>::_M_doit(this, __ibegin, __iend)
        ? traits_type::not_eof(__c)
        : _M_output_error();
    }
 
    // For a constant-width encoding we know that the external buffer
    // is large enough, so failure to consume the entire internal buffer
    // or to produce the correct number of external characters, is an error.
    // For a variable-width encoding, however, we require only that we
    // consume at least one internal character
    else if (__status != _Codecvt::error &&
             (((__inext == __iend) &&
               (__enext - _M_ext_buf == _M_width * (__iend - __ibegin))) ||
              (!_M_constant_width && __inext != __ibegin))) {
        // We successfully converted part or all of the internal buffer.
      ptrdiff_t __n = __enext - _M_ext_buf;
      if (_M_write(_M_ext_buf, __n))
        __ibegin += __inext - __ibegin;
      else
        return _M_output_error();
    }
    else
      return _M_output_error();
  }
 
  return traits_type::not_eof(__c);
}

pbackfail()

template<class _CharT , class _Traits >

__BF_int_type__ basic_filebuf< _CharT, _Traits >::pbackfail ( int_type  __c = traits_type::eof() )

protectedvirtual

Reimplemented from basic_streambuf< _CharT, _Traits >.

Definition at line 157 of file _fstream.c.

                                                      {
  const int_type __eof = traits_type::eof();
 
  // If we aren't already in input mode, pushback is impossible.
  if (!_M_in_input_mode)
    return __eof;
 
  // We can use the ordinary get buffer if there's enough space, and
  // if it's a buffer that we're allowed to write to.
  if (this->gptr() != this->eback() &&
      (traits_type::eq_int_type(__c, __eof) ||
       traits_type::eq(traits_type::to_char_type(__c), this->gptr()[-1]) ||
       !_M_mmap_base)) {
    this->gbump(-1);
    if (traits_type::eq_int_type(__c, __eof) ||
        traits_type::eq(traits_type::to_char_type(__c), *this->gptr()))
      return traits_type::to_int_type(*this->gptr());
  }
  else if (!traits_type::eq_int_type(__c, __eof)) {
    // Are we in the putback buffer already?
    _CharT* __pback_end = _M_pback_buf + __STATIC_CAST(int,_S_pback_buf_size);
    if (_M_in_putback_mode) {
      // Do we have more room in the putback buffer?
      if (this->eback() != _M_pback_buf)
        this->setg(this->egptr() - 1, this->egptr() - 1, __pback_end);
      else
        return __eof;           // No more room in the buffer, so fail.
    }
    else {                      // We're not yet in the putback buffer.
      _M_saved_eback = this->eback();
      _M_saved_gptr  = this->gptr();
      _M_saved_egptr = this->egptr();
      this->setg(__pback_end - 1, __pback_end - 1, __pback_end);
      _M_in_putback_mode = true;
    }
  }
  else
    return __eof;
 
  // We have made a putback position available.  Assign to it, and return.
  *this->gptr() = traits_type::to_char_type(__c);
  return __c;
}

seekoff()

template<class _CharT , class _Traits >

__BF_pos_type__ basic_filebuf< _CharT, _Traits >::seekoff ( off_type  __off, ios_base::seekdir  __whence, ios_base::openmode  = ios_base::in | ios_base::out  )

protectedvirtual

Reimplemented from basic_streambuf< _CharT, _Traits >.

Definition at line 291 of file _fstream.c.

                                                            {
  if (!this->is_open())
    return pos_type(-1);
 
  if (!_M_constant_width && __off != 0)
    return pos_type(-1);
 
  if (!_M_seek_init(__off != 0 || __whence != ios_base::cur))
    return pos_type(-1);
 
  // Seek to beginning or end, regardless of whether we're in input mode.
  if (__whence == ios_base::beg || __whence == ios_base::end)
    return _M_seek_return(_M_base._M_seek(_M_width * __off, __whence),
                          _State_type());
 
  // Seek relative to current position.  Complicated if we're in input mode.
  _STLP_ASSERT(__whence == ios_base::cur)
  if (!_M_in_input_mode)
    return _M_seek_return(_M_base._M_seek(_M_width * __off, __whence),
                          _State_type());
 
  if (_M_mmap_base != 0) {
    // __off is relative to gptr().  We need to do a bit of arithmetic
    // to get an offset relative to the external file pointer.
    streamoff __adjust = _M_mmap_len - (this->gptr() - (_CharT*) _M_mmap_base);
 
    // if __off == 0, we do not need to exit input mode and to shift file pointer
    return __off == 0 ? pos_type(_M_base._M_seek(0, ios_base::cur) - __adjust)
                      : _M_seek_return(_M_base._M_seek(__off - __adjust, ios_base::cur), _State_type());
  }
 
  if (_M_constant_width) { // Get or set the position.
    streamoff __iadj = _M_width * (this->gptr() - this->eback());
 
    // Compensate for offset relative to gptr versus offset relative
    // to external pointer.  For a text-oriented stream, where the
    // compensation is more than just pointer arithmetic, we may get
    // but not set the current position.
 
    if (__iadj <= _M_ext_buf_end - _M_ext_buf) {
      streamoff __eadj =  _M_base._M_get_offset(_M_ext_buf + __STATIC_CAST(ptrdiff_t, __iadj), _M_ext_buf_end);
 
      return __off == 0 ? pos_type(_M_base._M_seek(0, ios_base::cur) - __eadj)
                        : _M_seek_return(_M_base._M_seek(__off - __eadj, ios_base::cur), _State_type());
    }
  }
  else {                    // Get the position.  Encoding is var width.
    // Get position in internal buffer.
    ptrdiff_t __ipos = this->gptr() - this->eback();
 
    // Get corresponding position in external buffer.
    _State_type __state = _M_state;
    int __epos = _M_codecvt->length(__state, _M_ext_buf, _M_ext_buf_converted,
                                    __ipos);
#if defined (_STLP_ASSERTIONS)
    // Sanity check (expensive): make sure __epos is the right answer.
    _STLP_ASSERT(__epos >= 0)
    _State_type __tmp_state = _M_state;
    _Filebuf_Tmp_Buf<_CharT> __buf(__ipos);
    _CharT* __ibegin = __buf._M_ptr;
    _CharT* __inext  = __ibegin;
    const char* __dummy;
    typename _Codecvt::result __status
      = _M_codecvt->in(__tmp_state,
                       _M_ext_buf, _M_ext_buf + __epos, __dummy,
                       __ibegin, __ibegin + __ipos, __inext);
    // The result code is necessarily ok because:
    // - noconv: impossible for a variable encoding
    // - error: length method is supposed to count until it reach max value or find an error so we cannot have
    //          an error again when decoding an external buffer up to length return value.
    // - partial: idem error, it is also a reason for length to stop counting.
    _STLP_ASSERT(__status == _Codecvt::ok)
    _STLP_ASSERT(__inext == __ibegin + __ipos)
    _STLP_ASSERT(equal(this->eback(), this->gptr(), __ibegin, _STLP_PRIV _Eq_traits<traits_type>()))
#endif
    // Get the current position (at the end of the external buffer),
    // then adjust it.  Again, it might be a text-oriented stream.
    streamoff __cur = _M_base._M_seek(0, ios_base::cur);
    streamoff __adj = _M_base._M_get_offset(_M_ext_buf, _M_ext_buf + __epos) -
                      _M_base._M_get_offset(_M_ext_buf, _M_ext_buf_end);
    if (__cur != -1 && __cur + __adj >= 0)
      return __off == 0 ? pos_type(__cur + __adj)
                        : _M_seek_return(__cur + __adj, __state);
  }
 
  return pos_type(-1);
}

seekpos()

template<class _CharT , class _Traits >

__BF_pos_type__ basic_filebuf< _CharT, _Traits >::seekpos ( pos_type  __pos, ios_base::openmode  = ios_base::in | ios_base::out  )

protectedvirtual

Reimplemented from basic_streambuf< _CharT, _Traits >.

Definition at line 384 of file _fstream.c.

                                                            {
  if (this->is_open()) {
    if (!_M_seek_init(true))
      return pos_type(-1);
 
    streamoff __off = off_type(__pos);
    if (__off != -1 && _M_base._M_seek(__off, ios_base::beg) != -1) {
      _M_state = __pos.state();
      return _M_seek_return(__off, __pos.state());
    }
  }
 
  return pos_type(-1);
}

setbuf()

template<class _CharT , class _Traits >

basic_streambuf< _CharT, _Traits > * basic_filebuf< _CharT, _Traits >::setbuf ( char_type *  __buf, streamsize  __n  )

protectedvirtual

Reimplemented from basic_streambuf< _CharT, _Traits >.

Definition at line 268 of file _fstream.c.

                                                                    {
  if (!_M_in_input_mode &&! _M_in_output_mode && !_M_in_error_mode &&
      _M_int_buf == 0) {
    if (__buf == 0 && __n == 0)
      _M_allocate_buffers(0, 1);
    else if (__buf != 0 && __n > 0)
      _M_allocate_buffers(__buf, __n);
  }
  return this;
}

showmanyc()

template<class _CharT , class _Traits >

streamsize basic_filebuf< _CharT, _Traits >::showmanyc

protectedvirtual

Reimplemented from basic_streambuf< _CharT, _Traits >.

Definition at line 132 of file _fstream.c.

                                                     {
  // Is there any possibility that reads can succeed?
  if (!this->is_open() || _M_in_output_mode || _M_in_error_mode)
    return -1;
  else if (_M_in_putback_mode)
    return this->egptr() - this->gptr();
  else if (_M_constant_width) {
    streamoff __pos  = _M_base._M_seek(0, ios_base::cur);
    streamoff __size = _M_base._M_file_size();
    return __pos >= 0 && __size > __pos ? __size - __pos : 0;
  }
  else
    return 0;
}

sync()

template<class _CharT , class _Traits >

int basic_filebuf< _CharT, _Traits >::sync

protectedvirtual

Reimplemented from basic_streambuf< _CharT, _Traits >.

Definition at line 402 of file _fstream.c.

                                         {
  if (_M_in_output_mode)
    return traits_type::eq_int_type(this->overflow(traits_type::eof()),
                                    traits_type::eof()) ? -1 : 0;
  return 0;
}

underflow()

template<class _CharT , class _Traits >

_STLP_TYPENAME_ON_RETURN_TYPE basic_filebuf< _CharT, _Traits >::int_type basic_filebuf< _CharT, _Traits >::underflow

protectedvirtual

Reimplemented from basic_streambuf< _CharT, _Traits >.

Definition at line 75 of file _fstream.c.

                                          {
  return _Underflow<_CharT, _Traits>::_M_doit(this);
}

Friends And Related Function Documentation

_Underflow< _CharT, _Traits >

template<class _CharT , class _Traits >

friend class _Underflow< _CharT, _Traits >

friend

Definition at line 237 of file _fstream.h.

Member Data Documentation

_M_always_noconv

template<class _CharT , class _Traits >

unsigned char basic_filebuf< _CharT, _Traits >::_M_always_noconv

private

Definition at line 275 of file _fstream.h.

_M_base

template<class _CharT , class _Traits >

_Filebuf_base basic_filebuf< _CharT, _Traits >::_M_base

private

Definition at line 270 of file _fstream.h.

Referenced by basic_filebuf< _CharT, _Traits >::_M_open(), basic_filebuf< _CharT, _Traits >::_M_write(), basic_filebuf< _CharT, _Traits >::fd(), basic_filebuf< _CharT, _Traits >::is_open(), and basic_filebuf< _CharT, _Traits >::open().

_M_codecvt

template<class _CharT , class _Traits >

const _Codecvt* basic_filebuf< _CharT, _Traits >::_M_codecvt

private

Definition at line 320 of file _fstream.h.

_M_constant_width

template<class _CharT , class _Traits >

unsigned char basic_filebuf< _CharT, _Traits >::_M_constant_width

private

Definition at line 274 of file _fstream.h.

_M_end_state

template<class _CharT , class _Traits >

_State_type basic_filebuf< _CharT, _Traits >::_M_end_state

private

Definition at line 308 of file _fstream.h.

_M_ext_buf

template<class _CharT , class _Traits >

char* basic_filebuf< _CharT, _Traits >::_M_ext_buf

private

Definition at line 290 of file _fstream.h.

Referenced by basic_filebuf< _CharT, _Traits >::_M_do_noconv_input().

_M_ext_buf_converted

template<class _CharT , class _Traits >

char* basic_filebuf< _CharT, _Traits >::_M_ext_buf_converted

private

Definition at line 298 of file _fstream.h.

Referenced by basic_filebuf< _CharT, _Traits >::_M_do_noconv_input().

_M_ext_buf_end

template<class _CharT , class _Traits >

char* basic_filebuf< _CharT, _Traits >::_M_ext_buf_end

private

Definition at line 299 of file _fstream.h.

Referenced by basic_filebuf< _CharT, _Traits >::_M_do_noconv_input().

_M_ext_buf_EOS

template<class _CharT , class _Traits >

char* basic_filebuf< _CharT, _Traits >::_M_ext_buf_EOS

private

Definition at line 291 of file _fstream.h.

_M_in_error_mode

template<class _CharT , class _Traits >

unsigned char basic_filebuf< _CharT, _Traits >::_M_in_error_mode

private

Definition at line 282 of file _fstream.h.

Referenced by basic_filebuf< _CharT, _Traits >::_M_seek_return().

_M_in_input_mode

template<class _CharT , class _Traits >

unsigned char basic_filebuf< _CharT, _Traits >::_M_in_input_mode

private

Definition at line 280 of file _fstream.h.

Referenced by _Underflow< _CharT, _Traits >::_M_doit(), and basic_filebuf< _CharT, _Traits >::_M_seek_return().

_M_in_output_mode

template<class _CharT , class _Traits >

unsigned char basic_filebuf< _CharT, _Traits >::_M_in_output_mode

private

Definition at line 281 of file _fstream.h.

Referenced by basic_filebuf< _CharT, _Traits >::_M_seek_return().

_M_in_putback_mode

template<class _CharT , class _Traits >

unsigned char basic_filebuf< _CharT, _Traits >::_M_in_putback_mode

private

Definition at line 283 of file _fstream.h.

Referenced by _Underflow< _CharT, _Traits >::_M_doit(), basic_filebuf< _CharT, _Traits >::_M_exit_putback_mode(), and basic_filebuf< _CharT, _Traits >::_M_seek_return().

_M_int_buf

template<class _CharT , class _Traits >

_CharT* basic_filebuf< _CharT, _Traits >::_M_int_buf

private

Definition at line 286 of file _fstream.h.

_M_int_buf_dynamic

template<class _CharT , class _Traits >

unsigned char basic_filebuf< _CharT, _Traits >::_M_int_buf_dynamic

private

Definition at line 278 of file _fstream.h.

_M_int_buf_EOS

template<class _CharT , class _Traits >

_CharT* basic_filebuf< _CharT, _Traits >::_M_int_buf_EOS

private

Definition at line 287 of file _fstream.h.

_M_max_width

template<class _CharT , class _Traits >

int basic_filebuf< _CharT, _Traits >::_M_max_width

private

Definition at line 323 of file _fstream.h.

_M_mmap_base

template<class _CharT , class _Traits >

void* basic_filebuf< _CharT, _Traits >::_M_mmap_base

private

Definition at line 311 of file _fstream.h.

_M_mmap_len

template<class _CharT , class _Traits >

streamoff basic_filebuf< _CharT, _Traits >::_M_mmap_len

private

Definition at line 312 of file _fstream.h.

_M_pback_buf

template<class _CharT , class _Traits >

_CharT basic_filebuf< _CharT, _Traits >::_M_pback_buf[_S_pback_buf_size]

private

Definition at line 327 of file _fstream.h.

_M_saved_eback

template<class _CharT , class _Traits >

_CharT* basic_filebuf< _CharT, _Traits >::_M_saved_eback

private

Definition at line 315 of file _fstream.h.

Referenced by basic_filebuf< _CharT, _Traits >::_M_exit_putback_mode().

_M_saved_egptr

template<class _CharT , class _Traits >

_CharT* basic_filebuf< _CharT, _Traits >::_M_saved_egptr

private

Definition at line 317 of file _fstream.h.

Referenced by basic_filebuf< _CharT, _Traits >::_M_exit_putback_mode().

_M_saved_gptr

template<class _CharT , class _Traits >

_CharT* basic_filebuf< _CharT, _Traits >::_M_saved_gptr

private

Definition at line 316 of file _fstream.h.

Referenced by basic_filebuf< _CharT, _Traits >::_M_exit_putback_mode().

_M_state

template<class _CharT , class _Traits >

_State_type basic_filebuf< _CharT, _Traits >::_M_state

private

Definition at line 302 of file _fstream.h.

_M_width

template<class _CharT , class _Traits >

int basic_filebuf< _CharT, _Traits >::_M_width

private

Definition at line 322 of file _fstream.h.

---

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

• sdk/include/c++/stlport/stl/_fstream.h
• sdk/include/c++/stlport/stl/_fstream.c