basic_filebuf< CharT, Traits > Class Template Reference

#include <basic-filebuf.h>

Inheritance diagram for basic_filebuf< CharT, Traits >:

Collaboration diagram for basic_filebuf< CharT, Traits >:

Public Types
typedef CharT	char_type
typedef Traits	traits_type
typedef traits_type::int_type	int_type
typedef traits_type::pos_type	pos_type
typedef traits_type::off_type	off_type
typedef traits_type::state_type	state_type

Public Member Functions
	basic_filebuf ()
	basic_filebuf (basic_filebuf &&rhs)
virtual	~basic_filebuf ()
basic_filebuf &	operator= (basic_filebuf &&rhs)
void	swap (basic_filebuf &rhs)
bool	is_open () const
basic_filebuf *	open (const char *s, std::ios_base::openmode mode)
basic_filebuf *	open (const std::string &s, std::ios_base::openmode mode)
basic_filebuf *	open (int fd, std::ios_base::openmode mode)
basic_filebuf *	open (FILE *f, std::ios_base::openmode mode)
basic_filebuf *	close ()
FILE *	file ()
int	fd ()

Protected Member Functions
int_type	underflow () override
int_type	pbackfail (int_type c=traits_type::eof()) override
int_type	overflow (int_type c=traits_type::eof()) override
std::basic_streambuf< char_type, traits_type > *	setbuf (char_type *s, std::streamsize n) override
pos_type	seekoff (off_type off, std::ios_base::seekdir way, std::ios_base::openmode wch=std::ios_base::in|std::ios_base::out) override
pos_type	seekpos (pos_type sp, std::ios_base::openmode wch=std::ios_base::in|std::ios_base::out) override
int	sync () override
void	imbue (const std::locale &loc) override
const char *	_M_get_mode (std::ios_base::openmode mode)
bool	_M_read_mode ()
void	_M_write_mode ()

Protected Attributes
char *	_M_extbuf
const char *	_M_extbufnext
const char *	_M_extbufend
char	_M_extbuf_min [8]
size_t	_M_ebs
char_type *	_M_intbuf
size_t	_M_ibs
FILE *	_M_file
const std::codecvt< char_type, char, state_type > *	_M_cv
state_type	_M_st
state_type	_M_st_last
std::ios_base::openmode	_M_om
std::ios_base::openmode	_M_cm
bool	_M_owns_eb
bool	_M_owns_ib
bool	_M_always_noconv

Detailed Description

template<typename CharT, typename Traits = std::char_traits<CharT>>
class kaldi::basic_filebuf< CharT, Traits >

Definition at line 25 of file basic-filebuf.h.

Member Typedef Documentation

char_type

typedef CharT char_type

Definition at line 27 of file basic-filebuf.h.

int_type

typedef traits_type::int_type int_type

Definition at line 29 of file basic-filebuf.h.

off_type

typedef traits_type::off_type off_type

Definition at line 31 of file basic-filebuf.h.

pos_type

typedef traits_type::pos_type pos_type

Definition at line 30 of file basic-filebuf.h.

state_type

typedef traits_type::state_type state_type

Definition at line 32 of file basic-filebuf.h.

traits_type

typedef Traits traits_type

Definition at line 28 of file basic-filebuf.h.

Constructor & Destructor Documentation

basic_filebuf() [1/2]

basic_filebuf

(

)

Definition at line 91 of file basic-filebuf.h.

References basic_filebuf< CharT, Traits >::_M_always_noconv, basic_filebuf< CharT, Traits >::_M_cv, and basic_filebuf< CharT, Traits >::setbuf().

    : _M_extbuf(nullptr),
      _M_extbufnext(nullptr),
      _M_extbufend(nullptr),
      _M_ebs(0),
      _M_intbuf(nullptr),
      _M_ibs(0),
      _M_file(nullptr),
      _M_cv(nullptr),
      _M_st(),
      _M_st_last(),
      _M_om(std::ios_base::openmode(0)),
      _M_cm(std::ios_base::openmode(0)),
      _M_owns_eb(false),
      _M_owns_ib(false),
      _M_always_noconv(false) {
    if (std::has_facet<std::codecvt<char_type, char, state_type> >
        (this->getloc())) {
        _M_cv = &std::use_facet<std::codecvt<char_type, char, state_type> >
          (this->getloc());
        _M_always_noconv = _M_cv->always_noconv();
    }
    setbuf(0, 4096);
}

basic_filebuf() [2/2]

basic_filebuf

(

basic_filebuf< CharT, Traits > &&

rhs

)

Definition at line 118 of file basic-filebuf.h.

References basic_filebuf< CharT, Traits >::_M_always_noconv, basic_filebuf< CharT, Traits >::_M_cm, basic_filebuf< CharT, Traits >::_M_cv, basic_filebuf< CharT, Traits >::_M_ebs, basic_filebuf< CharT, Traits >::_M_extbuf, basic_filebuf< CharT, Traits >::_M_extbuf_min, basic_filebuf< CharT, Traits >::_M_extbufend, basic_filebuf< CharT, Traits >::_M_extbufnext, basic_filebuf< CharT, Traits >::_M_file, basic_filebuf< CharT, Traits >::_M_ibs, basic_filebuf< CharT, Traits >::_M_intbuf, basic_filebuf< CharT, Traits >::_M_om, basic_filebuf< CharT, Traits >::_M_owns_eb, basic_filebuf< CharT, Traits >::_M_owns_ib, basic_filebuf< CharT, Traits >::_M_st, and basic_filebuf< CharT, Traits >::_M_st_last.

    : std::basic_streambuf<CharT, Traits>(rhs) {
    if (rhs._M_extbuf == rhs._M_extbuf_min) {
        _M_extbuf = _M_extbuf_min;
        _M_extbufnext = _M_extbuf + (rhs._M_extbufnext - rhs._M_extbuf);
        _M_extbufend = _M_extbuf + (rhs._M_extbufend - rhs._M_extbuf);
    } else {
        _M_extbuf = rhs._M_extbuf;
        _M_extbufnext = rhs._M_extbufnext;
        _M_extbufend = rhs._M_extbufend;
    }
    _M_ebs = rhs._M_ebs;
    _M_intbuf = rhs._M_intbuf;
    _M_ibs = rhs._M_ibs;
    _M_file = rhs._M_file;
    _M_cv = rhs._M_cv;
    _M_st = rhs._M_st;
    _M_st_last = rhs._M_st_last;
    _M_om = rhs._M_om;
    _M_cm = rhs._M_cm;
    _M_owns_eb = rhs._M_owns_eb;
    _M_owns_ib = rhs._M_owns_ib;
    _M_always_noconv = rhs._M_always_noconv;
    if (rhs.pbase()) {
        if (rhs.pbase() == rhs._M_intbuf)
            this->setp(_M_intbuf, _M_intbuf + (rhs. epptr() - rhs.pbase()));
        else
            this->setp(reinterpret_cast<char_type*>(_M_extbuf),
                       reinterpret_cast<char_type*>(_M_extbuf)
                       + (rhs. epptr() - rhs.pbase()));
        this->pbump(rhs. pptr() - rhs.pbase());
    } else if (rhs.eback()) {
        if (rhs.eback() == rhs._M_intbuf)
            this->setg(_M_intbuf, _M_intbuf + (rhs.gptr() - rhs.eback()),
                                  _M_intbuf + (rhs.egptr() - rhs.eback()));
        else
            this->setg(reinterpret_cast<char_type*>(_M_extbuf),
                       reinterpret_cast<char_type*>(_M_extbuf) +
                       (rhs.gptr() - rhs.eback()),
                       reinterpret_cast<char_type*>(_M_extbuf) +
                       (rhs.egptr() - rhs.eback()));
    }
    rhs._M_extbuf = nullptr;
    rhs._M_extbufnext = nullptr;
    rhs._M_extbufend = nullptr;
    rhs._M_ebs = 0;
    rhs._M_intbuf = nullptr;
    rhs._M_ibs = 0;
    rhs._M_file = nullptr;
    rhs._M_st = state_type();
    rhs._M_st_last = state_type();
    rhs._M_om = std::ios_base::openmode(0);
    rhs._M_cm = std::ios_base::openmode(0);
    rhs._M_owns_eb = false;
    rhs._M_owns_ib = false;
    rhs.setg(0, 0, 0);
    rhs.setp(0, 0);
}

~basic_filebuf()

~basic_filebuf ( )

virtual

Definition at line 189 of file basic-filebuf.h.

References basic_filebuf< CharT, Traits >::_M_extbuf, basic_filebuf< CharT, Traits >::_M_intbuf, basic_filebuf< CharT, Traits >::_M_owns_eb, and basic_filebuf< CharT, Traits >::_M_owns_ib.

                                             {
    // try
    // {
    //     close();
    // }
    // catch (...)
    // {
    // }
    if (_M_owns_eb)
        delete [] _M_extbuf;
    if (_M_owns_ib)
        delete [] _M_intbuf;
}

Member Function Documentation

_M_get_mode()

const char * _M_get_mode ( std::ios_base::openmode  mode )

protected

Definition at line 290 of file basic-filebuf.h.

References basic_filebuf< CharT, Traits >::open().

Referenced by basic_filebuf< CharT, Traits >::is_open(), and basic_filebuf< CharT, Traits >::open().

                                      {
    switch ((mode & ~std::ios_base::ate) | 0) {
    case std::ios_base::out:
    case std::ios_base::out | std::ios_base::trunc:
        return "w";
    case std::ios_base::out | std::ios_base::app:
    case std::ios_base::app:
        return "a";
        break;
    case std::ios_base::in:
        return "r";
    case std::ios_base::in  | std::ios_base::out:
        return "r+";
    case std::ios_base::in  | std::ios_base::out | std::ios_base::trunc:
        return "w+";
    case std::ios_base::in  | std::ios_base::out | std::ios_base::app:
    case std::ios_base::in  | std::ios_base::app:
        return "a+";
    case std::ios_base::out | std::ios_base::binary:
    case std::ios_base::out | std::ios_base::trunc | std::ios_base::binary:
        return "wb";
    case std::ios_base::out | std::ios_base::app | std::ios_base::binary:
    case std::ios_base::app | std::ios_base::binary:
        return "ab";
    case std::ios_base::in  | std::ios_base::binary:
        return "rb";
    case std::ios_base::in  | std::ios_base::out | std::ios_base::binary:
        return "r+b";
    case std::ios_base::in  | std::ios_base::out | std::ios_base::trunc |
      std::ios_base::binary:
        return "w+b";
    case std::ios_base::in  | std::ios_base::out | std::ios_base::app |
      std::ios_base::binary:
    case std::ios_base::in  | std::ios_base::app | std::ios_base::binary:
        return "a+b";
    default:
        return nullptr;
    }
}

_M_read_mode()

bool _M_read_mode ( )

protected

Definition at line 748 of file basic-filebuf.h.

References basic_filebuf< CharT, Traits >::_M_always_noconv, basic_filebuf< CharT, Traits >::_M_cm, basic_filebuf< CharT, Traits >::_M_ebs, basic_filebuf< CharT, Traits >::_M_extbuf, basic_filebuf< CharT, Traits >::_M_ibs, and basic_filebuf< CharT, Traits >::_M_intbuf.

Referenced by basic_filebuf< CharT, Traits >::underflow().

                                           {
    if (!(_M_cm & std::ios_base::in)) {
        this->setp(0, 0);
        if (_M_always_noconv)
            this->setg(reinterpret_cast<char_type*>(_M_extbuf),
                       reinterpret_cast<char_type*>(_M_extbuf) + _M_ebs,
                       reinterpret_cast<char_type*>(_M_extbuf) + _M_ebs);
        else
            this->setg(_M_intbuf, _M_intbuf + _M_ibs, _M_intbuf + _M_ibs);
        _M_cm = std::ios_base::in;
        return true;
    }
    return false;
}

_M_write_mode()

void _M_write_mode ( )

protected

Definition at line 766 of file basic-filebuf.h.

References basic_filebuf< CharT, Traits >::_M_always_noconv, basic_filebuf< CharT, Traits >::_M_cm, basic_filebuf< CharT, Traits >::_M_ebs, basic_filebuf< CharT, Traits >::_M_extbuf, basic_filebuf< CharT, Traits >::_M_extbuf_min, basic_filebuf< CharT, Traits >::_M_ibs, and basic_filebuf< CharT, Traits >::_M_intbuf.

Referenced by basic_filebuf< CharT, Traits >::overflow().

                                            {
    if (!(_M_cm & std::ios_base::out)) {
        this->setg(0, 0, 0);
        if (_M_ebs > sizeof(_M_extbuf_min)) {
            if (_M_always_noconv)
                this->setp(reinterpret_cast<char_type*>(_M_extbuf),
                           reinterpret_cast<char_type*>(_M_extbuf) +
                           (_M_ebs - 1));
            else
                this->setp(_M_intbuf, _M_intbuf + (_M_ibs - 1));
        } else {
            this->setp(0, 0);
        }
        _M_cm = std::ios_base::out;
    }
}

close()

basic_filebuf< CharT, Traits > * close

(

)

Definition at line 391 of file basic-filebuf.h.

References basic_filebuf< CharT, Traits >::_M_file, and basic_filebuf< CharT, Traits >::sync().

Referenced by basic_filebuf< CharT, Traits >::operator=().

                                    {
    basic_filebuf<CharT, Traits>* rt = nullptr;
    if (_M_file) {
        rt = this;
        std::unique_ptr<FILE, int(*)(FILE*)> h(_M_file, fclose);
        if (sync())
            rt = nullptr;
        if (fclose(h.release()) == 0)
            _M_file = nullptr;
        else
            rt = nullptr;
    }
    return rt;
}

fd()

int fd ( )

inline

Definition at line 49 of file basic-filebuf.h.

References basic_filebuf< CharT, Traits >::_M_file, basic_filebuf< CharT, Traits >::imbue(), rnnlm::n, basic_filebuf< CharT, Traits >::overflow(), basic_filebuf< CharT, Traits >::pbackfail(), basic_filebuf< CharT, Traits >::seekoff(), basic_filebuf< CharT, Traits >::seekpos(), basic_filebuf< CharT, Traits >::setbuf(), basic_filebuf< CharT, Traits >::sync(), and basic_filebuf< CharT, Traits >::underflow().

{ return fileno(this->_M_file); }

file()

FILE* file ( )

inline

Definition at line 48 of file basic-filebuf.h.

References basic_filebuf< CharT, Traits >::_M_file.

{ return this->_M_file; }

imbue()

void imbue ( const std::locale &  loc )

overrideprotected

Definition at line 709 of file basic-filebuf.h.

References basic_filebuf< CharT, Traits >::_M_always_noconv, basic_filebuf< CharT, Traits >::_M_cv, basic_filebuf< CharT, Traits >::_M_ebs, basic_filebuf< CharT, Traits >::_M_extbuf, basic_filebuf< CharT, Traits >::_M_extbuf_min, basic_filebuf< CharT, Traits >::_M_ibs, basic_filebuf< CharT, Traits >::_M_intbuf, basic_filebuf< CharT, Traits >::_M_owns_eb, basic_filebuf< CharT, Traits >::_M_owns_ib, and basic_filebuf< CharT, Traits >::sync().

Referenced by basic_filebuf< CharT, Traits >::fd().

                                                        {
    sync();
    _M_cv = &std::use_facet<std::codecvt<char_type, char, state_type> >(loc);
    bool old_anc = _M_always_noconv;
    _M_always_noconv = _M_cv->always_noconv();
    if (old_anc != _M_always_noconv) {
        this->setg(0, 0, 0);
        this->setp(0, 0);
        // invariant, char_type is char, else we couldn't get here
        // need to dump _M_intbuf
        if (_M_always_noconv) {
            if (_M_owns_eb)
                delete [] _M_extbuf;
            _M_owns_eb = _M_owns_ib;
            _M_ebs = _M_ibs;
            _M_extbuf = reinterpret_cast<char*>(_M_intbuf);
            _M_ibs = 0;
            _M_intbuf = nullptr;
            _M_owns_ib = false;
        } else {  // need to obtain an _M_intbuf.
         // If _M_extbuf is user-supplied, use it, else new _M_intbuf
            if (!_M_owns_eb && _M_extbuf != _M_extbuf_min) {
                _M_ibs = _M_ebs;
                _M_intbuf = reinterpret_cast<char_type*>(_M_extbuf);
                _M_owns_ib = false;
                _M_extbuf = new char[_M_ebs];
                _M_owns_eb = true;
            } else {
                _M_ibs = _M_ebs;
                _M_intbuf = new char_type[_M_ibs];
                _M_owns_ib = true;
            }
        }
    }
}

is_open()

bool is_open ( ) const

inline

Definition at line 283 of file basic-filebuf.h.

References basic_filebuf< CharT, Traits >::_M_file, and basic_filebuf< CharT, Traits >::_M_get_mode().

                                            {
    return _M_file != nullptr;
}

open() [1/4]

basic_filebuf< CharT, Traits > * open	(	const char *	s,
		std::ios_base::openmode	mode
	)

Definition at line 334 of file basic-filebuf.h.

References basic_filebuf< CharT, Traits >::_M_file, basic_filebuf< CharT, Traits >::_M_get_mode(), and basic_filebuf< CharT, Traits >::_M_om.

Referenced by basic_filebuf< CharT, Traits >::_M_get_mode(), and basic_filebuf< CharT, Traits >::open().

                                              {
    basic_filebuf<CharT, Traits>* rt = nullptr;
    if (_M_file == nullptr) {
        const char* md= _M_get_mode(mode);
        if (md) {
            _M_file = fopen(s, md);
            if (_M_file) {
                rt = this;
                _M_om = mode;
                if (mode & std::ios_base::ate) {
                    if (fseek(_M_file, 0, SEEK_END)) {
                        fclose(_M_file);
                        _M_file = nullptr;
                        rt = nullptr;
                    }
                }
            }
        }
    }
    return rt;
}

open() [2/4]

basic_filebuf< CharT, Traits > * open ( const std::string &  s, std::ios_base::openmode  mode  )

inline

Definition at line 360 of file basic-filebuf.h.

References basic_filebuf< CharT, Traits >::open().

                              {
    return open(s.c_str(), mode);
}

open() [3/4]

basic_filebuf< CharT, Traits > * open	(	int	fd,
		std::ios_base::openmode	mode
	)

Definition at line 368 of file basic-filebuf.h.

References basic_filebuf< CharT, Traits >::_M_file, basic_filebuf< CharT, Traits >::_M_get_mode(), and basic_filebuf< CharT, Traits >::_M_om.

                                                                   {
    const char* md= this->_M_get_mode(mode);
    if (md) {
        this->_M_file= fdopen(fd, md);
        this->_M_om = mode;
        return this;
    } else {
      return nullptr;
    }
}

open() [4/4]

basic_filebuf< CharT, Traits > * open	(	FILE *	f,
		std::ios_base::openmode	mode
	)

Definition at line 382 of file basic-filebuf.h.

References basic_filebuf< CharT, Traits >::_M_file, and basic_filebuf< CharT, Traits >::_M_om.

                                                                    {
    this->_M_file = f;
    this->_M_om = mode;
    return this;
}

operator=()

basic_filebuf< CharT, Traits > & operator= ( basic_filebuf< CharT, Traits > &&  rhs )

inline

Definition at line 181 of file basic-filebuf.h.

References basic_filebuf< CharT, Traits >::close(), and basic_filebuf< CharT, Traits >::swap().

                                                           {
    close();
    swap(rhs);
    return *this;
}

overflow()

basic_filebuf< CharT, Traits >::int_type overflow ( int_type  c = traits_type::eof() )

overrideprotected

Definition at line 494 of file basic-filebuf.h.

References basic_filebuf< CharT, Traits >::_M_always_noconv, basic_filebuf< CharT, Traits >::_M_cv, basic_filebuf< CharT, Traits >::_M_ebs, basic_filebuf< CharT, Traits >::_M_extbuf, basic_filebuf< CharT, Traits >::_M_file, basic_filebuf< CharT, Traits >::_M_st, and basic_filebuf< CharT, Traits >::_M_write_mode().

Referenced by basic_filebuf< CharT, Traits >::fd(), and basic_filebuf< CharT, Traits >::sync().

                                                 {
    if (_M_file == nullptr)
        return traits_type::eof();
    _M_write_mode();
    char_type buf;
    char_type* pb_save = this->pbase();
    char_type* epb_save = this->epptr();
    if (!traits_type::eq_int_type(c, traits_type::eof())) {
        if (this->pptr() == nullptr)
            this->setp(&buf, &buf+1);
        *this->pptr() = traits_type::to_char_type(c);
        this->pbump(1);
    }
    if (this->pptr() != this->pbase()) {
        if (_M_always_noconv) {
            size_t nmemb = static_cast<size_t>(this->pptr() - this->pbase());
            if (fwrite(this->pbase(), sizeof(char_type),
                  nmemb, _M_file) != nmemb)
                return traits_type::eof();
        } else {
            char* extbe = _M_extbuf;
            std::codecvt_base::result r;
            do {
                if (!_M_cv)
                    throw std::bad_cast();
                const char_type* e;
                r = _M_cv->out(_M_st, this->pbase(), this->pptr(), e,
                               _M_extbuf, _M_extbuf + _M_ebs, extbe);
                if (e == this->pbase())
                    return traits_type::eof();
                if (r == std::codecvt_base::noconv) {
                    size_t nmemb = static_cast<size_t>
                      (this->pptr() - this->pbase());
                    if (fwrite(this->pbase(), 1, nmemb, _M_file) != nmemb)
                        return traits_type::eof();
                } else if (r == std::codecvt_base::ok ||
                    r == std::codecvt_base::partial) {
                    size_t nmemb = static_cast<size_t>(extbe - _M_extbuf);
                    if (fwrite(_M_extbuf, 1, nmemb, _M_file) != nmemb)
                        return traits_type::eof();
                    if (r == std::codecvt_base::partial) {
                        this->setp(const_cast<char_type*>(e),
                            this->pptr());
                        this->pbump(this->epptr() - this->pbase());
                    }
                } else {
                    return traits_type::eof();
                }
            } while (r == std::codecvt_base::partial);
        }
        this->setp(pb_save, epb_save);
    }
    return traits_type::not_eof(c);
}

pbackfail()

basic_filebuf< CharT, Traits >::int_type pbackfail ( int_type  c = traits_type::eof() )

overrideprotected

Definition at line 475 of file basic-filebuf.h.

References basic_filebuf< CharT, Traits >::_M_file, and basic_filebuf< CharT, Traits >::_M_om.

Referenced by basic_filebuf< CharT, Traits >::fd().

                                                  {
    if (_M_file && this->eback() < this->gptr()) {
        if (traits_type::eq_int_type(c, traits_type::eof())) {
            this->gbump(-1);
            return traits_type::not_eof(c);
        }
        if ((_M_om & std::ios_base::out) ||
            traits_type::eq(traits_type::to_char_type(c), this->gptr()[-1])) {
            this->gbump(-1);
            *this->gptr() = traits_type::to_char_type(c);
            return c;
        }
    }
    return traits_type::eof();
}

seekoff()

basic_filebuf< CharT, Traits >::pos_type seekoff ( off_type  off, std::ios_base::seekdir  way, std::ios_base::openmode  wch = std::ios_base::in | std::ios_base::out  )

overrideprotected

Definition at line 593 of file basic-filebuf.h.

References basic_filebuf< CharT, Traits >::_M_cv, basic_filebuf< CharT, Traits >::_M_file, basic_filebuf< CharT, Traits >::_M_st, and basic_filebuf< CharT, Traits >::sync().

Referenced by basic_filebuf< CharT, Traits >::fd().

                                                           {
    if (!_M_cv)
        throw std::bad_cast();
    int width = _M_cv->encoding();
    if (_M_file == nullptr || (width <= 0 && off != 0) || sync())
        return pos_type(off_type(-1));
    // width > 0 || off == 0
    int whence;
    switch (way) {
    case std::ios_base::beg:
        whence = SEEK_SET;
        break;
    case std::ios_base::cur:
        whence = SEEK_CUR;
        break;
    case std::ios_base::end:
        whence = SEEK_END;
        break;
    default:
        return pos_type(off_type(-1));
    }
#if _WIN32
    if (fseek(_M_file, width > 0 ? width * off : 0, whence))
        return pos_type(off_type(-1));
    pos_type r = ftell(_M_file);
#else
    if (fseeko(_M_file, width > 0 ? width * off : 0, whence))
        return pos_type(off_type(-1));
    pos_type r = ftello(_M_file);
#endif
    r.state(_M_st);
    return r;
}

seekpos()

basic_filebuf< CharT, Traits >::pos_type seekpos ( pos_type  sp, std::ios_base::openmode  wch = std::ios_base::in | std::ios_base::out  )

overrideprotected

Definition at line 631 of file basic-filebuf.h.

References basic_filebuf< CharT, Traits >::_M_file, basic_filebuf< CharT, Traits >::_M_st, and basic_filebuf< CharT, Traits >::sync().

Referenced by basic_filebuf< CharT, Traits >::fd().

                                                                      {
    if (_M_file == nullptr || sync())
        return pos_type(off_type(-1));
#if _WIN32
    if (fseek(_M_file, sp, SEEK_SET))
        return pos_type(off_type(-1));
#else
    if (fseeko(_M_file, sp, SEEK_SET))
        return pos_type(off_type(-1));
#endif
    _M_st = sp.state();
    return sp;
}

setbuf()

std::basic_streambuf< CharT, Traits > * setbuf ( char_type *  s, std::streamsize  n  )

overrideprotected

Definition at line 552 of file basic-filebuf.h.

References basic_filebuf< CharT, Traits >::_M_always_noconv, basic_filebuf< CharT, Traits >::_M_ebs, basic_filebuf< CharT, Traits >::_M_extbuf, basic_filebuf< CharT, Traits >::_M_extbuf_min, basic_filebuf< CharT, Traits >::_M_ibs, basic_filebuf< CharT, Traits >::_M_intbuf, basic_filebuf< CharT, Traits >::_M_owns_eb, basic_filebuf< CharT, Traits >::_M_owns_ib, and rnnlm::n.

Referenced by basic_filebuf< CharT, Traits >::basic_filebuf(), and basic_filebuf< CharT, Traits >::fd().

                                                                  {
    this->setg(0, 0, 0);
    this->setp(0, 0);
    if (_M_owns_eb)
        delete [] _M_extbuf;
    if (_M_owns_ib)
        delete [] _M_intbuf;
    _M_ebs = n;
    if (_M_ebs > sizeof(_M_extbuf_min)) {
        if (_M_always_noconv && s) {
            _M_extbuf = reinterpret_cast<char*>(s);
            _M_owns_eb = false;
        } else {
            _M_extbuf = new char[_M_ebs];
            _M_owns_eb = true;
        }
    } else {
        _M_extbuf = _M_extbuf_min;
        _M_ebs = sizeof(_M_extbuf_min);
        _M_owns_eb = false;
    }
    if (!_M_always_noconv) {
        _M_ibs = std::max<std::streamsize>(n, sizeof(_M_extbuf_min));
        if (s && _M_ibs >= sizeof(_M_extbuf_min)) {
            _M_intbuf = s;
            _M_owns_ib = false;
        } else {
            _M_intbuf = new char_type[_M_ibs];
            _M_owns_ib = true;
        }
    } else {
        _M_ibs = 0;
        _M_intbuf = 0;
        _M_owns_ib = false;
    }
    return this;
}

swap()

void swap

(

basic_filebuf< CharT, Traits > &

rhs

)

Definition at line 206 of file basic-filebuf.h.

References basic_filebuf< CharT, Traits >::_M_always_noconv, basic_filebuf< CharT, Traits >::_M_cm, basic_filebuf< CharT, Traits >::_M_cv, basic_filebuf< CharT, Traits >::_M_ebs, basic_filebuf< CharT, Traits >::_M_extbuf, basic_filebuf< CharT, Traits >::_M_extbuf_min, basic_filebuf< CharT, Traits >::_M_extbufend, basic_filebuf< CharT, Traits >::_M_extbufnext, basic_filebuf< CharT, Traits >::_M_file, basic_filebuf< CharT, Traits >::_M_ibs, basic_filebuf< CharT, Traits >::_M_intbuf, basic_filebuf< CharT, Traits >::_M_om, basic_filebuf< CharT, Traits >::_M_owns_eb, basic_filebuf< CharT, Traits >::_M_owns_ib, basic_filebuf< CharT, Traits >::_M_st, basic_filebuf< CharT, Traits >::_M_st_last, rnnlm::n, and kaldi::swap().

Referenced by basic_filebuf< CharT, Traits >::operator=(), and kaldi::swap().

                                                     {
    std::basic_streambuf<char_type, traits_type>::swap(rhs);
    if (_M_extbuf != _M_extbuf_min && rhs._M_extbuf != rhs._M_extbuf_min) {
        std::swap(_M_extbuf, rhs._M_extbuf);
        std::swap(_M_extbufnext, rhs._M_extbufnext);
        std::swap(_M_extbufend, rhs._M_extbufend);
    } else {
        ptrdiff_t ln = _M_extbufnext - _M_extbuf;
        ptrdiff_t le = _M_extbufend - _M_extbuf;
        ptrdiff_t rn = rhs._M_extbufnext - rhs._M_extbuf;
        ptrdiff_t re = rhs._M_extbufend - rhs._M_extbuf;
        if (_M_extbuf == _M_extbuf_min && rhs._M_extbuf != rhs._M_extbuf_min) {
            _M_extbuf = rhs._M_extbuf;
            rhs._M_extbuf = rhs._M_extbuf_min;
        } else if (_M_extbuf != _M_extbuf_min &&
            rhs._M_extbuf == rhs._M_extbuf_min) {
            rhs._M_extbuf = _M_extbuf;
            _M_extbuf = _M_extbuf_min;
        }
        _M_extbufnext = _M_extbuf + rn;
        _M_extbufend = _M_extbuf + re;
        rhs._M_extbufnext = rhs._M_extbuf + ln;
        rhs._M_extbufend = rhs._M_extbuf + le;
    }
    std::swap(_M_ebs, rhs._M_ebs);
    std::swap(_M_intbuf, rhs._M_intbuf);
    std::swap(_M_ibs, rhs._M_ibs);
    std::swap(_M_file, rhs._M_file);
    std::swap(_M_cv, rhs._M_cv);
    std::swap(_M_st, rhs._M_st);
    std::swap(_M_st_last, rhs._M_st_last);
    std::swap(_M_om, rhs._M_om);
    std::swap(_M_cm, rhs._M_cm);
    std::swap(_M_owns_eb, rhs._M_owns_eb);
    std::swap(_M_owns_ib, rhs._M_owns_ib);
    std::swap(_M_always_noconv, rhs._M_always_noconv);
    if (this->eback() == reinterpret_cast<char_type*>(rhs._M_extbuf_min)) {
        ptrdiff_t n = this->gptr() - this->eback();
        ptrdiff_t e = this->egptr() - this->eback();
        this->setg(reinterpret_cast<char_type*>(_M_extbuf_min),
                   reinterpret_cast<char_type*>(_M_extbuf_min) + n,
                   reinterpret_cast<char_type*>(_M_extbuf_min) + e);
    } else if (this->pbase() ==
               reinterpret_cast<char_type*>(rhs._M_extbuf_min)) {
        ptrdiff_t n = this->pptr() - this->pbase();
        ptrdiff_t e = this->epptr() - this->pbase();
        this->setp(reinterpret_cast<char_type*>(_M_extbuf_min),
                   reinterpret_cast<char_type*>(_M_extbuf_min) + e);
        this->pbump(n);
    }
    if (rhs.eback() == reinterpret_cast<char_type*>(_M_extbuf_min)) {
        ptrdiff_t n = rhs.gptr() - rhs.eback();
        ptrdiff_t e = rhs.egptr() - rhs.eback();
        rhs.setg(reinterpret_cast<char_type*>(rhs._M_extbuf_min),
                 reinterpret_cast<char_type*>(rhs._M_extbuf_min) + n,
                 reinterpret_cast<char_type*>(rhs._M_extbuf_min) + e);
    } else if (rhs.pbase() == reinterpret_cast<char_type*>(_M_extbuf_min)) {
        ptrdiff_t n = rhs.pptr() - rhs.pbase();
        ptrdiff_t e = rhs.epptr() - rhs.pbase();
        rhs.setp(reinterpret_cast<char_type*>(rhs._M_extbuf_min),
                 reinterpret_cast<char_type*>(rhs._M_extbuf_min) + e);
        rhs.pbump(n);
    }
}

sync()

int sync ( )

overrideprotected

Definition at line 648 of file basic-filebuf.h.

References basic_filebuf< CharT, Traits >::_M_always_noconv, basic_filebuf< CharT, Traits >::_M_cm, basic_filebuf< CharT, Traits >::_M_cv, basic_filebuf< CharT, Traits >::_M_ebs, basic_filebuf< CharT, Traits >::_M_extbuf, basic_filebuf< CharT, Traits >::_M_extbufend, basic_filebuf< CharT, Traits >::_M_extbufnext, basic_filebuf< CharT, Traits >::_M_file, basic_filebuf< CharT, Traits >::_M_st, basic_filebuf< CharT, Traits >::_M_st_last, and basic_filebuf< CharT, Traits >::overflow().

Referenced by basic_filebuf< CharT, Traits >::close(), basic_filebuf< CharT, Traits >::fd(), basic_filebuf< CharT, Traits >::imbue(), basic_filebuf< CharT, Traits >::seekoff(), and basic_filebuf< CharT, Traits >::seekpos().

                                   {
    if (_M_file == nullptr)
        return 0;
    if (!_M_cv)
        throw std::bad_cast();
    if (_M_cm & std::ios_base::out) {
        if (this->pptr() != this->pbase())
            if (overflow() == traits_type::eof())
                return -1;
        std::codecvt_base::result r;
        do {
            char* extbe;
            r = _M_cv->unshift(_M_st, _M_extbuf, _M_extbuf + _M_ebs, extbe);
            size_t nmemb = static_cast<size_t>(extbe - _M_extbuf);
            if (fwrite(_M_extbuf, 1, nmemb, _M_file) != nmemb)
                return -1;
        } while (r == std::codecvt_base::partial);
        if (r == std::codecvt_base::error)
            return -1;
        if (fflush(_M_file))
            return -1;
    } else if (_M_cm & std::ios_base::in) {
        off_type c;
        state_type state = _M_st_last;
        bool update_st = false;
        if (_M_always_noconv) {
            c = this->egptr() - this->gptr();
        } else {
            int width = _M_cv->encoding();
            c = _M_extbufend - _M_extbufnext;
            if (width > 0) {
                c += width * (this->egptr() - this->gptr());
            } else {
                if (this->gptr() != this->egptr()) {
                    const int off = _M_cv->length(state, _M_extbuf,
                                                  _M_extbufnext,
                                                  this->gptr() - this->eback());
                    c += _M_extbufnext - _M_extbuf - off;
                    update_st = true;
                }
            }
        }
#if _WIN32
        if (fseek(_M_file_, -c, SEEK_CUR))
            return -1;
#else
        if (fseeko(_M_file, -c, SEEK_CUR))
            return -1;
#endif
        if (update_st)
            _M_st = state;
        _M_extbufnext = _M_extbufend = _M_extbuf;
        this->setg(0, 0, 0);
        _M_cm = std::ios_base::openmode(0);
    }
    return 0;
}

underflow()

basic_filebuf< CharT, Traits >::int_type underflow ( )

overrideprotected

Definition at line 409 of file basic-filebuf.h.

References basic_filebuf< CharT, Traits >::_M_always_noconv, basic_filebuf< CharT, Traits >::_M_cv, basic_filebuf< CharT, Traits >::_M_ebs, basic_filebuf< CharT, Traits >::_M_extbuf, basic_filebuf< CharT, Traits >::_M_extbuf_min, basic_filebuf< CharT, Traits >::_M_extbufend, basic_filebuf< CharT, Traits >::_M_extbufnext, basic_filebuf< CharT, Traits >::_M_file, basic_filebuf< CharT, Traits >::_M_ibs, basic_filebuf< CharT, Traits >::_M_read_mode(), basic_filebuf< CharT, Traits >::_M_st, and basic_filebuf< CharT, Traits >::_M_st_last.

Referenced by basic_filebuf< CharT, Traits >::fd().

                                        {
    if (_M_file == nullptr)
        return traits_type::eof();
    bool initial = _M_read_mode();
    char_type buf;
    if (this->gptr() == nullptr)
        this->setg(&buf, &buf+1, &buf+1);
    const size_t unget_sz = initial ? 0 : std::
      min<size_t>((this->egptr() - this->eback()) / 2, 4);
    int_type c = traits_type::eof();
    if (this->gptr() == this->egptr()) {
        memmove(this->eback(), this->egptr() - unget_sz,
            unget_sz * sizeof(char_type));
        if (_M_always_noconv) {
            size_t nmemb = static_cast<size_t>
              (this->egptr() - this->eback() - unget_sz);
            nmemb = fread(this->eback() + unget_sz, 1, nmemb, _M_file);
            if (nmemb != 0) {
                this->setg(this->eback(),
                           this->eback() + unget_sz,
                           this->eback() + unget_sz + nmemb);
                c = traits_type::to_int_type(*this->gptr());
            }
        } else {
            memmove(_M_extbuf, _M_extbufnext, _M_extbufend - _M_extbufnext);
            _M_extbufnext = _M_extbuf + (_M_extbufend - _M_extbufnext);
            _M_extbufend = _M_extbuf +
              (_M_extbuf == _M_extbuf_min ? sizeof(_M_extbuf_min) : _M_ebs);
            size_t nmemb = std::min(static_cast<size_t>(_M_ibs - unget_sz),
                                    static_cast<size_t>
                                    (_M_extbufend - _M_extbufnext));
            std::codecvt_base::result r;
            _M_st_last = _M_st;
            size_t nr = fread(
                reinterpret_cast<void*>(const_cast<char_type*>(_M_extbufnext)),
                1, nmemb, _M_file);
            if (nr != 0) {
                if (!_M_cv)
                    throw std::bad_cast();
                _M_extbufend = _M_extbufnext + nr;
                char_type*  inext;
                r = _M_cv->in(_M_st, _M_extbuf, _M_extbufend, _M_extbufnext,
                              this->eback() + unget_sz,
                              this->eback() + _M_ibs, inext);
                if (r == std::codecvt_base::noconv) {
                    this->setg(reinterpret_cast<char_type*>(_M_extbuf),
                               reinterpret_cast<char_type*>(_M_extbuf),
                               const_cast<char_type*>(_M_extbufend));
                    c = traits_type::to_int_type(*this->gptr());
                } else if (inext != this->eback() + unget_sz) {
                    this->setg(this->eback(), this->eback() + unget_sz, inext);
                    c = traits_type::to_int_type(*this->gptr());
                }
            }
        }
    } else {
        c = traits_type::to_int_type(*this->gptr());
    }
    if (this->eback() == &buf)
        this->setg(0, 0, 0);
    return c;
}

Member Data Documentation

_M_always_noconv

bool _M_always_noconv

protected

Definition at line 82 of file basic-filebuf.h.

Referenced by basic_filebuf< CharT, Traits >::_M_read_mode(), basic_filebuf< CharT, Traits >::_M_write_mode(), basic_filebuf< CharT, Traits >::basic_filebuf(), basic_filebuf< CharT, Traits >::imbue(), basic_filebuf< CharT, Traits >::overflow(), basic_filebuf< CharT, Traits >::setbuf(), basic_filebuf< CharT, Traits >::swap(), basic_filebuf< CharT, Traits >::sync(), and basic_filebuf< CharT, Traits >::underflow().

_M_cm

std::ios_base::openmode _M_cm

protected

Definition at line 79 of file basic-filebuf.h.

Referenced by basic_filebuf< CharT, Traits >::_M_read_mode(), basic_filebuf< CharT, Traits >::_M_write_mode(), basic_filebuf< CharT, Traits >::basic_filebuf(), basic_filebuf< CharT, Traits >::swap(), and basic_filebuf< CharT, Traits >::sync().

_M_cv

const std::codecvt<char_type, char, state_type>* _M_cv

protected

Definition at line 75 of file basic-filebuf.h.

Referenced by basic_filebuf< CharT, Traits >::basic_filebuf(), basic_filebuf< CharT, Traits >::imbue(), basic_filebuf< CharT, Traits >::overflow(), basic_filebuf< CharT, Traits >::seekoff(), basic_filebuf< CharT, Traits >::swap(), basic_filebuf< CharT, Traits >::sync(), and basic_filebuf< CharT, Traits >::underflow().

_M_ebs

size_t _M_ebs

protected

Definition at line 71 of file basic-filebuf.h.

Referenced by basic_filebuf< CharT, Traits >::_M_read_mode(), basic_filebuf< CharT, Traits >::_M_write_mode(), basic_filebuf< CharT, Traits >::basic_filebuf(), basic_filebuf< CharT, Traits >::imbue(), basic_filebuf< CharT, Traits >::overflow(), basic_filebuf< CharT, Traits >::setbuf(), basic_filebuf< CharT, Traits >::swap(), basic_filebuf< CharT, Traits >::sync(), and basic_filebuf< CharT, Traits >::underflow().

_M_extbuf

char* _M_extbuf

protected

Definition at line 67 of file basic-filebuf.h.

Referenced by basic_filebuf< CharT, Traits >::_M_read_mode(), basic_filebuf< CharT, Traits >::_M_write_mode(), basic_filebuf< CharT, Traits >::basic_filebuf(), basic_filebuf< CharT, Traits >::imbue(), basic_filebuf< CharT, Traits >::overflow(), basic_filebuf< CharT, Traits >::setbuf(), basic_filebuf< CharT, Traits >::swap(), basic_filebuf< CharT, Traits >::sync(), basic_filebuf< CharT, Traits >::underflow(), and basic_filebuf< CharT, Traits >::~basic_filebuf().

_M_extbuf_min

char _M_extbuf_min[8]

protected

Definition at line 70 of file basic-filebuf.h.

Referenced by basic_filebuf< CharT, Traits >::_M_write_mode(), basic_filebuf< CharT, Traits >::basic_filebuf(), basic_filebuf< CharT, Traits >::imbue(), basic_filebuf< CharT, Traits >::setbuf(), basic_filebuf< CharT, Traits >::swap(), and basic_filebuf< CharT, Traits >::underflow().

_M_extbufend

const char* _M_extbufend

protected

Definition at line 69 of file basic-filebuf.h.

Referenced by basic_filebuf< CharT, Traits >::basic_filebuf(), basic_filebuf< CharT, Traits >::swap(), basic_filebuf< CharT, Traits >::sync(), and basic_filebuf< CharT, Traits >::underflow().

_M_extbufnext

const char* _M_extbufnext

protected

Definition at line 68 of file basic-filebuf.h.

Referenced by basic_filebuf< CharT, Traits >::basic_filebuf(), basic_filebuf< CharT, Traits >::swap(), basic_filebuf< CharT, Traits >::sync(), and basic_filebuf< CharT, Traits >::underflow().

_M_file

FILE* _M_file

protected

Definition at line 74 of file basic-filebuf.h.

Referenced by basic_filebuf< CharT, Traits >::basic_filebuf(), basic_filebuf< CharT, Traits >::close(), basic_filebuf< CharT, Traits >::fd(), basic_filebuf< CharT, Traits >::file(), basic_filebuf< CharT, Traits >::is_open(), basic_filebuf< CharT, Traits >::open(), basic_filebuf< CharT, Traits >::overflow(), basic_filebuf< CharT, Traits >::pbackfail(), basic_filebuf< CharT, Traits >::seekoff(), basic_filebuf< CharT, Traits >::seekpos(), basic_filebuf< CharT, Traits >::swap(), basic_filebuf< CharT, Traits >::sync(), and basic_filebuf< CharT, Traits >::underflow().

_M_ibs

size_t _M_ibs

protected

Definition at line 73 of file basic-filebuf.h.

Referenced by basic_filebuf< CharT, Traits >::_M_read_mode(), basic_filebuf< CharT, Traits >::_M_write_mode(), basic_filebuf< CharT, Traits >::basic_filebuf(), basic_filebuf< CharT, Traits >::imbue(), basic_filebuf< CharT, Traits >::setbuf(), basic_filebuf< CharT, Traits >::swap(), and basic_filebuf< CharT, Traits >::underflow().

_M_intbuf

char_type* _M_intbuf

protected

Definition at line 72 of file basic-filebuf.h.

Referenced by basic_filebuf< CharT, Traits >::_M_read_mode(), basic_filebuf< CharT, Traits >::_M_write_mode(), basic_filebuf< CharT, Traits >::basic_filebuf(), basic_filebuf< CharT, Traits >::imbue(), basic_filebuf< CharT, Traits >::setbuf(), basic_filebuf< CharT, Traits >::swap(), and basic_filebuf< CharT, Traits >::~basic_filebuf().

_M_om

std::ios_base::openmode _M_om

protected

Definition at line 78 of file basic-filebuf.h.

Referenced by basic_filebuf< CharT, Traits >::basic_filebuf(), basic_filebuf< CharT, Traits >::open(), basic_filebuf< CharT, Traits >::pbackfail(), and basic_filebuf< CharT, Traits >::swap().

_M_owns_eb

bool _M_owns_eb

protected

Definition at line 80 of file basic-filebuf.h.

Referenced by basic_filebuf< CharT, Traits >::basic_filebuf(), basic_filebuf< CharT, Traits >::imbue(), basic_filebuf< CharT, Traits >::setbuf(), basic_filebuf< CharT, Traits >::swap(), and basic_filebuf< CharT, Traits >::~basic_filebuf().

_M_owns_ib

bool _M_owns_ib

protected

Definition at line 81 of file basic-filebuf.h.

Referenced by basic_filebuf< CharT, Traits >::basic_filebuf(), basic_filebuf< CharT, Traits >::imbue(), basic_filebuf< CharT, Traits >::setbuf(), basic_filebuf< CharT, Traits >::swap(), and basic_filebuf< CharT, Traits >::~basic_filebuf().

_M_st

state_type _M_st

protected

Definition at line 76 of file basic-filebuf.h.

Referenced by basic_filebuf< CharT, Traits >::basic_filebuf(), basic_filebuf< CharT, Traits >::overflow(), basic_filebuf< CharT, Traits >::seekoff(), basic_filebuf< CharT, Traits >::seekpos(), basic_filebuf< CharT, Traits >::swap(), basic_filebuf< CharT, Traits >::sync(), and basic_filebuf< CharT, Traits >::underflow().

_M_st_last

state_type _M_st_last

protected

Definition at line 77 of file basic-filebuf.h.

Referenced by basic_filebuf< CharT, Traits >::basic_filebuf(), basic_filebuf< CharT, Traits >::swap(), basic_filebuf< CharT, Traits >::sync(), and basic_filebuf< CharT, Traits >::underflow().

---

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

• util/basic-filebuf.h