1
0
Fork 0
mirror of https://github.com/AquariaOSE/Aquaria.git synced 2024-12-25 06:05:45 +00:00
Aquaria/ExternalLibs/ByteBuffer.h
2012-09-24 02:26:39 +02:00

521 lines
12 KiB
C++

#ifndef BYTEBUFFER_H
#define BYTEBUFFER_H
#include <stdlib.h>
#include <string.h> // for memcpy
#include <stdio.h>
#include <string>
#include <algorithm>
#if defined(__GNUC__) && __GNUC__ <= 2
# define BB_OLD_GNUC
#endif
// ** compatibility stuff for BBGE .... **
#define BYTEBUFFER_NO_EXCEPTIONS
// from SDL headers
#if defined(__hppa__) || \
defined(__m68k__) || defined(mc68000) || defined(_M_M68K) || \
(defined(__MIPS__) && defined(__MISPEB__)) || \
defined(__ppc__) || defined(__POWERPC__) || defined(_M_PPC) || \
defined(__sparc__)
#define BB_IS_BIG_ENDIAN 1
#endif
// ****
namespace ByteBufferTools
{
template<int T> inline void convert(char *val)
{
std::swap(*val, *(val + T - 1));
convert<T - 2>(val + 1);
}
template<> inline void convert<0>(char *) {}
template<> inline void convert<1>(char *) {}
template<typename T> inline void EndianConvert(T *val)
{
convert<sizeof(T)>((char *)(val));
}
inline void EndianConvertRT(char *p, unsigned int size)
{
std::reverse(p, p + size);
}
#if BB_IS_BIG_ENDIAN
template<typename T> inline void ToLittleEndian(T& val) { EndianConvert<T>(&val); }
inline void ToLittleEndianRT(void *p, unsigned int size) { EndianConvertRT((char*)p, size); }
template<typename T> inline void ToBigEndian(T&) { }
inline void ToBigEndianRT(void *p, unsigned int size) { }
#else
template<typename T> inline void ToLittleEndian(T&) { }
inline void ToLittleEndianRT(void *p, unsigned int size) { }
template<typename T> inline void ToBigEndian(T& val) { EndianConvert<T>(&val); }
inline void ToBigEndianRT(void *p, unsigned int size) { EndianConvertRT((char*)p, size); }
#endif
template<typename T> void ToLittleEndian(T*); // will generate link error
template<typename T> void ToBigEndian(T*); // will generate link error
};
#ifdef BB_OLD_GNUC
# define BB_MAKE_WRITE_OP(T) inline ByteBuffer& operator<<(T val) { appendT(&val, sizeof(T)); return *this; }
# define BB_MAKE_READ_OP(T) inline ByteBuffer& operator>>(T &val) { readT(&val, sizeof(T)); return *this; }
#else
# define BB_MAKE_WRITE_OP(T) inline ByteBuffer& operator<<(T val) { append<T>(val); return *this; }
# define BB_MAKE_READ_OP(T) inline ByteBuffer& operator>>(T &val) { val = read<T>(); return *this; }
#endif
class ByteBuffer
{
public:
typedef void (*delete_func)(void*);
typedef void *(*allocator_func)(size_t);
enum Mode // for creation with existing pointers
{
COPY, //- Make a copy of the buffer (default action).
REUSE, //- Use the passed-in buffer as is. Requires the pointer
// to remain valid over the life of this object.
TAKE_OVER, //- Take over the passed-in buffer; it will be deleted on object destruction.
};
#ifdef _MSC_VER
typedef __int64 int64;
typedef long int32;
typedef short int16;
typedef char int8;
typedef unsigned __int64 uint64;
typedef unsigned long uint32;
typedef unsigned short uint16;
typedef unsigned char uint8;
#else
typedef long long int64;
typedef int int32;
typedef short int16;
typedef char int8;
typedef unsigned long long uint64;
typedef unsigned int uint32;
typedef unsigned short uint16;
typedef unsigned char uint8;
#endif
class Exception
{
public:
Exception(const ByteBuffer *bb, const char *act, uint32 sp = 0)
{
action = act;
rpos = bb->rpos();
wpos = bb->wpos();
sizeparam = sp;
cursize = bb->size();
}
uint32 rpos, wpos, sizeparam, cursize;
const char *action;
};
#ifdef BYTEBUFFER_NO_EXCEPTIONS
#define BYTEBUFFER_EXCEPT(bb, desc, sz) { Exception __e(bb, desc, sz); \
fprintf(stderr, "Exception in ByteBuffer: '%s', rpos: %u, wpos: %u, cursize: %u, sizeparam: %u", \
__e.action, __e.rpos, __e.wpos, __e.cursize, __e.sizeparam); abort(); }
#else
#define BYTEBUFFER_EXCEPT(bb, desc, sz) throw Exception(bb, desc, sz)
#endif
protected:
uint8 *_buf; // the ptr to the buffer that holds all the bytes
uint32 _rpos, // read position, [0 ... _size]
_wpos, // write position, [0 ... _size]
_res, // reserved buffer size, [0 ... _size ... _res]
_size; // used buffer size
delete_func _delfunc;
allocator_func _allocfunc;
bool _mybuf; // if true, destructor deletes buffer
bool _growable; // default true, if false, buffer will not re-allocate more space
public:
ByteBuffer()
: _rpos(0), _wpos(0), _buf(NULL), _size(0), _growable(true), _res(0), _mybuf(false), _delfunc(NULL),
_allocfunc(NULL)
{
}
ByteBuffer(uint32 res)
: _rpos(0), _wpos(0), _buf(NULL), _size(0), _growable(true), _res(0), _mybuf(false), _delfunc(NULL),
_allocfunc(NULL)
{
_allocate(res);
}
ByteBuffer(ByteBuffer &buf, Mode mode = COPY, uint32 extra = 0)
: _rpos(0), _wpos(0), _buf(NULL), _size(0), _growable(true), _res(0), _mybuf(false), _delfunc(NULL),
_allocfunc(NULL)
{
init(buf, mode, extra);
}
// del param only used with TAKE_OVER, extra only used with COPY
ByteBuffer(void *buf, uint32 size, Mode mode = COPY, delete_func del = NULL, uint32 extra = 0)
: _rpos(0), _wpos(0), _size(size), _buf(NULL), _growable(true), _delfunc(del),
_mybuf(false), _allocfunc(NULL) // for mode == REUSE
{
init(buf, size, mode, del, extra);
}
void init(void *buf, uint32 size, Mode mode = COPY, delete_func del = NULL, uint32 extra = 0)
{
_mybuf = false;
switch(mode)
{
case COPY:
_allocate(size + extra);
append(buf, size);
break;
case TAKE_OVER:
_mybuf = true; // fallthrough
case REUSE:
_buf = (uint8*)buf;
_res = size;
_size = size;
}
}
void init(ByteBuffer& bb, Mode mode = COPY, uint32 extra = 0)
{
_allocfunc = bb._allocfunc;
switch(mode)
{
case COPY:
reserve(bb.size() + extra);
append(bb);
break;
case TAKE_OVER:
case REUSE:
_mybuf = bb._mybuf;
_delfunc = bb._delfunc;
_buf = bb._buf;
_res = bb._res;
_size = bb._size;
_growable = bb._growable;
break;
}
if(mode == TAKE_OVER)
{
bb._buf = NULL;
bb._size = 0;
bb._res = 0;
}
}
virtual ~ByteBuffer()
{
clear();
}
void clear(void)
{
_delete();
reset();
}
inline void reset(void)
{
_rpos = _wpos = _size = 0;
}
void resize(uint32 newsize)
{
reserve(newsize);
_rpos = 0;
_wpos = newsize;
_size = newsize;
}
void reserve(uint32 newsize)
{
if(_res < newsize)
_allocate(newsize);
}
// ---------------------- Write methods -----------------------
BB_MAKE_WRITE_OP(char);
BB_MAKE_WRITE_OP(uint8);
BB_MAKE_WRITE_OP(uint16);
BB_MAKE_WRITE_OP(uint32);
BB_MAKE_WRITE_OP(uint64);
BB_MAKE_WRITE_OP(float);
BB_MAKE_WRITE_OP(double);
ByteBuffer &operator<<(const char *str)
{
append((uint8 *)str, str ? strlen(str) : 0);
appendByte(0);
return *this;
}
ByteBuffer &operator<<(const std::string &value)
{
append((uint8 *)value.c_str(), value.length());
appendByte(0);
return *this;
}
// -------------------- Read methods --------------------
BB_MAKE_READ_OP(char);
BB_MAKE_READ_OP(uint8);
BB_MAKE_READ_OP(uint16);
BB_MAKE_READ_OP(uint32);
BB_MAKE_READ_OP(uint64);
BB_MAKE_READ_OP(float);
BB_MAKE_READ_OP(double);
inline uint8 operator[](uint32 pos) const
{
if(pos >= size())
BYTEBUFFER_EXCEPT(this, "operator[]", 1);
return _buf[pos];
}
ByteBuffer &operator>>(std::string& value)
{
value.clear();
char c;
while(readable() && (c = readByte()))
value += c;
return *this;
}
// --------------------------------------------------
uint32 rpos() const { return _rpos; }
uint32 rpos(uint32 rpos)
{
_rpos = rpos < size() ? rpos : size();
return _rpos;
}
uint32 wpos() const { return _wpos; }
uint32 wpos(uint32 wpos)
{
_wpos = wpos < size() ? wpos : size();
return _wpos;
}
template <typename T> T read()
{
T r = read<T>(_rpos);
_rpos += sizeof(T);
return r;
}
template <typename T> T read(uint32 pos) const
{
if(pos + sizeof(T) > size())
BYTEBUFFER_EXCEPT(this, "read", sizeof(T));
T val = *((T const*)(_buf + pos));
ByteBufferTools::ToLittleEndian<T>(val);
return val;
}
inline uint8 readByte()
{
if (_rpos < size())
return _buf[_rpos++];
BYTEBUFFER_EXCEPT(this, "readByte", 1);
return 0;
}
void readT(void *dest, uint32 len)
{
read(dest, len);
ByteBufferTools::ToLittleEndianRT(dest, len);
}
void read(void *dest, uint32 len)
{
if (_rpos + len <= size())
memcpy(dest, &_buf[_rpos], len);
else
BYTEBUFFER_EXCEPT(this, "read-into", len);
_rpos += len;
}
void skipRead(uint32 len)
{
_rpos += len;
}
inline const uint8 *contents() const { return _buf; }
inline uint8 *contents() { return _buf; }
inline const void *ptr() const { return _buf; }
inline void *ptr() { return _buf; }
inline uint32 size() const { return _size; }
inline uint32 bytes() const { return size(); }
inline uint32 bits() const { return bytes() * 8; }
inline uint32 capacity() const { return _res; }
inline uint32 readable(void) const { return size() - rpos(); }
inline uint32 writable(void) const { return size() - wpos(); } // free space left before realloc will occur
template <typename T> inline void append(T value)
{
ByteBufferTools::ToLittleEndian<T>(value);
_enlargeIfReq(_wpos + sizeof(T));
*((T*)(_buf + _wpos)) = value;
_wpos += sizeof(T);
if(_size < _wpos)
_size = _wpos;
}
inline void appendByte(uint8 value)
{
_enlargeIfReq(_wpos + 1);
_buf[_wpos++] = value;
if(_size < _wpos)
_size = _wpos;
}
// GCC 2.95 fails with an internal error in the template function above
void appendT(const void *src, uint32 bytes)
{
append(src, bytes);
ByteBufferTools::ToLittleEndianRT(_buf + (_wpos - bytes), bytes);
}
void append(const void *src, uint32 bytes)
{
if (!bytes) return;
_enlargeIfReq(_wpos + bytes);
memcpy(_buf + _wpos, src, bytes);
_wpos += bytes;
if(_size < _wpos)
_size = _wpos;
}
void append(const ByteBuffer& buffer)
{
if(buffer.size())
append(buffer.contents(), buffer.size());
}
void put(uint32 pos, const void *src, uint32 bytes)
{
memcpy(_buf + pos, src, bytes);
}
template <typename T> void put(uint32 pos, const T& value)
{
if(pos >= size())
BYTEBUFFER_EXCEPT(this, "put", sizeof(T));
ByteBufferTools::ToLittleEndian<T>(value);
*((T*)(_buf + pos)) = value;
}
inline bool growable(void) { return _growable; }
inline void growable(bool b) { _growable = b; }
// dangerous functions
void _setPtr(void *p)
{
_buf = (uint8*)p;
}
void _setAllocFunc(allocator_func f)
{
_allocfunc = f;
}
void _setDelFunc(delete_func f)
{
_delfunc = f;
}
void _setSize(uint32 s)
{
_size = s;
}
void _setReserved(uint32 s)
{
_res = s;
}
protected:
void _delete(void)
{
if(_mybuf)
{
if(_delfunc)
_delfunc(_buf);
else
delete [] _buf;
_buf = NULL;
_res = 0;
}
}
// allocate larger buffer and copy contents. if we own the current buffer, delete old, otherwise, leave it as it is.
void _allocate(uint32 s)
{
if(!_growable && _buf) // only throw if we already have a buf
BYTEBUFFER_EXCEPT(this, "_alloc+locked", s);
// dangerous: It's up to the user to be sure that _allocfunc and _delfunc are matching
uint8 *newbuf = (uint8*)(_allocfunc ? _allocfunc(s) : new char[s]);
if(_buf)
{
memcpy(newbuf, _buf, _size);
_delete();
}
_buf = newbuf;
_res = s;
_mybuf = true;
if (!_allocfunc)
_delfunc = NULL;
}
void _enlargeIfReq(uint32 minSize)
{
if(_res < minSize)
{
uint32 a = _res * 2;
if(a < minSize) // fallback if doubling the space was not enough
a += minSize;
_allocate(a);
}
}
};
#undef BB_MAKE_WRITE_OP
#undef BB_MAKE_READ_OP
#undef BB_IS_BIG_ENDIAN
#endif