Stream.h

Go to the documentation of this file.

// Honeycomb, Copyright (C) 2015 NewGamePlus Inc.  Distributed under the Boost Software License v1.0.
#pragma once

#include "Honey/String/ByteStream.h"
#include "Honey/Math/Alge/Alge.h"

namespace honey { namespace net
{


template<class Alloc = std::allocator<byte>>
class StreamBuf_ : public ByteStreamBuf, mt::NoCopy
{
public:
    StreamBuf_(szt maxSize = numeral<szt>().max(), const Alloc& alloc = Alloc()) :
        _maxSize(maxSize),
        _buf(alloc)
    {
        auto pend = Alge::min(_maxSize, buf_delta);
        _buf.resize(Alge::max(pend, 1));
        setg(&_buf[0], &_buf[0], &_buf[0]);
        setp(&_buf[0], &_buf[0] + pend);
    }

    szt size() const                        { return pptr() - gptr(); }
    szt maxSize() const                     { return _maxSize; }
    ByteBufConst data() const               { return ByteBufConst(gptr(), size()); }


    ByteBuf prepare(szt n)                  { reserve(n); return ByteBuf(pptr(), n); }


    void commit(szt n)
    {
        if (pptr() + n > epptr()) n = epptr() - pptr();
        pbump(n);
        setg(eback(), gptr(), pptr());
    }


    void consume(szt n)
    {
        if (egptr() < pptr()) setg(&_buf[0], gptr(), pptr());
        if (gptr() + n > pptr()) n = pptr() - gptr();
        gbump(n);
    }

protected:
    static const int buf_delta = 128;


    int_type underflow()
    {
        if (gptr() < pptr())
        {
            setg(&_buf[0], gptr(), pptr());
            return traits_type::to_int_type(*gptr());
        }
        else
            return traits_type::eof();
    }


    int_type overflow(int_type c)
    {
        if (!traits_type::eq_int_type(c, traits_type::eof()))
        {
            if (pptr() == epptr())
            {
                szt _bufsize = pptr() - gptr();
                if (_bufsize < _maxSize && _maxSize - _bufsize < buf_delta)
                    reserve(_maxSize - _bufsize);
                else
                    reserve(buf_delta);
            }

            *pptr() = traits_type::to_char_type(c);
            pbump(1);
            return c;
        }

        return traits_type::not_eof(c);
    }

    void reserve(szt n)
    {
        //get current stream positions as offsets
        szt gnext = gptr() - &_buf[0];
        szt pnext = pptr() - &_buf[0];
        szt pend = epptr() - &_buf[0];

        //check if there is already enough space in the put area
        if (n <= pend - pnext) return;

        //shift existing contents of get area to start of buffer
        if (gnext > 0)
        {
            pnext -= gnext;
            std::memmove(&_buf[0], &_buf[0] + gnext, pnext);
        }

        //ensure buffer is large enough to hold at least the specified size
        if (n > pend - pnext)
        {
            if (n <= _maxSize && pnext <= _maxSize - n)
            {
                pend = pnext + n;
                _buf.resize(Alge::max(pend, 1));
            }
            else
                throw std::length_error("buffer too large");
        }

        //update stream positions
        setg(&_buf[0], &_buf[0], &_buf[0] + pnext);
        setp(&_buf[0] + pnext, &_buf[0] + pend);
    }

private:
    szt _maxSize;
    vector<byte, Alloc> _buf;
};

typedef StreamBuf_<> StreamBuf;

} }