auto_buf.h

Go to the documentation of this file.

/*  auto_buf.h - Growable buffer class, munged from ostream
    Copyright (C) 2001-2004 Mark Weaver
    Written by Mark Weaver <mark@npsl.co.uk>

    Part of the Open-Win32 library.
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, 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
    Library General Public License for more details.

    You should have received a copy of the GNU Library General Public
    License along with this library; if not, write to the
    Free Software Foundation, Inc., 59 Temple Place - Suite 330,
    Boston, MA  02111-1307, USA.
*/

#ifndef OW32_auto_buf_h
#define OW32_auto_buf_h

#include <cstddef>   // for size_t
#include <stdexcept> // for bad_alloc, logic_error

namespace OW32
{

template <class E>
class auto_buf
{
protected:
    size_t  m_length;
    size_t  m_capacity;
    size_t  m_pos;
    E*      m_buf;

    void grow(size_t n) {
        // any need to realloc?
        if (n <= m_capacity)
            return;

        E* newbuf = (E*)realloc(m_buf, sizeof(E*)*n);
        if (!newbuf)
            throw std::bad_alloc();

        m_capacity = n;
        m_buf = newbuf;
    }

    void extendp(size_t n) {
        size_t max_sz = static_cast<size_t>(-1);

        // Check for integer overflow
        if (max_sz - m_pos < n)
            throw std::length_error("auto_buf<E> length overflow");

        // Check for capacity overflow
        if (m_pos + n > m_capacity)
        {
            // +50% growth policy
            size_t newcap;

            // Check for overflow in growth
            if (max_sz - m_capacity / 2 < m_capacity)
                newcap = m_pos + n;
            else
            {
                newcap = m_capacity + m_capacity / 2;
                if (newcap < m_pos + n)
                    newcap = m_pos + n;
            }

            // Grow to fit
            E* newbuf = (E*)realloc(m_buf, sizeof(E*)*newcap);
            if (!newbuf)
                throw std::bad_alloc();

            m_capacity = newcap;
            m_buf = newbuf;
        }
    }

public:
    enum seekdir { 
        beg,
        cur,
        end
    };

    auto_buf() : /* throw() */
        m_capacity(0),
        m_length(0),
        m_pos(0),
        m_buf(0)
    {
    }

    auto_buf(const E* s) :
        m_capacity(0),
        m_length(0),
        m_pos(0),
        m_buf(0)
    {
        (void)write(s);
    }

    auto_buf(const E* s, size_t n) :
        m_capacity(0),
        m_length(0),
        m_pos(0),
        m_buf(0)
    {
        (void)write(s,n);
    }

    auto_buf(const auto_buf& rhs)
    {
        (void)operator=(rhs);
    }

    auto_buf& operator= (const auto_buf& rhs)
    {
        // allocate
        grow(rhs.m_capacity);

        // copy
        memcpy(m_buf, rhs.m_buf, rhs.m_capacity);
        m_capacity = rhs.m_capacity;
        m_length = rhs.m_length;
        m_pos = rhs.m_pos;

        return *this;
    }

    ~auto_buf()
    {
        if (m_buf) free(m_buf);
    }

    size_t length() const { return m_length; }

    size_t count() const { return m_length; }

    size_t size() const { return m_length; }

    E* detach() {
        E* buf = m_buf;
        m_buf = 0;
        m_capacity = m_length = m_pos = 0;
        return buf;
    }

    void attach(E* buf, size_t capacity) {
        if (m_buf) free(m_buf);
        m_buf = buf;
        m_length = m_capacity = capacity;
        m_pos = 0;
    }

    void resize(size_t n) {
        grow(n);
        m_length = n;
        if (m_pos > m_length) m_pos = m_length;
    }

    void reserve(size_t n) {
        grow(n);
    }

    size_t capacity() const {
        return m_capacity;
    }

    void clear() {
        m_length = m_pos = 0;
    }

    void reset() {
        if (m_buf) {
            free(m_buf);
            m_buf = 0;
        }
        m_length = m_pos = m_capacity = 0;
    }

    void put(E c) {
        extendp(1);
        m_buf[m_pos++] = c;
        // extend the buffer if required
        if (m_pos > m_length) m_length = m_pos;
    }

    size_t write(const E* s, size_t n) {
        extendp(n);
        memcpy(m_buf + m_pos, s, sizeof(E)*n);
        m_pos += n;
        // extend the buffer if required
        if (m_pos > m_length) m_length = m_pos;
        return n;
    }

    size_t write(const E* s) {
        size_t n = 0;
        const E* p = s;
        while (*p++ != E(0)) ++n;
        return write(s, n);
    }

    size_t tellp() const {
        return m_pos;
    }

    void seekp(size_t p) {
        if (p > m_length) {
            grow(p);
            m_length = p;
        }
        m_pos = p;
    }

    void seekp(int off, seekdir way) {
        size_t newpos;

        switch (way) {
        case beg:
            seekp((size_t)off);
            return;
        case cur:
            newpos = size_t(m_pos+off);
            break;
        case end:
            newpos = size_t(m_length+off);
            break;
        default:
            throw std::logic_error("auto_buf::seekp - invalid way parameter");
        }
        if (newpos > m_length) {
            grow(newpos);
            m_length = newpos;
        }
        m_pos = newpos;
    }

    E* str() const {
        return m_buf;
    }

    E* cstr() const {
        return m_buf + m_pos;
    }

    auto_buf& operator<< (const E& c) {
        put(c);
        return *this;
    }

    auto_buf& operator<< (const E* s) {
        (void)write(s);
        return *this;
    }

    E& operator[](size_t offset) {
        return m_buf[offset];
    }

    const E& operator[](size_t offset) const {
        return m_buf[offset];
    }
};

typedef auto_buf<char> auto_char_buf;

class auto_byte_buf : public auto_buf<unsigned char>
{
public:
    auto_byte_buf() {}

    auto_byte_buf(const unsigned char* s, size_t n) :
        auto_buf<unsigned char>(s, n) {}

    auto_byte_buf(const unsigned char* s) :
        auto_buf<unsigned char>(s) {}

    size_t write(const void* s, size_t n) {
        return auto_buf<unsigned char>::write((const unsigned char*)s, n);
    }

    size_t write(const unsigned char* s) {
        return auto_buf<unsigned char>::write((const unsigned char*)s);
    }

    size_t write(const char* s) {
        return auto_buf<unsigned char>::write((const unsigned char*)s);
    }

    auto_byte_buf& operator<< (const char c) {
        put((unsigned char)c);
        return *this;
    }

    auto_byte_buf& operator<< (const char* s) {
        (void)auto_buf<unsigned char>::write((const unsigned char*)s);
        return *this;
    }

    auto_byte_buf& operator<< (const unsigned char& c) {
        put(c);
        return *this;
    }

    auto_byte_buf& operator<< (const unsigned char* s) {
        (void)auto_buf<unsigned char>::write(s);
        return *this;
    }
};

typedef auto_buf<short> auto_short_buf;
typedef auto_buf<unsigned short> auto_ushort_buf;

typedef auto_buf<int> auto_int_buf;
typedef auto_buf<unsigned int> auto_uint_buf;

} // namespace OW32

#endif // OW32_auto_buf_h

---