streambuf

Go to the documentation of this file.

// Stream buffer classes -*- C++ -*-

// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library.  This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 2, or (at your option)
// any later version.

// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING.  If not, write to the Free
// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
// USA.

// As a special exception, you may use this file as part of a free software
// library without restriction.  Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License.  This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.

//
// ISO C++ 14882: 27.5  Stream buffers
//

#ifndef _GLIBXX_STREAMBUF
#define _GLIBXX_STREAMBUF 1

#pragma GCC system_header

#include <bits/c++config.h>
#include <iosfwd>
#include <bits/localefwd.h>
#include <bits/ios_base.h>

namespace std
{
  template<typename _CharT, typename _Traits>
    streamsize
    __copy_streambufs(basic_streambuf<_CharT, _Traits>* __sbin,
              basic_streambuf<_CharT, _Traits>* __sbout);
  
  template<typename _CharT, typename _Traits>
    class basic_streambuf 
    {
    public:

      typedef _CharT                    char_type;
      typedef _Traits                   traits_type;
      typedef typename traits_type::int_type        int_type;
      typedef typename traits_type::pos_type        pos_type;
      typedef typename traits_type::off_type        off_type;


      typedef basic_streambuf<char_type, traits_type>   __streambuf_type;
      
      friend class basic_ios<char_type, traits_type>;
      friend class basic_istream<char_type, traits_type>;
      friend class basic_ostream<char_type, traits_type>;
      friend class istreambuf_iterator<char_type, traits_type>;
      friend class ostreambuf_iterator<char_type, traits_type>;

      friend streamsize
      __copy_streambufs<>(__streambuf_type* __sbin,
              __streambuf_type* __sbout);
      
      template<typename _CharT2, typename _Traits2>
        friend basic_istream<_CharT2, _Traits2>&
        operator>>(basic_istream<_CharT2, _Traits2>&, _CharT2*);
      
      template<typename _CharT2, typename _Traits2, typename _Alloc>
        friend basic_istream<_CharT2, _Traits2>&
        operator>>(basic_istream<_CharT2, _Traits2>&,
           basic_string<_CharT2, _Traits2, _Alloc>&);
      
      template<typename _CharT2, typename _Traits2, typename _Alloc>
        friend basic_istream<_CharT2, _Traits2>&
        getline(basic_istream<_CharT2, _Traits2>&,
        basic_string<_CharT2, _Traits2, _Alloc>&, _CharT2);

    protected:

      char_type*        _M_in_beg;     // Start of get area. 
      char_type*        _M_in_cur;     // Current read area. 
      char_type*        _M_in_end;     // End of get area. 
      char_type*        _M_out_beg;    // Start of put area. 
      char_type*        _M_out_cur;    // Current put area. 
      char_type*        _M_out_end;    // End of put area.

      locale            _M_buf_locale;  

  public:
      virtual 
      ~basic_streambuf() 
      { }

      // [27.5.2.2.1] locales
      locale 
      pubimbue(const locale &__loc)
      {
    locale __tmp(this->getloc());
    this->imbue(__loc);
    _M_buf_locale = __loc;
    return __tmp;
      }

      locale   
      getloc() const
      { return _M_buf_locale; } 

      // [27.5.2.2.2] buffer management and positioning

      __streambuf_type* 
      pubsetbuf(char_type* __s, streamsize __n) 
      { return this->setbuf(__s, __n); }

      pos_type 
      pubseekoff(off_type __off, ios_base::seekdir __way, 
         ios_base::openmode __mode = ios_base::in | ios_base::out)
      { return this->seekoff(__off, __way, __mode); }

      pos_type 
      pubseekpos(pos_type __sp,
         ios_base::openmode __mode = ios_base::in | ios_base::out)
      { return this->seekpos(__sp, __mode); }

      int 
      pubsync() { return this->sync(); }

      // [27.5.2.2.3] get area
      streamsize 
      in_avail() 
      { 
    const streamsize __ret = this->egptr() - this->gptr();
    return __ret ? __ret : this->showmanyc();
      }

      int_type 
      snextc()
      {
    int_type __ret = traits_type::eof();
    if (__builtin_expect(!traits_type::eq_int_type(this->sbumpc(), 
                               __ret), true))
      __ret = this->sgetc();
    return __ret;
      }

      int_type 
      sbumpc()
      {
    int_type __ret;
    if (__builtin_expect(this->gptr() < this->egptr(), true))
      {
        __ret = traits_type::to_int_type(*this->gptr());
        this->gbump(1);
      }
    else 
      __ret = this->uflow();
    return __ret;
      }

      int_type 
      sgetc()
      {
    int_type __ret;
    if (__builtin_expect(this->gptr() < this->egptr(), true))
      __ret = traits_type::to_int_type(*this->gptr());
    else 
      __ret = this->underflow();
    return __ret;
      }

      streamsize 
      sgetn(char_type* __s, streamsize __n)
      { return this->xsgetn(__s, __n); }

      // [27.5.2.2.4] putback
      int_type 
      sputbackc(char_type __c)
      {
    int_type __ret;
    const bool __testpos = this->eback() < this->gptr();
    if (__builtin_expect(!__testpos || 
                 !traits_type::eq(__c, this->gptr()[-1]), false))
      __ret = this->pbackfail(traits_type::to_int_type(__c));
    else 
      {
        this->gbump(-1);
        __ret = traits_type::to_int_type(*this->gptr());
      }
    return __ret;
      }

      int_type 
      sungetc()
      {
    int_type __ret;
    if (__builtin_expect(this->eback() < this->gptr(), true))
      {
        this->gbump(-1);
        __ret = traits_type::to_int_type(*this->gptr());
      }
    else 
      __ret = this->pbackfail();
    return __ret;
      }

      // [27.5.2.2.5] put area
      int_type 
      sputc(char_type __c)
      {
    int_type __ret;
    if (__builtin_expect(this->pptr() < this->epptr(), true))
      {
        *this->pptr() = __c;
        this->pbump(1);
        __ret = traits_type::to_int_type(__c);
      }
    else
      __ret = this->overflow(traits_type::to_int_type(__c));
    return __ret;
      }

      streamsize 
      sputn(const char_type* __s, streamsize __n)
      { return this->xsputn(__s, __n); }

    protected:
      basic_streambuf()
      : _M_in_beg(0), _M_in_cur(0), _M_in_end(0), 
      _M_out_beg(0), _M_out_cur(0), _M_out_end(0),
      _M_buf_locale(locale()) 
      { }

      // [27.5.2.3.1] get area access

      char_type* 
      eback() const { return _M_in_beg; }

      char_type* 
      gptr()  const { return _M_in_cur;  }

      char_type* 
      egptr() const { return _M_in_end; }

      void 
      gbump(int __n) { _M_in_cur += __n; }

      void 
      setg(char_type* __gbeg, char_type* __gnext, char_type* __gend)
      {
    _M_in_beg = __gbeg;
    _M_in_cur = __gnext;
    _M_in_end = __gend;
      }

      // [27.5.2.3.2] put area access

      char_type* 
      pbase() const { return _M_out_beg; }

      char_type* 
      pptr() const { return _M_out_cur; }

      char_type* 
      epptr() const { return _M_out_end; }

      void 
      pbump(int __n) { _M_out_cur += __n; }

      void 
      setp(char_type* __pbeg, char_type* __pend)
      { 
    _M_out_beg = _M_out_cur = __pbeg; 
    _M_out_end = __pend;
      }

      // [27.5.2.4] virtual functions
      // [27.5.2.4.1] locales
      virtual void 
      imbue(const locale&) 
      { }

      // [27.5.2.4.2] buffer management and positioning
      virtual basic_streambuf<char_type,_Traits>* 
      setbuf(char_type*, streamsize)
      { return this; }
      
      virtual pos_type 
      seekoff(off_type, ios_base::seekdir,
          ios_base::openmode /*__mode*/ = ios_base::in | ios_base::out)
      { return pos_type(off_type(-1)); } 

      virtual pos_type 
      seekpos(pos_type, 
          ios_base::openmode /*__mode*/ = ios_base::in | ios_base::out)
      { return pos_type(off_type(-1)); } 

      virtual int 
      sync() { return 0; }

      // [27.5.2.4.3] get area
      virtual streamsize 
      showmanyc() { return 0; }

      virtual streamsize 
      xsgetn(char_type* __s, streamsize __n);

      virtual int_type 
      underflow()
      { return traits_type::eof(); }

      virtual int_type 
      uflow() 
      {
    int_type __ret = traits_type::eof();
    const bool __testeof = traits_type::eq_int_type(this->underflow(), 
                            __ret);
    if (!__testeof)
      {
        __ret = traits_type::to_int_type(*this->gptr());
        this->gbump(1);
      }
    return __ret;    
      }

      // [27.5.2.4.4] putback
      virtual int_type 
      pbackfail(int_type /* __c */  = traits_type::eof())
      { return traits_type::eof(); }

      // Put area:
      virtual streamsize 
      xsputn(const char_type* __s, streamsize __n);

      virtual int_type 
      overflow(int_type /* __c */ = traits_type::eof())
      { return traits_type::eof(); }

#ifdef _GLIBCXX_DEPRECATED
    // Annex D.6
    public:
      void 
      stossc() 
      {
    if (this->gptr() < this->egptr()) 
      this->gbump(1);
    else 
      this->uflow();
      }
#endif

    private:
      // _GLIBCXX_RESOLVE_LIB_DEFECTS
      // Side effect of DR 50. 
      basic_streambuf(const __streambuf_type& __sb)
      : _M_in_beg(__sb._M_in_beg), _M_in_cur(__sb._M_in_cur), 
      _M_in_end(__sb._M_in_end), _M_out_beg(__sb._M_out_beg), 
      _M_out_cur(__sb._M_out_cur), _M_out_end(__sb._M_out_cur),
      _M_buf_locale(__sb._M_buf_locale) 
      { }

      __streambuf_type& 
      operator=(const __streambuf_type&) { return *this; };
    };

  // Explicit specialization declarations, defined in src/streambuf.cc.
  template<>
    streamsize
    __copy_streambufs(basic_streambuf<char>* __sbin,
              basic_streambuf<char>* __sbout);
#ifdef _GLIBCXX_USE_WCHAR_T
  template<>
    streamsize
    __copy_streambufs(basic_streambuf<wchar_t>* __sbin,
              basic_streambuf<wchar_t>* __sbout);
#endif
} // namespace std

#ifndef _GLIBCXX_EXPORT_TEMPLATE
# include <bits/streambuf.tcc>
#endif

#endif /* _GLIBCXX_STREAMBUF */

---