ByteBuffer.h

Go to the documentation of this file.

// $Id: ByteBuffer.h 130 2006-05-14 17:11:25Z bingmann $

#ifndef VGS_ByteBuffer_H
#define VGS_ByteBuffer_H

#include <stdlib.h>
#include <assert.h>

#include <string>

namespace VGServer {

class ByteBuffer
{
protected:
    char *_data;

    size_t _size;

    size_t _buff;

public:
    explicit inline ByteBuffer() {
        _data = NULL;
        _size = _buff = 0;
    }

    explicit inline ByteBuffer(size_t n) {
        _data = NULL;
        _size = _buff = 0;
        alloc(n);
    }

    explicit inline ByteBuffer(const ByteBuffer &o) {
        _data = NULL;
        _size = _buff = 0;
        assign_copy(o.data(), o.size());
    }

    inline ByteBuffer& operator=(const ByteBuffer &o) {
        assign_copy(o.data(), o.size());
        return *this;
    }

    virtual ~ByteBuffer() {
        dealloc();
    }

    inline const char *data() const
    { return _data; }

    inline char *data()
    { return _data; }

    inline size_t size() const
    { return _size; }

    inline size_t buffsize() const
    { return _buff; }

    inline bool empty() const
    { return size() == 0; }

    inline void set_size(size_t s)
    { assert(s <= _buff); _size = s; }

    inline operator std::string() const
    { return std::string(_data, _size); }

    inline std::string toString() const
    { return std::string(_data, _size); }

    inline void clear()
    { _size = 0; }

    virtual void alloc(size_t n)
    {
        if (_size < n)
        {
            _size = _buff = n;
            _data = static_cast<char*>(realloc(_data, _size));
        }
    }

    virtual void grow(size_t n)
    {
        if (_buff < n)
        {
            // place to adapt the buffer growing algorithm as need.
            while(_buff < n) {
                if (_buff < 256) _buff = 512;
                else if (_buff < 1024*1024) _buff = 2*_buff;
                else _buff += 1024*1024;
            }

            _data = static_cast<char*>(realloc(_data, _buff));
        }
    }

    inline void dealloc()
    {
        if (_data) free(_data);
        _data = NULL;
        _size = _buff = 0;
    }

    inline const char *detach() {
        const char *data = _data;
        _data = NULL;
        _size = _buff = 0;
        return data;
    }

    inline std::pair<const char*, size_t> detach_pair()
    {
        std::pair<const char*, size_t> pair(_data, _size);
        _data = NULL;
        _size = 0;
        return pair;
    }

    inline void assign_keep(void *data, size_t len)
    {
        dealloc();
        _data = static_cast<char*>(data);
        _size = _buff = len;
    }

    inline void assign_copy(const void *data, size_t len)
    {
        if (_buff < len) alloc(len);

        memcpy(_data, data, len);
        _size = len;
    }
};

} // namespace VGServer

#endif // VGS_ByteBuffer_H

---