smstream/memstream.hh

/* -*- mode: c++; c-basic-offset: 4; -*- */
#ifndef MEMSTREAM_HH
#define MEMSTREAM_HH

#include <iostream>
#include <streambuf>
 
template<typename _CharT, typename _Traits = std::char_traits<_CharT> >
class basic_membuf : public std::basic_streambuf< _CharT, _Traits >
{
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 std::basic_streambuf<char_type, traits_type> _streambuf_type;

public:
    basic_membuf(std::ios_base::openmode __mode = std::ios_base::out);

    basic_membuf(char_type* buf, int_type len,
                 std::ios_base::openmode __mode = std::ios_base::out);

    virtual ~basic_membuf(void) {sync();}

protected:
    virtual int_type underflow(void);

    virtual int_type overflow(void) {return traits_type::eof();}

    virtual int_type pbackfail(int_type c) {return traits_type::eof();}

    virtual pos_type seekoff(off_type off, std::ios_base::seekdir way, 
                             std::ios_base::openmode mode);

    virtual pos_type seekpos(pos_type sp, std::ios_base::openmode mode);
    
    virtual basic_membuf<_CharT,_Traits>* setbuf(char_type* buf, int_type len);

    virtual int sync(void) {return 0;}

private:
    std::ios_base::openmode _M_mode;
    char_type* mBuf;
    int_type   mLen;
};

template<typename _CharT, typename _Traits>
inline
basic_membuf<_CharT, _Traits>::basic_membuf(std::ios_base::openmode __mode)
  : mBuf(0), mLen(0)
{
    _M_mode = __mode;
}

template<typename _CharT, typename _Traits>
inline
basic_membuf<_CharT, _Traits>::basic_membuf(char_type* buf, int_type len,
                                            std::ios_base::openmode __mode)
{
    _M_mode = __mode;
    setbuf(buf, len);
}


template<typename _CharT, typename _Traits>
inline typename basic_membuf<_CharT, _Traits>::int_type 
basic_membuf<_CharT, _Traits>::underflow(void) {
    if (this->gptr() < this->egptr()) return traits_type::to_int_type(*this->gptr());
    return traits_type::eof();
}

template<typename _CharT, typename _Traits>
inline basic_membuf<_CharT, _Traits>*
basic_membuf<_CharT, _Traits>::setbuf(char_type* buf, int_type len) 
{
    mBuf = buf;
    mLen = len;
    if ((_M_mode & std::ios_base::in )!=0) this->setg(mBuf, mBuf, mBuf+mLen);
    if ((_M_mode & std::ios_base::out)!=0) this->setp(mBuf, mBuf + mLen);
    return this;
}

template<typename _CharT, typename _Traits>
inline typename basic_membuf<_CharT, _Traits>::pos_type 
basic_membuf<_CharT, _Traits>::seekoff(off_type off, 
                                       std::ios_base::seekdir way,
                                       std::ios_base::openmode mode) {
    off_type ret(-1);
    bool in_mode  = (std::ios_base::in  & _M_mode & mode) != 0;
    bool out_mode = (std::ios_base::out & _M_mode & mode) != 0;
    if (way == std::ios_base::beg) {
        ret = 0;
    } else if (way == std::ios_base::cur) {
        if (out_mode) ret = this->pptr() - mBuf;
        if ( in_mode) ret = this->gptr() - mBuf;
    } else if (way == std::ios_base::end) {
        ret = mLen;
    }
    if (ret != off_type(-1)) {
        ret += off;
        if (!(ret >= 0 && ret <= mLen)) ret = off_type(-1);
    }
    if (ret != off_type(-1)) {
        if ( in_mode) this->setg(mBuf, mBuf+ret, mBuf+mLen);
        if (out_mode) {
           this->setp(mBuf, mBuf + mLen);
           this->pbump(ret);
        }
    }
    return pos_type(ret);
}

template<typename _CharT, typename _Traits>
inline typename basic_membuf<_CharT, _Traits>::pos_type 
basic_membuf<_CharT, _Traits>::seekpos(pos_type sp, 
                                       std::ios_base::openmode mode) {
    return seekoff(off_type(sp), std::ios_base::beg, mode);
}

template<typename _CharT, typename _Traits = std::char_traits<_CharT> >
class basic_imemstream : public std::basic_istream<_CharT, _Traits>
{
public:
    // Types:
    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_membuf<_CharT, _Traits>              __membuf_type;
    typedef std::basic_istream<char_type, traits_type> __istream_type;
 
private:
    __membuf_type  _M_membuf;
 
public:
    // Constructors:
    explicit
    basic_imemstream(std::ios_base::openmode __mode = std::ios_base::in)
      : __istream_type(NULL)
      { this->init(&_M_membuf); }
 
    basic_imemstream(const char_type* __buf, int_type __len,
                        std::ios_base::openmode __mode = std::ios_base::in)
      : __istream_type(NULL), 
        _M_membuf(const_cast<char_type*>(__buf), __len, __mode)
      { this->init(&_M_membuf); }
 
      ~basic_imemstream()
      { }
 
      // Members:
      __membuf_type* rdbuf() const
      { return const_cast<__membuf_type*>(&_M_membuf); }
};


template <typename _CharT, typename _Traits = std::char_traits<_CharT> >
class basic_omemstream : public std::basic_ostream<_CharT, _Traits>
{
public:
    // Types:
    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_membuf<_CharT, _Traits>               __membuf_type;

    typedef std::basic_ostream<char_type, traits_type>  __ostream_type;
 
    private:
      __membuf_type  _M_membuf;
 
    public:
     // Constructors/destructor:
      explicit
      basic_omemstream(std::ios_base::openmode __mode = std::ios_base::out)
      : __ostream_type(NULL), _M_membuf(__mode | std::ios_base::out)
      { this->init(&_M_membuf); }
 
      basic_omemstream(char_type* __buf, int_type __len,
                       std::ios_base::openmode __mode = std::ios_base::out)
        : __ostream_type(NULL), _M_membuf(__buf, __len, __mode | std::ios_base::out)
      { this->init(&_M_membuf); }
 

      ~basic_omemstream()
      { }
 
      // Members:
    __membuf_type*
    rdbuf() const
      { return const_cast<__membuf_type*>(&_M_membuf); }
};

typedef basic_imemstream<char> imemstream;
typedef basic_omemstream<char> omemstream;

#endif

---