BufferStreambuf.hh

Go to the documentation of this file.

#ifndef avro_BufferStreambuf_hh__
#define avro_BufferStreambuf_HH__

#include "Buffer.hh"

namespace avro {

class ostreambuf : public std::streambuf {

  public:

    ostreambuf() : 
        std::streambuf(),
        buffer_()
    { }

    explicit ostreambuf(OutputBuffer &buffer) :
        std::streambuf(),
        buffer_( buffer )
    { }

    const OutputBuffer &getBuffer() const {
        return buffer_;
    }

  protected:
    
    virtual int_type overflow(int_type c) 
    {
        buffer_.writeTo(static_cast<OutputBuffer::data_type>(c));
        return c;
    }

    virtual std::streamsize xsputn(const char_type *s, std::streamsize n) 
    {
        return buffer_.writeTo(s, n);
    }

  private:

    OutputBuffer buffer_;
};

class istreambuf : public std::streambuf {

  public:

    explicit istreambuf(const InputBuffer &buffer) :
        std::streambuf(),
        buffer_( buffer ),
        basePos_(0),
        iter_(buffer_.begin())
    { 
        setBuffer();
    }

    explicit istreambuf(const OutputBuffer &buffer) :
        std::streambuf(),
        buffer_( buffer, InputBuffer::ShallowCopy()),
        basePos_(0),
        iter_(buffer_.begin())
    { 
        setBuffer();
    }

    const InputBuffer &getBuffer() const {
        return buffer_;
    }

  protected:

    virtual int_type underflow() {
        if(iter_ != buffer_.end()) {
            basePos_ += (egptr()-eback());
            ++iter_;
        }
        return setBuffer();
    }

    virtual std::streamsize xsgetn(char_type *c, std::streamsize len) 
    {
        std::streamsize bytesCopied = 0;

        while (bytesCopied < len) {

            size_t inBuffer = egptr() - gptr();

            if (inBuffer) {
                size_t remaining = len - bytesCopied;
                size_t toCopy = std::min(inBuffer, remaining);
                memcpy(c, gptr(), toCopy);
                c += toCopy;
                bytesCopied += toCopy;
                gbump(toCopy);
            }

            if(bytesCopied < len) {
                underflow();
                if(iter_ == buffer_.end()) {
                    break;
                }
            }
        }

        return bytesCopied;
    }

    virtual pos_type seekoff(off_type off, std::ios::seekdir dir, std::_Ios_Openmode) {

        off_type curpos = basePos_ + (gptr() - eback()); 
        off_type newpos = off;

        if(dir == std::ios::cur) {
            newpos += curpos;
        }
        else if (dir == std::ios::end) {
            newpos += buffer_.size();
        }
        // short circuit for tell()  
        if(newpos == curpos) {
            return curpos;
        }

        off_type endpos = basePos_ + (egptr() - eback());

        // if the position is after our current buffer make
        // sure it's not past the end of the buffer
        if((newpos > endpos) && (newpos > static_cast<off_type>(buffer_.size()) )) {
            return pos_type(-1);
        }
        // if the new position is before our current iterator
        // reset the iterator to the beginning
        else if (newpos < basePos_) {
            iter_ = buffer_.begin();
            basePos_ = 0;
            setBuffer();
            endpos = (egptr() -eback());
        }

        // now if the new position is after the end of the buffer
        // increase the buffer until it is not
        while (newpos > endpos) {
            istreambuf::underflow();
            endpos = basePos_ + (egptr() - eback()); 
        }

        setg(eback(), eback() + (newpos - basePos_), egptr());
        return newpos;
    }

    virtual pos_type seekpos(pos_type pos, std::_Ios_Openmode) {
        return istreambuf::seekoff(pos, std::ios::beg, std::_Ios_Openmode(0));
    }
    
    virtual std::streamsize showmanyc() {

        // this function only gets called when the current buffer has been
        // completely read, verify this is the case, and if so, underflow to
        // fetch the next buffer

        if(egptr() - gptr() == 0) {
            istreambuf::underflow();
        }
        return egptr() - gptr();
    }

  private:
    
    int_type setBuffer() {
        int_type ret = traits_type::eof();

        if(iter_ != buffer_.end()) {
            char *loc = const_cast <char *> (iter_->data()) ;
            setg(loc, loc, loc + iter_->size());
            ret = *gptr();
        }
        else {
            setg(0,0,0);
        }
        return ret;
    }

    const InputBuffer buffer_;
    off_type basePos_;
    InputBuffer::const_iterator iter_;
};

} // namespace

#endif