mirror of
https://github.com/TrinityCore/TrinityCore.git
synced 2026-02-03 07:37:11 +01:00
833 lines
20 KiB
C++
Executable File
833 lines
20 KiB
C++
Executable File
/*
|
|
* Copyright (C) 2008-2011 TrinityCore <http://www.trinitycore.org/>
|
|
* Copyright (C) 2005-2009 MaNGOS <http://getmangos.com/>
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify it
|
|
* under the terms of the GNU General Public License as published by the
|
|
* Free Software Foundation; either version 2 of the License, or (at your
|
|
* option) any later version.
|
|
*
|
|
* This program 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 General Public License for
|
|
* more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License along
|
|
* with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#ifndef _BYTEBUFFER_H
|
|
#define _BYTEBUFFER_H
|
|
|
|
#include "Common.h"
|
|
#include "Debugging/Errors.h"
|
|
#include "Logging/Log.h"
|
|
#include "Utilities/ByteConverter.h"
|
|
|
|
|
|
|
|
class ByteBufferException
|
|
{
|
|
public:
|
|
ByteBufferException(bool _add, size_t _pos, size_t _esize, size_t _size)
|
|
: add(_add), pos(_pos), esize(_esize), size(_size)
|
|
{
|
|
PrintPosError();
|
|
}
|
|
|
|
void PrintPosError() const
|
|
{
|
|
sLog->outError("Attempted to %s in ByteBuffer (pos: " SIZEFMTD " size: "SIZEFMTD") value with size: " SIZEFMTD,
|
|
(add ? "put" : "get"), pos, size, esize);
|
|
}
|
|
private:
|
|
bool add;
|
|
size_t pos;
|
|
size_t esize;
|
|
size_t size;
|
|
};
|
|
|
|
class BitStream
|
|
{
|
|
public:
|
|
BitStream(): _rpos(0), _wpos(0) {}
|
|
|
|
BitStream(uint32 val, size_t len): _rpos(0), _wpos(0)
|
|
{
|
|
WriteBits(val, len);
|
|
}
|
|
|
|
void Clear();
|
|
uint8 GetBit(uint32 bit);
|
|
uint8 ReadBit();
|
|
void WriteBit(uint32 bit);
|
|
template <typename T> void WriteBits(T value, size_t bits);
|
|
bool Emtpy ();
|
|
void Reverse();
|
|
void Print();
|
|
|
|
size_t GetLenght () { return _data.size();}
|
|
uint32 GetReadPosition() { return _rpos; }
|
|
uint32 GetWritePosition() { return _wpos; }
|
|
void SetReadPos (uint32 pos) { _rpos = pos; }
|
|
|
|
uint8 operator[](uint32 pos) const
|
|
{
|
|
return _data[pos];
|
|
}
|
|
|
|
uint8& operator[] (const uint32 pos)
|
|
{
|
|
return _data[pos];
|
|
}
|
|
|
|
private:
|
|
std::vector<uint8> _data;
|
|
uint32 _rpos, _wpos;
|
|
};
|
|
|
|
class ByteBuffer
|
|
{
|
|
public:
|
|
const static size_t DEFAULT_SIZE = 0x1000;
|
|
|
|
// constructor
|
|
ByteBuffer(): _rpos(0), _wpos(0), _bitpos(8), _curbitval(0)
|
|
{
|
|
_storage.reserve(DEFAULT_SIZE);
|
|
}
|
|
|
|
// constructor
|
|
ByteBuffer(size_t res, bool init = false);
|
|
|
|
// copy constructor
|
|
ByteBuffer(const ByteBuffer &buf): _rpos(buf._rpos), _wpos(buf._wpos), _storage(buf._storage), _bitpos(buf._bitpos), _curbitval(buf._curbitval) { }
|
|
|
|
void clear()
|
|
{
|
|
_storage.clear();
|
|
_rpos = _wpos = 0;
|
|
}
|
|
|
|
template <typename T> void append(T value)
|
|
{
|
|
flushBits();
|
|
EndianConvert(value);
|
|
append((uint8 *)&value, sizeof(value));
|
|
}
|
|
|
|
void flushBits()
|
|
{
|
|
if (_bitpos == 8)
|
|
return;
|
|
|
|
append((uint8 *)&_curbitval, sizeof(uint8));
|
|
_curbitval = 0;
|
|
_bitpos = 8;
|
|
}
|
|
|
|
bool writeBit(uint32 bit)
|
|
{
|
|
--_bitpos;
|
|
if (bit)
|
|
_curbitval |= (1 << (_bitpos));
|
|
|
|
if (_bitpos == 0)
|
|
{
|
|
_bitpos = 8;
|
|
append((uint8 *)&_curbitval, sizeof(_curbitval));
|
|
_curbitval = 0;
|
|
}
|
|
|
|
return (bit != 0);
|
|
}
|
|
|
|
bool readBit()
|
|
{
|
|
++_bitpos;
|
|
if (_bitpos > 7)
|
|
{
|
|
_bitpos = 0;
|
|
_curbitval = read<uint8>();
|
|
}
|
|
bool bit = ((_curbitval >> (7-_bitpos)) & 1) != 0;
|
|
return bit;
|
|
}
|
|
|
|
template <typename T> void writeBits(T value, size_t bits)
|
|
{
|
|
for (int32 i = bits-1; i >= 0; --i)
|
|
writeBit((value >> i) & 1);
|
|
}
|
|
|
|
uint32 readBits(size_t bits)
|
|
{
|
|
uint32 value = 0;
|
|
for (int32 i = bits-1; i >= 0; --i)
|
|
{
|
|
if(readBit())
|
|
{
|
|
value |= (1 << (_bitpos));
|
|
}
|
|
}
|
|
return value;
|
|
}
|
|
|
|
BitStream* ReadBitStream(uint32 len)
|
|
{
|
|
BitStream* b = new BitStream();
|
|
for (uint32 i = 0; i < len; ++i)
|
|
b->WriteBit(readBit());
|
|
return b;
|
|
}
|
|
|
|
template <typename T> void put(size_t pos, T value)
|
|
{
|
|
EndianConvert(value);
|
|
put(pos, (uint8 *)&value, sizeof(value));
|
|
}
|
|
|
|
ByteBuffer &operator<<(uint8 value)
|
|
{
|
|
append<uint8>(value);
|
|
return *this;
|
|
}
|
|
|
|
ByteBuffer &operator<<(uint16 value)
|
|
{
|
|
append<uint16>(value);
|
|
return *this;
|
|
}
|
|
|
|
ByteBuffer &operator<<(uint32 value)
|
|
{
|
|
append<uint32>(value);
|
|
return *this;
|
|
}
|
|
|
|
ByteBuffer &operator<<(uint64 value)
|
|
{
|
|
append<uint64>(value);
|
|
return *this;
|
|
}
|
|
|
|
// signed as in 2e complement
|
|
ByteBuffer &operator<<(int8 value)
|
|
{
|
|
append<int8>(value);
|
|
return *this;
|
|
}
|
|
|
|
ByteBuffer &operator<<(int16 value)
|
|
{
|
|
append<int16>(value);
|
|
return *this;
|
|
}
|
|
|
|
ByteBuffer &operator<<(int32 value)
|
|
{
|
|
append<int32>(value);
|
|
return *this;
|
|
}
|
|
|
|
ByteBuffer &operator<<(int64 value)
|
|
{
|
|
append<int64>(value);
|
|
return *this;
|
|
}
|
|
|
|
// floating points
|
|
ByteBuffer &operator<<(float value)
|
|
{
|
|
append<float>(value);
|
|
return *this;
|
|
}
|
|
|
|
ByteBuffer &operator<<(double value)
|
|
{
|
|
append<double>(value);
|
|
return *this;
|
|
}
|
|
|
|
ByteBuffer &operator<<(const std::string &value)
|
|
{
|
|
append((uint8 const*)value.c_str(), value.length());
|
|
append((uint8)0);
|
|
return *this;
|
|
}
|
|
|
|
ByteBuffer &operator<<(const char *str)
|
|
{
|
|
append((uint8 const*)str, str ? strlen(str) : 0);
|
|
append((uint8)0);
|
|
return *this;
|
|
}
|
|
|
|
ByteBuffer &operator>>(bool &value)
|
|
{
|
|
value = read<char>() > 0 ? true : false;
|
|
return *this;
|
|
}
|
|
|
|
ByteBuffer &operator>>(uint8 &value)
|
|
{
|
|
value = read<uint8>();
|
|
return *this;
|
|
}
|
|
|
|
ByteBuffer &operator>>(uint16 &value)
|
|
{
|
|
value = read<uint16>();
|
|
return *this;
|
|
}
|
|
|
|
ByteBuffer &operator>>(uint32 &value)
|
|
{
|
|
value = read<uint32>();
|
|
return *this;
|
|
}
|
|
|
|
ByteBuffer &operator>>(uint64 &value)
|
|
{
|
|
value = read<uint64>();
|
|
return *this;
|
|
}
|
|
|
|
//signed as in 2e complement
|
|
ByteBuffer &operator>>(int8 &value)
|
|
{
|
|
value = read<int8>();
|
|
return *this;
|
|
}
|
|
|
|
ByteBuffer &operator>>(int16 &value)
|
|
{
|
|
value = read<int16>();
|
|
return *this;
|
|
}
|
|
|
|
ByteBuffer &operator>>(int32 &value)
|
|
{
|
|
value = read<int32>();
|
|
return *this;
|
|
}
|
|
|
|
ByteBuffer &operator>>(int64 &value)
|
|
{
|
|
value = read<int64>();
|
|
return *this;
|
|
}
|
|
|
|
ByteBuffer &operator>>(float &value)
|
|
{
|
|
value = read<float>();
|
|
return *this;
|
|
}
|
|
|
|
ByteBuffer &operator>>(double &value)
|
|
{
|
|
value = read<double>();
|
|
return *this;
|
|
}
|
|
|
|
ByteBuffer &operator>>(std::string& value)
|
|
{
|
|
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;
|
|
}
|
|
|
|
uint8 operator[](size_t pos) const
|
|
{
|
|
return read<uint8>(pos);
|
|
}
|
|
|
|
uint8& operator[] (const size_t pos)
|
|
{
|
|
if (pos >= size())
|
|
throw ByteBufferException(false, pos, 1, size());
|
|
return _storage[pos];
|
|
}
|
|
|
|
size_t rpos() const { return _rpos; }
|
|
|
|
size_t rpos(size_t rpos_)
|
|
{
|
|
_rpos = rpos_;
|
|
return _rpos;
|
|
}
|
|
|
|
void rfinish()
|
|
{
|
|
_rpos = wpos();
|
|
}
|
|
|
|
size_t wpos() const { return _wpos; }
|
|
|
|
size_t wpos(size_t wpos_)
|
|
{
|
|
_wpos = wpos_;
|
|
return _wpos;
|
|
}
|
|
|
|
template<typename T>
|
|
void read_skip() { read_skip(sizeof(T)); }
|
|
|
|
void read_skip(size_t skip)
|
|
{
|
|
if (_rpos + skip > size())
|
|
throw ByteBufferException(false, _rpos, skip, size());
|
|
_rpos += skip;
|
|
}
|
|
|
|
template <typename T> T read()
|
|
{
|
|
T r = read<T>(_rpos);
|
|
_rpos += sizeof(T);
|
|
return r;
|
|
}
|
|
|
|
template <typename T> T read(size_t pos) const
|
|
{
|
|
if (pos + sizeof(T) > size())
|
|
throw ByteBufferException(false, pos, sizeof(T), size());
|
|
T val = *((T const*)&_storage[pos]);
|
|
EndianConvert(val);
|
|
return val;
|
|
}
|
|
|
|
void read(uint8 *dest, size_t len)
|
|
{
|
|
if (_rpos + len > size())
|
|
throw ByteBufferException(false, _rpos, len, size());
|
|
memcpy(dest, &_storage[_rpos], len);
|
|
_rpos += len;
|
|
}
|
|
|
|
void readPackGUID(uint64& guid)
|
|
{
|
|
if (rpos() + 1 > size())
|
|
throw ByteBufferException(false, _rpos, 1, size());
|
|
|
|
guid = 0;
|
|
|
|
uint8 guidmark = 0;
|
|
(*this) >> guidmark;
|
|
|
|
for (int i = 0; i < 8; ++i)
|
|
{
|
|
if (guidmark & (uint8(1) << i))
|
|
{
|
|
if (rpos() + 1 > size())
|
|
throw ByteBufferException(false, _rpos, 1, size());
|
|
|
|
uint8 bit;
|
|
(*this) >> bit;
|
|
guid |= (uint64(bit) << (i * 8));
|
|
}
|
|
}
|
|
}
|
|
|
|
uint8 ReadUInt8()
|
|
{
|
|
uint8 u = 0;
|
|
(*this) >> u;
|
|
return u;
|
|
}
|
|
|
|
uint16 ReadUInt16()
|
|
{
|
|
uint16 u = 0;
|
|
(*this) >> u;
|
|
return u;
|
|
}
|
|
|
|
uint32 ReadUInt32()
|
|
{
|
|
uint32 u = 0;
|
|
(*this) >> u;
|
|
return u;
|
|
}
|
|
|
|
uint64 ReadUInt64()
|
|
{
|
|
uint64 u = 0;
|
|
(*this) >> u;
|
|
return u;
|
|
}
|
|
|
|
int8 ReadInt8()
|
|
{
|
|
int8 u = 0;
|
|
(*this) >> u;
|
|
return u;
|
|
}
|
|
|
|
int16 ReadInt16()
|
|
{
|
|
int16 u = 0;
|
|
(*this) >> u;
|
|
return u;
|
|
}
|
|
|
|
int32 ReadInt32()
|
|
{
|
|
uint32 u = 0;
|
|
(*this) >> u;
|
|
return u;
|
|
}
|
|
|
|
int64 ReadInt64()
|
|
{
|
|
int64 u = 0;
|
|
(*this) >> u;
|
|
return u;
|
|
}
|
|
|
|
std::string ReadString()
|
|
{
|
|
std::string s = 0;
|
|
(*this) >> s;
|
|
return s;
|
|
}
|
|
|
|
bool ReadBoolean()
|
|
{
|
|
uint8 b = 0;
|
|
(*this) >> b;
|
|
return b > 0 ? true : false;
|
|
}
|
|
|
|
float ReadSingle()
|
|
{
|
|
float f = 0;
|
|
(*this) >> f;
|
|
return f;
|
|
}
|
|
|
|
const uint8 *contents() const { return &_storage[0]; }
|
|
|
|
size_t size() const { return _storage.size(); }
|
|
bool empty() const { return _storage.empty(); }
|
|
|
|
void resize(size_t newsize)
|
|
{
|
|
_storage.resize(newsize);
|
|
_rpos = 0;
|
|
_wpos = size();
|
|
}
|
|
|
|
void reserve(size_t ressize)
|
|
{
|
|
if (ressize > size())
|
|
_storage.reserve(ressize);
|
|
}
|
|
|
|
void append(const std::string& str)
|
|
{
|
|
append((uint8 const*)str.c_str(), str.size() + 1);
|
|
}
|
|
|
|
void append(const char *src, size_t cnt)
|
|
{
|
|
return append((const uint8 *)src, cnt);
|
|
}
|
|
|
|
template<class T> void append(const T *src, size_t cnt)
|
|
{
|
|
return append((const uint8 *)src, cnt * sizeof(T));
|
|
}
|
|
|
|
void append(const uint8 *src, size_t cnt)
|
|
{
|
|
if (!cnt)
|
|
return;
|
|
|
|
ASSERT(size() < 10000000);
|
|
|
|
if (_storage.size() < _wpos + cnt)
|
|
_storage.resize(_wpos + cnt);
|
|
memcpy(&_storage[_wpos], src, cnt);
|
|
_wpos += cnt;
|
|
}
|
|
|
|
void append(const ByteBuffer& buffer)
|
|
{
|
|
if (buffer.wpos())
|
|
append(buffer.contents(), buffer.wpos());
|
|
}
|
|
|
|
// can be used in SMSG_MONSTER_MOVE opcode
|
|
void appendPackXYZ(float x, float y, float z)
|
|
{
|
|
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;
|
|
}
|
|
|
|
void appendPackGUID(uint64 guid)
|
|
{
|
|
uint8 packGUID[8+1];
|
|
packGUID[0] = 0;
|
|
size_t size = 1;
|
|
for (uint8 i = 0;guid != 0;++i)
|
|
{
|
|
if (guid & 0xFF)
|
|
{
|
|
packGUID[0] |= uint8(1 << i);
|
|
packGUID[size] = uint8(guid & 0xFF);
|
|
++size;
|
|
}
|
|
|
|
guid >>= 8;
|
|
}
|
|
append(packGUID, size);
|
|
}
|
|
|
|
void put(size_t pos, const uint8 *src, size_t cnt)
|
|
{
|
|
if (pos + cnt > size())
|
|
throw ByteBufferException(true, pos, cnt, size());
|
|
memcpy(&_storage[pos], src, cnt);
|
|
}
|
|
|
|
void print_storage() const
|
|
{
|
|
if (!sLog->IsOutDebug()) // optimize disabled debug output
|
|
return;
|
|
|
|
sLog->outDebug(LOG_FILTER_NETWORKIO, "STORAGE_SIZE: %lu", (unsigned long)size() );
|
|
for (uint32 i = 0; i < size(); ++i)
|
|
sLog->outDebugInLine("%u - ", read<uint8>(i) );
|
|
sLog->outDebug(LOG_FILTER_NETWORKIO, " ");
|
|
}
|
|
|
|
void textlike() const
|
|
{
|
|
if (!sLog->IsOutDebug()) // optimize disabled debug output
|
|
return;
|
|
|
|
sLog->outDebug(LOG_FILTER_NETWORKIO, "STORAGE_SIZE: %lu", (unsigned long)size() );
|
|
for (uint32 i = 0; i < size(); ++i)
|
|
sLog->outDebugInLine("%c", read<uint8>(i) );
|
|
sLog->outDebug(LOG_FILTER_NETWORKIO, " ");
|
|
}
|
|
|
|
void hexlike() const
|
|
{
|
|
if (!sLog->IsOutDebug()) // optimize disabled debug output
|
|
return;
|
|
|
|
uint32 j = 1, k = 1;
|
|
sLog->outDebug(LOG_FILTER_NETWORKIO, "STORAGE_SIZE: %lu", (unsigned long)size() );
|
|
|
|
for (uint32 i = 0; i < size(); ++i)
|
|
{
|
|
if ((i == (j * 8)) && ((i != (k * 16))))
|
|
{
|
|
if (read<uint8>(i) < 0x10)
|
|
{
|
|
sLog->outDebugInLine("| 0%X ", read<uint8>(i) );
|
|
}
|
|
else
|
|
{
|
|
sLog->outDebugInLine("| %X ", read<uint8>(i) );
|
|
}
|
|
++j;
|
|
}
|
|
else if (i == (k * 16))
|
|
{
|
|
if (read<uint8>(i) < 0x10)
|
|
{
|
|
sLog->outDebugInLine("\n");
|
|
|
|
sLog->outDebugInLine("0%X ", read<uint8>(i) );
|
|
}
|
|
else
|
|
{
|
|
sLog->outDebugInLine("\n");
|
|
|
|
sLog->outDebugInLine("%X ", read<uint8>(i) );
|
|
}
|
|
|
|
++k;
|
|
++j;
|
|
}
|
|
else
|
|
{
|
|
if (read<uint8>(i) < 0x10)
|
|
{
|
|
sLog->outDebugInLine("0%X ", read<uint8>(i) );
|
|
}
|
|
else
|
|
{
|
|
sLog->outDebugInLine("%X ", read<uint8>(i) );
|
|
}
|
|
}
|
|
}
|
|
sLog->outDebugInLine("\n");
|
|
}
|
|
|
|
protected:
|
|
size_t _rpos, _wpos, _bitpos;
|
|
uint8 _curbitval;
|
|
std::vector<uint8> _storage;
|
|
};
|
|
|
|
template <typename T>
|
|
inline ByteBuffer &operator<<(ByteBuffer &b, std::vector<T> v)
|
|
{
|
|
b << (uint32)v.size();
|
|
for (typename std::vector<T>::iterator i = v.begin(); i != v.end(); ++i)
|
|
{
|
|
b << *i;
|
|
}
|
|
return b;
|
|
}
|
|
|
|
template <typename T>
|
|
inline ByteBuffer &operator>>(ByteBuffer &b, std::vector<T> &v)
|
|
{
|
|
uint32 vsize;
|
|
b >> vsize;
|
|
v.clear();
|
|
while (vsize--)
|
|
{
|
|
T t;
|
|
b >> t;
|
|
v.push_back(t);
|
|
}
|
|
return b;
|
|
}
|
|
|
|
template <typename T>
|
|
inline ByteBuffer &operator<<(ByteBuffer &b, std::list<T> v)
|
|
{
|
|
b << (uint32)v.size();
|
|
for (typename std::list<T>::iterator i = v.begin(); i != v.end(); ++i)
|
|
{
|
|
b << *i;
|
|
}
|
|
return b;
|
|
}
|
|
|
|
template <typename T>
|
|
inline ByteBuffer &operator>>(ByteBuffer &b, std::list<T> &v)
|
|
{
|
|
uint32 vsize;
|
|
b >> vsize;
|
|
v.clear();
|
|
while (vsize--)
|
|
{
|
|
T t;
|
|
b >> t;
|
|
v.push_back(t);
|
|
}
|
|
return b;
|
|
}
|
|
|
|
template <typename K, typename V>
|
|
inline ByteBuffer &operator<<(ByteBuffer &b, std::map<K, V> &m)
|
|
{
|
|
b << (uint32)m.size();
|
|
for (typename std::map<K, V>::iterator i = m.begin(); i != m.end(); ++i)
|
|
{
|
|
b << i->first << i->second;
|
|
}
|
|
return b;
|
|
}
|
|
|
|
template <typename K, typename V>
|
|
inline ByteBuffer &operator>>(ByteBuffer &b, std::map<K, V> &m)
|
|
{
|
|
uint32 msize;
|
|
b >> msize;
|
|
m.clear();
|
|
while (msize--)
|
|
{
|
|
K k;
|
|
V v;
|
|
b >> k >> v;
|
|
m.insert(make_pair(k, v));
|
|
}
|
|
return b;
|
|
}
|
|
|
|
// TODO: Make a ByteBuffer.cpp and move all this inlining to it.
|
|
template<> inline std::string ByteBuffer::read<std::string>()
|
|
{
|
|
std::string tmp;
|
|
*this >> tmp;
|
|
return tmp;
|
|
}
|
|
|
|
template<>
|
|
inline void ByteBuffer::read_skip<char*>()
|
|
{
|
|
std::string temp;
|
|
*this >> temp;
|
|
}
|
|
|
|
template<>
|
|
inline void ByteBuffer::read_skip<char const*>()
|
|
{
|
|
read_skip<char*>();
|
|
}
|
|
|
|
template<>
|
|
inline void ByteBuffer::read_skip<std::string>()
|
|
{
|
|
read_skip<char*>();
|
|
}
|
|
|
|
class BitConverter
|
|
{
|
|
public:
|
|
|
|
static uint8 ToUInt8(ByteBuffer buff, size_t start = 0)
|
|
{
|
|
return buff.read<uint8>(start);
|
|
}
|
|
|
|
static uint16 ToUInt16(ByteBuffer buff, size_t start = 0)
|
|
{
|
|
return buff.read<uint16>(start);
|
|
}
|
|
|
|
static uint32 ToUInt32(ByteBuffer buff, size_t start = 0)
|
|
{
|
|
return buff.read<uint32>(start);
|
|
}
|
|
|
|
static uint64 ToUInt64(ByteBuffer buff, size_t start = 0)
|
|
{
|
|
return buff.read<uint64>(start);
|
|
}
|
|
|
|
static int16 ToInt16(ByteBuffer buff, size_t start = 0)
|
|
{
|
|
return buff.read<int16>(start);
|
|
}
|
|
|
|
static int32 ToInt32(ByteBuffer buff, size_t start = 0)
|
|
{
|
|
return buff.read<int32>(start);
|
|
}
|
|
|
|
static int64 ToInt64(ByteBuffer buff, size_t start = 0)
|
|
{
|
|
return buff.read<int64>(start);
|
|
}
|
|
};
|
|
|
|
#endif
|
|
|