ByteBuffer Class Reference

#include <ByteBuffer.h>

Public Member Functions
	ByteBuffer ()
	ByteBuffer (size_t reserve)
	ByteBuffer (ByteBuffer &&buf)
	ByteBuffer (ByteBuffer const &right)
	ByteBuffer (MessageBuffer &&buffer)
std::vector< uint8 > &&	Move ()
ByteBuffer &	operator= (ByteBuffer const &right)
ByteBuffer &	operator= (ByteBuffer &&right)
virtual	~ByteBuffer ()
void	clear ()
template<typename T >
void	append (T value)
void	FlushBits ()
void	ResetBitPos ()
bool	WriteBit (uint32 bit)
bool	ReadBit ()
template<typename T >
void	WriteBits (T value, int32 bits)
uint32	ReadBits (int32 bits)
void	ReadByteSeq (uint8 &b)
void	WriteByteSeq (uint8 b)
template<typename T >
void	put (size_t pos, T value)
template<>
void	read_skip ()
template<>
void	read_skip ()

Static Public Attributes
static size_t const	DEFAULT_SIZE = 0x1000
static uint8 const	InitialBitPos = 8

PutBits
Places specified amount of bits of value at specified position in packet. To ensure all bits are correctly written, only call this method after bit flush has been performed Parameters pos Position to place the value at, in bits. The entire value must fit in the packet It is advised to obtain the position using bitwpos() function. value Data to write. bitCount Number of bits to store the value on.
size_t	_rpos
size_t	_wpos
size_t	_bitpos
uint8	_curbitval
std::vector< uint8 >	_storage
template<typename T >
void	PutBits (size_t pos, T value, uint32 bitCount)
ByteBuffer &	operator<< (uint8 value)
ByteBuffer &	operator<< (uint16 value)
ByteBuffer &	operator<< (uint32 value)
ByteBuffer &	operator<< (uint64 value)
ByteBuffer &	operator<< (int8 value)
ByteBuffer &	operator<< (int16 value)
ByteBuffer &	operator<< (int32 value)
ByteBuffer &	operator<< (int64 value)
ByteBuffer &	operator<< (float value)
ByteBuffer &	operator<< (double value)
ByteBuffer &	operator<< (const std::string &value)
ByteBuffer &	operator<< (const char *str)
ByteBuffer &	operator>> (bool &value)
ByteBuffer &	operator>> (uint8 &value)
ByteBuffer &	operator>> (uint16 &value)
ByteBuffer &	operator>> (uint32 &value)
ByteBuffer &	operator>> (uint64 &value)
ByteBuffer &	operator>> (int8 &value)
ByteBuffer &	operator>> (int16 &value)
ByteBuffer &	operator>> (int32 &value)
ByteBuffer &	operator>> (int64 &value)
ByteBuffer &	operator>> (float &value)
ByteBuffer &	operator>> (double &value)
ByteBuffer &	operator>> (std::string &value)
uint8 &	operator[] (size_t const pos)
uint8 const &	operator[] (size_t const pos) const
size_t	rpos () const
size_t	rpos (size_t rpos_)
void	rfinish ()
size_t	wpos () const
size_t	wpos (size_t wpos_)
size_t	bitwpos () const
	Returns position of last written bit. More...
size_t	bitwpos (size_t newPos)
template<typename T >
void	read_skip ()
void	read_skip (size_t skip)
template<typename T >
T	read ()
template<typename T >
T	read (size_t pos) const
void	read (uint8 *dest, size_t len)
void	ReadPackedUInt64 (uint64 &guid)
void	ReadPackedUInt64 (uint8 mask, uint64 &value)
std::string	ReadString (uint32 length)
void	WriteString (std::string const &str)
void	WriteString (char const *str, size_t len)
uint32	ReadPackedTime ()
ByteBuffer &	ReadPackedTime (uint32 &time)
uint8 *	contents ()
uint8 const *	contents () const
size_t	size () const
bool	empty () const
void	resize (size_t newsize)
void	reserve (size_t ressize)
void	append (const char *src, size_t cnt)
template<class T >
void	append (const T *src, size_t cnt)
void	append (const uint8 *src, size_t cnt)
void	append (const ByteBuffer &buffer)
void	appendPackXYZ (float x, float y, float z)
void	AppendPackedUInt64 (uint64 guid)
void	AppendPackedTime (time_t time)
void	put (size_t pos, const uint8 *src, size_t cnt)
void	print_storage () const
void	textlike () const
void	hexlike () const
static size_t	PackUInt64 (uint64 value, uint8 *mask, uint8 *result)

Constructor & Destructor Documentation

ByteBuffer::ByteBuffer ( )

inline

 : _rpos(0), _wpos(0), _bitpos(InitialBitPos), _curbitval(0)
 {
 _storage.reserve(DEFAULT_SIZE);
 }

ByteBuffer::ByteBuffer ( size_t  reserve )

inline

 : _rpos(0), _wpos(0), _bitpos(InitialBitPos), _curbitval(0)
 {
 _storage.reserve(reserve);
 }

ByteBuffer::ByteBuffer ( ByteBuffer &&  buf )

inline

 : _rpos(buf._rpos), _wpos(buf._wpos),
 _bitpos(buf._bitpos), _curbitval(buf._curbitval), _storage(buf.Move()) { }

ByteBuffer::ByteBuffer ( ByteBuffer const &  right )

inline

 : _rpos(right._rpos), _wpos(right._wpos),
 _bitpos(right._bitpos), _curbitval(right._curbitval), _storage(right._storage) { }

ByteBuffer::ByteBuffer

(

MessageBuffer &&

buffer

)

 : _rpos(0), _wpos(0), _bitpos(InitialBitPos), _curbitval(0), _storage(buffer.Move())
{
}

virtual ByteBuffer::~ByteBuffer ( )

inlinevirtual

{ }

Member Function Documentation

template<typename T >

void ByteBuffer::append ( T  value )

inline

 {
 static_assert(std::is_fundamental<T>::value, "append(compound)");
 EndianConvert(value);
 append((uint8 *)&value, sizeof(value));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void ByteBuffer::append ( const char *  src, size_t  cnt  )

inline

 {
 return append((const uint8 *)src, cnt);
 }

Here is the call graph for this function:

template<class T >

void ByteBuffer::append ( const T *  src, size_t  cnt  )

inline

 {
 return append((const uint8 *)src, cnt * sizeof(T));
 }

Here is the call graph for this function:

void ByteBuffer::append ( const uint8 *  src, size_t  cnt  )

inline

 {
 if (!cnt)
 throw ByteBufferSourceException(_wpos, size(), cnt);

 if (!src)
 throw ByteBufferSourceException(_wpos, size(), cnt);

 ASSERT(size() < 10000000);

 FlushBits();

 if (_storage.size() < _wpos + cnt)
 _storage.resize(_wpos + cnt);
 std::memcpy(&_storage[_wpos], src, cnt);
 _wpos += cnt;
 }

void ByteBuffer::append ( const ByteBuffer &  buffer )

inline

 {
 if (buffer.wpos())
 append(buffer.contents(), buffer.wpos());
 }

Here is the call graph for this function:

void ByteBuffer::AppendPackedTime ( time_t  time )

inline

 {
 tm lt;
 localtime_r(&time, &lt);
 append<uint32>((lt.tm_year - 100) << 24 | lt.tm_mon << 20 | (lt.tm_mday - 1) << 14 | lt.tm_wday << 11 | lt.tm_hour << 6 | lt.tm_min);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void ByteBuffer::AppendPackedUInt64 ( uint64  guid )

inline

 {
 uint8 mask = 0;
 size_t pos = wpos();
 *this << uint8(mask);

 uint8 packed[8];
 if (size_t packedSize = PackUInt64(guid, &mask, packed))
 append(packed, packedSize);

 put<uint8>(pos, mask);
 }

Here is the call graph for this function:

void ByteBuffer::appendPackXYZ ( float  x, float  y, float  z  )

inline

 {
 uint32 packed = 0;
 packed |= ((int)(x / 0.25f) & 0x7FF);
 packed |= ((int)(y / 0.25f) & 0x7FF) << 11;
 packed |= ((int)(z / 0.25f) & 0x3FF) << 22;
 *this << packed;
 }

Here is the caller graph for this function:

size_t ByteBuffer::bitwpos ( ) const

inline

Returns position of last written bit.

{ return _wpos * 8 + 8 - _bitpos; }

size_t ByteBuffer::bitwpos ( size_t  newPos )

inline

 {
 _wpos = newPos / 8;
 _bitpos = 8 - (newPos % 8);
 return _wpos * 8 + 8 - _bitpos;
 }

void ByteBuffer::clear ( )

inline

 {
 _rpos = 0;
 _wpos = 0;
 _bitpos = InitialBitPos;
 _curbitval = 0;
 _storage.clear();
 }

Here is the caller graph for this function:

uint8* ByteBuffer::contents ( )

inline

 {
 if (_storage.empty())
 throw ByteBufferException();
 return _storage.data();
 }

Here is the caller graph for this function:

uint8 const* ByteBuffer::contents ( ) const

inline

 {
 if (_storage.empty())
 throw ByteBufferException();
 return _storage.data();
 }

bool ByteBuffer::empty ( ) const

inline

{ return _storage.empty(); }

Here is the caller graph for this function:

void ByteBuffer::FlushBits ( )

inline

 {
 if (_bitpos == 8)
 return;

 _bitpos = 8;

 append((uint8 *)&_curbitval, sizeof(uint8));
 _curbitval = 0;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void ByteBuffer::hexlike

(

)

const

{
 if (!sLog->ShouldLog("network", LOG_LEVEL_TRACE)) // optimize disabled trace output
 return;

 uint32 j = 1, k = 1;

 std::ostringstream o;
 o << "STORAGE_SIZE: " << size();

 for (uint32 i = 0; i < size(); ++i)
 {
 char buf[3];
 snprintf(buf, 3, "%2X ", read<uint8>(i));
 if ((i == (j * 8)) && ((i != (k * 16))))
 {
 o << "| ";
 ++j;
 }
 else if (i == (k * 16))
 {
 o << "\n";
 ++k;
 ++j;
 }

 o << buf;
 }
 o << " ";
 TC_LOG_TRACE("network", "%s", o.str().c_str());
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::vector<uint8>&& ByteBuffer::Move ( )

inline

 {
 _rpos = 0;
 _wpos = 0;
 _bitpos = InitialBitPos;
 _curbitval = 0;
 return std::move(_storage);
 }

ByteBuffer& ByteBuffer::operator<< ( uint8  value )

inline

 {
 append<uint8>(value);
 return *this;
 }

ByteBuffer& ByteBuffer::operator<< ( uint16  value )

inline

 {
 append<uint16>(value);
 return *this;
 }

ByteBuffer& ByteBuffer::operator<< ( uint32  value )

inline

 {
 append<uint32>(value);
 return *this;
 }

ByteBuffer& ByteBuffer::operator<< ( uint64  value )

inline

 {
 append<uint64>(value);
 return *this;
 }

ByteBuffer& ByteBuffer::operator<< ( int8  value )

inline

 {
 append<int8>(value);
 return *this;
 }

ByteBuffer& ByteBuffer::operator<< ( int16  value )

inline

 {
 append<int16>(value);
 return *this;
 }

ByteBuffer& ByteBuffer::operator<< ( int32  value )

inline

 {
 append<int32>(value);
 return *this;
 }

ByteBuffer& ByteBuffer::operator<< ( int64  value )

inline

 {
 append<int64>(value);
 return *this;
 }

ByteBuffer& ByteBuffer::operator<< ( float  value )

inline

 {
 append<float>(value);
 return *this;
 }

ByteBuffer& ByteBuffer::operator<< ( double  value )

inline

 {
 append<double>(value);
 return *this;
 }

ByteBuffer& ByteBuffer::operator<< ( const std::string &  value )

inline

 {
 if (size_t len = value.length())
 append((uint8 const*)value.c_str(), len);
 append<uint8>(0);
 return *this;
 }

Here is the call graph for this function:

ByteBuffer& ByteBuffer::operator<< ( const char *  str )

inline

 {
 if (size_t len = (str ? strlen(str) : 0))
 append((uint8 const*)str, len);
 append<uint8>(0);
 return *this;
 }

Here is the call graph for this function:

ByteBuffer& ByteBuffer::operator= ( ByteBuffer const &  right )

inline

 {
 if (this != &right)
 {
 _rpos = right._rpos;
 _wpos = right._wpos;
 _bitpos = right._bitpos;
 _curbitval = right._curbitval;
 _storage = right._storage;
 }

 return *this;
 }

Here is the caller graph for this function:

ByteBuffer& ByteBuffer::operator= ( ByteBuffer &&  right )

inline

 {
 if (this != &right)
 {
 _rpos = right._rpos;
 _wpos = right._wpos;
 _bitpos = right._bitpos;
 _curbitval = right._curbitval;
 _storage = right.Move();
 }

 return *this;
 }

ByteBuffer& ByteBuffer::operator>> ( bool &  value )

inline

 {
 value = read<char>() > 0 ? true : false;
 return *this;
 }

ByteBuffer& ByteBuffer::operator>> ( uint8 &  value )

inline

 {
 value = read<uint8>();
 return *this;
 }

ByteBuffer& ByteBuffer::operator>> ( uint16 &  value )

inline

 {
 value = read<uint16>();
 return *this;
 }

ByteBuffer& ByteBuffer::operator>> ( uint32 &  value )

inline

 {
 value = read<uint32>();
 return *this;
 }

ByteBuffer& ByteBuffer::operator>> ( uint64 &  value )

inline

 {
 value = read<uint64>();
 return *this;
 }

ByteBuffer& ByteBuffer::operator>> ( int8 &  value )

inline

 {
 value = read<int8>();
 return *this;
 }

ByteBuffer& ByteBuffer::operator>> ( int16 &  value )

inline

 {
 value = read<int16>();
 return *this;
 }

ByteBuffer& ByteBuffer::operator>> ( int32 &  value )

inline

 {
 value = read<int32>();
 return *this;
 }

ByteBuffer& ByteBuffer::operator>> ( int64 &  value )

inline

 {
 value = read<int64>();
 return *this;
 }

ByteBuffer& ByteBuffer::operator>> ( float &  value )

inline

 {
 value = read<float>();
 if (!std::isfinite(value))
 throw ByteBufferException();
 return *this;
 }

ByteBuffer& ByteBuffer::operator>> ( double &  value )

inline

 {
 value = read<double>();
 if (!std::isfinite(value))
 throw ByteBufferException();
 return *this;
 }

ByteBuffer& ByteBuffer::operator>> ( std::string &  value )

inline

 {
 value.clear();
 while (rpos() < size()) // prevent crash at wrong string format in packet
 {
 char c = read<char>();
 if (c == 0)
 break;
 value += c;
 }
 return *this;
 }

Here is the call graph for this function:

uint8& ByteBuffer::operator[] ( size_t const  pos )

inline

 {
 if (pos >= size())
 throw ByteBufferPositionException(false, pos, 1, size());
 return _storage[pos];
 }

uint8 const& ByteBuffer::operator[] ( size_t const  pos ) const

inline

 {
 if (pos >= size())
 throw ByteBufferPositionException(false, pos, 1, size());
 return _storage[pos];
 }

static size_t ByteBuffer::PackUInt64 ( uint64  value, uint8 *  mask, uint8 *  result  )

inlinestatic

 {
 size_t resultSize = 0;
 *mask = 0;
 memset(result, 0, 8);

 for (uint8 i = 0; value != 0; ++i)
 {
 if (value & 0xFF)
 {
 *mask |= uint8(1 << i);
 result[resultSize++] = uint8(value & 0xFF);
 }

 value >>= 8;
 }

 return resultSize;
 }

Here is the caller graph for this function:

void ByteBuffer::print_storage

(

)

const

{
 if (!sLog->ShouldLog("network", LOG_LEVEL_TRACE)) // optimize disabled trace output
 return;

 std::ostringstream o;
 o << "STORAGE_SIZE: " << size();
 for (uint32 i = 0; i < size(); ++i)
 o << read<uint8>(i) << " - ";
 o << " ";

 TC_LOG_TRACE("network", "%s", o.str().c_str());
}

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename T >

void ByteBuffer::put ( size_t  pos, T  value  )

inline

 {
 static_assert(std::is_fundamental<T>::value, "append(compound)");
 EndianConvert(value);
 put(pos, (uint8 *)&value, sizeof(value));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void ByteBuffer::put ( size_t  pos, const uint8 *  src, size_t  cnt  )

inline

 {
 if (pos + cnt > size())
 throw ByteBufferPositionException(true, pos, cnt, size());

 if (!src)
 throw ByteBufferSourceException(_wpos, size(), cnt);

 std::memcpy(&_storage[pos], src, cnt);
 }

template<typename T >

void ByteBuffer::PutBits ( size_t  pos, T  value, uint32  bitCount  )

inline

 {
 if (!bitCount)
 throw ByteBufferSourceException((pos + bitCount) / 8, size(), 0);

 if (pos + bitCount > size() * 8)
 throw ByteBufferPositionException(false, (pos + bitCount) / 8, size(), (bitCount - 1) / 8 + 1);

 for (uint32 i = 0; i < bitCount; ++i)
 {
 size_t wp = (pos + i) / 8;
 size_t bit = (pos + i) % 8;
 if ((value >> (bitCount - i - 1)) & 1)
 _storage[wp] |= 1 << (7 - bit);
 else
 _storage[wp] &= ~(1 << (7 - bit));
 }
 }

template<typename T >

T ByteBuffer::read ( )

inline

 {
 ResetBitPos();
 T r = read<T>(_rpos);
 _rpos += sizeof(T);
 return r;
 }

Here is the caller graph for this function:

template<typename T >

T ByteBuffer::read ( size_t  pos ) const

inline

 {
 if (pos + sizeof(T) > size())
 throw ByteBufferPositionException(false, pos, sizeof(T), size());
 T val = *((T const*)&_storage[pos]);
 EndianConvert(val);
 return val;
 }

Here is the call graph for this function:

void ByteBuffer::read ( uint8 *  dest, size_t  len  )

inline

 {
 if (_rpos + len > size())
 throw ByteBufferPositionException(false, _rpos, len, size());

 ResetBitPos();
 std::memcpy(dest, &_storage[_rpos], len);
 _rpos += len;
 }

template<typename T >

void ByteBuffer::read_skip ( )

inline

{ read_skip(sizeof(T)); }

Here is the call graph for this function:

Here is the caller graph for this function:

void ByteBuffer::read_skip ( size_t  skip )

inline

 {
 if (_rpos + skip > size())
 throw ByteBufferPositionException(false, _rpos, skip, size());

 ResetBitPos();
 _rpos += skip;
 }

template<>

void ByteBuffer::read_skip ( )

inline

{
 std::string temp;
 *this >> temp;
}

template<>

void ByteBuffer::read_skip ( )

inline

{
 read_skip<char*>();
}

bool ByteBuffer::ReadBit ( )

inline

 {
 ++_bitpos;
 if (_bitpos > 7)
 {
 _curbitval = read<uint8>();
 _bitpos = 0;
 }

 return ((_curbitval >> (7-_bitpos)) & 1) != 0;
 }

Here is the caller graph for this function:

uint32 ByteBuffer::ReadBits ( int32  bits )

inline

 {
 uint32 value = 0;
 for (int32 i = bits - 1; i >= 0; --i)
 if (ReadBit())
 value |= (1 << (i));

 return value;
 }

Here is the caller graph for this function:

void ByteBuffer::ReadByteSeq ( uint8 &  b )

inline

 {
 if (b != 0)
 b ^= read<uint8>();
 }

Here is the caller graph for this function:

uint32 ByteBuffer::ReadPackedTime ( )

inline

 {
 uint32 packedDate = read<uint32>();
 tm lt = tm();

 lt.tm_min = packedDate & 0x3F;
 lt.tm_hour = (packedDate >> 6) & 0x1F;
 //lt.tm_wday = (packedDate >> 11) & 7;
 lt.tm_mday = ((packedDate >> 14) & 0x3F) + 1;
 lt.tm_mon = (packedDate >> 20) & 0xF;
 lt.tm_year = ((packedDate >> 24) & 0x1F) + 100;

 return uint32(mktime(&lt));
 }

Here is the caller graph for this function:

ByteBuffer& ByteBuffer::ReadPackedTime ( uint32 &  time )

inline

 {
 time = ReadPackedTime();
 return *this;
 }

void ByteBuffer::ReadPackedUInt64 ( uint64 &  guid )

inline

 {
 guid = 0;
 ReadPackedUInt64(read<uint8>(), guid);
 }

Here is the caller graph for this function:

void ByteBuffer::ReadPackedUInt64 ( uint8  mask, uint64 &  value  )

inline

 {
 for (uint32 i = 0; i < 8; ++i)
 if (mask & (uint8(1) << i))
 value |= (uint64(read<uint8>()) << (i * 8));
 }

std::string ByteBuffer::ReadString ( uint32  length )

inline

 {
 if (_rpos + length > size())
 throw ByteBufferPositionException(false, _rpos, length, size());

 ResetBitPos();
 if (!length)
 return std::string();

 std::string str((char const*)&_storage[_rpos], length);
 _rpos += length;
 return str;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void ByteBuffer::reserve ( size_t  ressize )

inline

        {
            if (ressize > size())
                _storage.reserve(ressize);
        }

Here is the caller graph for this function:

void ByteBuffer::ResetBitPos ( )

inline

        {
            if (_bitpos > 7)
                return;

            _bitpos = 8;
            _curbitval = 0;
        }

Here is the caller graph for this function:

void ByteBuffer::resize ( size_t  newsize )

inline

        {
            _storage.resize(newsize, 0);
            _rpos = 0;
            _wpos = size();
        }

Here is the caller graph for this function:

void ByteBuffer::rfinish ( )

inline

        {
            _rpos = wpos();
        }

Here is the caller graph for this function:

size_t ByteBuffer::rpos ( ) const

inline

{ return _rpos; }

Here is the caller graph for this function:

size_t ByteBuffer::rpos ( size_t  rpos_ )

inline

        {
            _rpos = rpos_;
            return _rpos;
        }

size_t ByteBuffer::size ( ) const

inline

{ return _storage.size(); }

Here is the caller graph for this function:

void ByteBuffer::textlike

(

)

const

{
    if (!sLog->ShouldLog("network", LOG_LEVEL_TRACE)) // optimize disabled trace output
        return;

    std::ostringstream o;
    o << "STORAGE_SIZE: " << size();
    for (uint32 i = 0; i < size(); ++i)
    {
        char buf[2];
        snprintf(buf, 2, "%c", read<uint8>(i));
        o << buf;
    }
    o << " ";
    TC_LOG_TRACE("network", "%s", o.str().c_str());
}

Here is the call graph for this function:

size_t ByteBuffer::wpos ( ) const

inline

{ return _wpos; }

Here is the caller graph for this function:

size_t ByteBuffer::wpos ( size_t  wpos_ )

inline

        {
            _wpos = wpos_;
            return _wpos;
        }

bool ByteBuffer::WriteBit ( uint32  bit )

inline

        {
            --_bitpos;
            if (bit)
                _curbitval |= (1 << (_bitpos));

            if (_bitpos == 0)
            {
                _bitpos = 8;
                append((uint8 *)&_curbitval, sizeof(_curbitval));
                _curbitval = 0;
            }

            return (bit != 0);
        }

Here is the call graph for this function:

template<typename T >

void ByteBuffer::WriteBits ( T  value, int32  bits  )

inline

        {
            for (int32 i = bits - 1; i >= 0; --i)
                WriteBit((value >> i) & 1);
        }

Here is the caller graph for this function:

void ByteBuffer::WriteByteSeq ( uint8  b )

inline

        {
            if (b != 0)
                append<uint8>(b ^ 1);
        }

Here is the caller graph for this function:

void ByteBuffer::WriteString ( std::string const &  str )

inline

Method for writing strings that have their length sent separately in packet without null-terminating the string

        {
            if (size_t len = str.length())
                append(str.c_str(), len);
        }

Here is the call graph for this function:

Here is the caller graph for this function:

void ByteBuffer::WriteString ( char const *  str, size_t  len  )

inline

        {
            if (len)
                append(str, len);
        }

Here is the call graph for this function:

Member Data Documentation

size_t ByteBuffer::_bitpos

protected

uint8 ByteBuffer::_curbitval

protected

size_t ByteBuffer::_rpos

protected

std::vector<uint8> ByteBuffer::_storage

protected

size_t ByteBuffer::_wpos

protected

size_t const ByteBuffer::DEFAULT_SIZE = 0x1000

static

uint8 const ByteBuffer::InitialBitPos = 8

static

---

The documentation for this class was generated from the following files:

• src/server/shared/Packets/ByteBuffer.h
• src/server/shared/Packets/ByteBuffer.cpp