mirror of
https://github.com/mod-playerbots/azerothcore-wotlk.git
synced 2026-01-23 21:56:22 +00:00
feat(Core/Packets): Port packet handling from TrinityCore (#5617)
* feat(Core/Packets): Port packet handling from TrinityCore * 1 * 2 * 3 * 1 * 2 * #3670 * 3 * 1 * codestyle * fix msvc warnings
This commit is contained in:
Kargatum
@@ -1,69 +0,0 @@
|
||||
/*
|
||||
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it and/or modify it under version 2 of the License, or (at your option), any later version.
|
||||
* Copyright (C) 2008-2016 TrinityCore <http://www.trinitycore.org/>
|
||||
* Copyright (C) 2005-2009 MaNGOS <http://getmangos.com/>
|
||||
*/
|
||||
|
||||
#include "ByteBuffer.h"
|
||||
#include "Common.h"
|
||||
#include "Log.h"
|
||||
|
||||
#include <ace/Stack_Trace.h>
|
||||
#include <sstream>
|
||||
|
||||
ByteBufferPositionException::ByteBufferPositionException(bool add, size_t pos,
|
||||
size_t size, size_t valueSize)
|
||||
{
|
||||
std::ostringstream ss;
|
||||
|
||||
ss << "Attempted to " << (add ? "put" : "get") << " value with size: "
|
||||
<< valueSize << " in ByteBuffer (pos: " << pos << " size: " << size
|
||||
<< ")";
|
||||
|
||||
message().assign(ss.str());
|
||||
}
|
||||
|
||||
ByteBufferSourceException::ByteBufferSourceException(size_t pos, size_t size,
|
||||
size_t valueSize)
|
||||
{
|
||||
std::ostringstream ss;
|
||||
|
||||
ss << "Attempted to put a "
|
||||
<< (valueSize > 0 ? "NULL-pointer" : "zero-sized value")
|
||||
<< " in ByteBuffer (pos: " << pos << " size: " << size << ")";
|
||||
|
||||
message().assign(ss.str());
|
||||
}
|
||||
|
||||
void ByteBuffer::hexlike(bool outString) const
|
||||
{
|
||||
if (!outString)
|
||||
return;
|
||||
|
||||
uint32 j = 1, k = 1;
|
||||
|
||||
std::ostringstream o;
|
||||
o << "STORAGE_SIZE: " << size() << "\nCONTENTS:\n";
|
||||
|
||||
for (uint32 i = 0; i < size(); ++i)
|
||||
{
|
||||
char buf[3];
|
||||
snprintf(buf, 3, "%02X", read<uint8>(i));
|
||||
if ((i == (j * 8)) && ((i != (k * 16))))
|
||||
{
|
||||
o << "| ";
|
||||
++j;
|
||||
}
|
||||
else if (i == (k * 16))
|
||||
{
|
||||
o << "\n";
|
||||
++k;
|
||||
++j;
|
||||
}
|
||||
|
||||
o << buf << " ";
|
||||
}
|
||||
o << " ";
|
||||
|
||||
LOG_INFO("server", "%s", o.str().c_str());
|
||||
}
|
||||
@@ -1,628 +0,0 @@
|
||||
/*
|
||||
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it and/or modify it under version 2 of the License, or (at your option), any later version.
|
||||
* Copyright (C) 2008-2016 TrinityCore <http://www.trinitycore.org/>
|
||||
* Copyright (C) 2005-2009 MaNGOS <http://getmangos.com/>
|
||||
*/
|
||||
|
||||
#ifndef _BYTEBUFFER_H
|
||||
#define _BYTEBUFFER_H
|
||||
|
||||
#include "Common.h"
|
||||
#include "Errors.h"
|
||||
#include "Util.h"
|
||||
#include "ByteConverter.h"
|
||||
#include <exception>
|
||||
#include <list>
|
||||
#include <map>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
#include <cstring>
|
||||
#include <array>
|
||||
|
||||
// Root of ByteBuffer exception hierarchy
|
||||
class ByteBufferException : public std::exception
|
||||
{
|
||||
public:
|
||||
~ByteBufferException() noexcept override = default;
|
||||
|
||||
[[nodiscard]] char const* what() const noexcept override { return msg_.c_str(); }
|
||||
|
||||
protected:
|
||||
std::string& message() noexcept { return msg_; }
|
||||
|
||||
private:
|
||||
std::string msg_;
|
||||
};
|
||||
|
||||
class ByteBufferPositionException : public ByteBufferException
|
||||
{
|
||||
public:
|
||||
ByteBufferPositionException(bool add, size_t pos, size_t size, size_t valueSize);
|
||||
~ByteBufferPositionException() noexcept override = default;
|
||||
};
|
||||
|
||||
class ByteBufferSourceException : public ByteBufferException
|
||||
{
|
||||
public:
|
||||
ByteBufferSourceException(size_t pos, size_t size, size_t valueSize);
|
||||
~ByteBufferSourceException() noexcept override = default;
|
||||
};
|
||||
|
||||
class ByteBuffer
|
||||
{
|
||||
public:
|
||||
const static size_t DEFAULT_SIZE = 0x1000;
|
||||
|
||||
// constructor
|
||||
ByteBuffer()
|
||||
{
|
||||
_storage.reserve(DEFAULT_SIZE);
|
||||
}
|
||||
|
||||
ByteBuffer(size_t reserve) : _rpos(0), _wpos(0)
|
||||
{
|
||||
_storage.reserve(reserve);
|
||||
}
|
||||
|
||||
// copy constructor
|
||||
ByteBuffer(const ByteBuffer& buf) : _rpos(buf._rpos), _wpos(buf._wpos),
|
||||
_storage(buf._storage)
|
||||
{
|
||||
}
|
||||
/* requried as of C++ 11 */
|
||||
#if __cplusplus >= 201103L
|
||||
ByteBuffer(ByteBuffer&&) = default;
|
||||
ByteBuffer& operator=(const ByteBuffer&) = default;
|
||||
ByteBuffer& operator=(ByteBuffer&&) = default;
|
||||
#endif
|
||||
|
||||
void clear()
|
||||
{
|
||||
_storage.clear();
|
||||
_rpos = _wpos = 0;
|
||||
}
|
||||
|
||||
template <typename T> void append(T value)
|
||||
{
|
||||
EndianConvert(value);
|
||||
append((uint8*)&value, sizeof(value));
|
||||
}
|
||||
|
||||
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)
|
||||
{
|
||||
if (size_t len = value.length())
|
||||
append((uint8 const*)value.c_str(), len);
|
||||
append((uint8)0);
|
||||
return *this;
|
||||
}
|
||||
|
||||
ByteBuffer& operator<<(const char* str)
|
||||
{
|
||||
if (size_t len = (str ? strlen(str) : 0))
|
||||
append((uint8 const*)str, len);
|
||||
append((uint8)0);
|
||||
return *this;
|
||||
}
|
||||
|
||||
ByteBuffer& operator>>(bool& value)
|
||||
{
|
||||
value = (read<char>() > 0);
|
||||
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>();
|
||||
if (!myisfinite(value))
|
||||
{
|
||||
value = 0.0f;
|
||||
//throw ByteBufferException();
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
ByteBuffer& operator>>(double& value)
|
||||
{
|
||||
value = read<double>();
|
||||
if (!myisfinite(value))
|
||||
{
|
||||
value = 0.0f;
|
||||
//throw ByteBufferException();
|
||||
}
|
||||
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 const pos)
|
||||
{
|
||||
if (pos >= size())
|
||||
throw ByteBufferPositionException(false, pos, 1, size());
|
||||
return _storage[pos];
|
||||
}
|
||||
|
||||
uint8 const& operator[](size_t const pos) const
|
||||
{
|
||||
if (pos >= size())
|
||||
throw ByteBufferPositionException(false, pos, 1, size());
|
||||
return _storage[pos];
|
||||
}
|
||||
|
||||
[[nodiscard]] size_t rpos() const { return _rpos; }
|
||||
|
||||
size_t rpos(size_t rpos_)
|
||||
{
|
||||
_rpos = rpos_;
|
||||
return _rpos;
|
||||
}
|
||||
|
||||
void rfinish()
|
||||
{
|
||||
_rpos = wpos();
|
||||
}
|
||||
|
||||
[[nodiscard]] 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 ByteBufferPositionException(false, _rpos, skip, size());
|
||||
_rpos += skip;
|
||||
}
|
||||
|
||||
template <typename T> T read()
|
||||
{
|
||||
T r = read<T>(_rpos);
|
||||
_rpos += sizeof(T);
|
||||
return r;
|
||||
}
|
||||
|
||||
template <typename T> [[nodiscard]] [[nodiscard]] [[nodiscard]] [[nodiscard]] [[nodiscard]] [[nodiscard]] [[nodiscard]] [[nodiscard]] [[nodiscard]] [[nodiscard]] [[nodiscard]] T read(size_t pos) const
|
||||
{
|
||||
if (pos + sizeof(T) > size())
|
||||
throw ByteBufferPositionException(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 ByteBufferPositionException(false, _rpos, len, size());
|
||||
std::memcpy(dest, &_storage[_rpos], len);
|
||||
_rpos += len;
|
||||
}
|
||||
|
||||
template<size_t Size>
|
||||
void read(std::array<uint8, Size>& arr)
|
||||
{
|
||||
read(arr.data(), Size);
|
||||
}
|
||||
|
||||
void readPackGUID(uint64& guid)
|
||||
{
|
||||
if (rpos() + 1 > size())
|
||||
throw ByteBufferPositionException(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 ByteBufferPositionException(false, _rpos, 1, size());
|
||||
|
||||
uint8 bit;
|
||||
(*this) >> bit;
|
||||
guid |= (uint64(bit) << (i * 8));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
uint32 ReadPackedTime()
|
||||
{
|
||||
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(<));
|
||||
}
|
||||
|
||||
ByteBuffer& ReadPackedTime(uint32& time)
|
||||
{
|
||||
time = ReadPackedTime();
|
||||
return *this;
|
||||
}
|
||||
|
||||
uint8* contents()
|
||||
{
|
||||
if (_storage.empty())
|
||||
throw ByteBufferException();
|
||||
return &_storage[0];
|
||||
}
|
||||
|
||||
[[nodiscard]] const uint8* contents() const
|
||||
{
|
||||
if (_storage.empty())
|
||||
throw ByteBufferException();
|
||||
return &_storage[0];
|
||||
}
|
||||
|
||||
[[nodiscard]] size_t size() const { return _storage.size(); }
|
||||
[[nodiscard]] bool empty() const { return _storage.empty(); }
|
||||
|
||||
void resize(size_t newsize)
|
||||
{
|
||||
_storage.resize(newsize, 0);
|
||||
_rpos = 0;
|
||||
_wpos = size();
|
||||
}
|
||||
|
||||
void reserve(size_t ressize)
|
||||
{
|
||||
if (ressize > size())
|
||||
_storage.reserve(ressize);
|
||||
}
|
||||
|
||||
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)
|
||||
throw ByteBufferSourceException(_wpos, size(), cnt);
|
||||
|
||||
if (!src)
|
||||
throw ByteBufferSourceException(_wpos, size(), cnt);
|
||||
|
||||
ASSERT(size() < 10000000);
|
||||
|
||||
size_t newsize = _wpos + cnt;
|
||||
|
||||
if (_storage.capacity() < newsize) // pussywizard
|
||||
{
|
||||
if (newsize < 100)
|
||||
_storage.reserve(300);
|
||||
else if (newsize < 750)
|
||||
_storage.reserve(2500);
|
||||
else if (newsize < 6000)
|
||||
_storage.reserve(10000);
|
||||
else
|
||||
_storage.reserve(400000);
|
||||
}
|
||||
|
||||
if (_storage.size() < newsize)
|
||||
_storage.resize(newsize);
|
||||
|
||||
memcpy(&_storage[_wpos], src, cnt);
|
||||
_wpos = newsize;
|
||||
}
|
||||
|
||||
void append(const ByteBuffer& buffer)
|
||||
{
|
||||
if (buffer.wpos())
|
||||
append(buffer.contents(), buffer.wpos());
|
||||
}
|
||||
|
||||
template<size_t Size>
|
||||
void append(std::array<uint8, Size> const& arr)
|
||||
{
|
||||
append(arr.data(), Size);
|
||||
}
|
||||
|
||||
// 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 AppendPackedTime(time_t time)
|
||||
{
|
||||
tm lt;
|
||||
localtime_r(&time, <);
|
||||
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);
|
||||
}
|
||||
|
||||
void put(size_t pos, const uint8* src, size_t cnt)
|
||||
{
|
||||
if (pos + cnt > size())
|
||||
throw ByteBufferPositionException(true, pos, cnt, size());
|
||||
|
||||
if (!src)
|
||||
throw ByteBufferSourceException(_wpos, size(), cnt);
|
||||
|
||||
std::memcpy(&_storage[pos], src, cnt);
|
||||
}
|
||||
|
||||
void hexlike(bool outString = false) const;
|
||||
|
||||
protected:
|
||||
size_t _rpos{0}, _wpos{0};
|
||||
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*>();
|
||||
}
|
||||
|
||||
#endif
|
||||
@@ -1,54 +0,0 @@
|
||||
/*
|
||||
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it and/or modify it under version 2 of the License, or (at your option), any later version.
|
||||
* Copyright (C) 2008-2016 TrinityCore <http://www.trinitycore.org/>
|
||||
* Copyright (C) 2005-2009 MaNGOS <http://getmangos.com/>
|
||||
*/
|
||||
|
||||
#ifndef AZEROTHCORE_WORLDPACKET_H
|
||||
#define AZEROTHCORE_WORLDPACKET_H
|
||||
|
||||
#include "Common.h"
|
||||
#include "ByteBuffer.h"
|
||||
#include "Duration.h"
|
||||
|
||||
class WorldPacket : public ByteBuffer
|
||||
{
|
||||
public:
|
||||
// just container for later use
|
||||
WorldPacket() : ByteBuffer(0)
|
||||
{
|
||||
}
|
||||
explicit WorldPacket(uint16 opcode, size_t res = 200) : ByteBuffer(res), m_opcode(opcode) { }
|
||||
|
||||
WorldPacket(WorldPacket&& packet, TimePoint receivedTime) : ByteBuffer(std::move(packet)), m_opcode(packet.m_opcode), m_receivedTime(receivedTime)
|
||||
{
|
||||
}
|
||||
|
||||
// copy constructor
|
||||
WorldPacket(const WorldPacket& packet) : ByteBuffer(packet), m_opcode(packet.m_opcode)
|
||||
{
|
||||
}
|
||||
/* requried as of C++ 11 */
|
||||
#if __cplusplus >= 201103L
|
||||
WorldPacket(WorldPacket&&) = default;
|
||||
WorldPacket& operator=(const WorldPacket&) = default;
|
||||
WorldPacket& operator=(WorldPacket&&) = default;
|
||||
#endif
|
||||
|
||||
void Initialize(uint16 opcode, size_t newres = 200)
|
||||
{
|
||||
clear();
|
||||
_storage.reserve(newres);
|
||||
m_opcode = opcode;
|
||||
}
|
||||
|
||||
[[nodiscard]] uint16 GetOpcode() const { return m_opcode; }
|
||||
void SetOpcode(uint16 opcode) { m_opcode = opcode; }
|
||||
|
||||
[[nodiscard]] TimePoint GetReceivedTime() const { return m_receivedTime; }
|
||||
|
||||
protected:
|
||||
uint16 m_opcode{0};
|
||||
TimePoint m_receivedTime; // only set for a specific set of opcodes, for performance reasons.
|
||||
};
|
||||
#endif
|
||||
128
src/common/Utilities/MessageBuffer.h
Normal file
128
src/common/Utilities/MessageBuffer.h
Normal file
@@ -0,0 +1,128 @@
|
||||
/*
|
||||
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU AGPL v3 license: https://github.com/azerothcore/azerothcore-wotlk/blob/master/LICENSE-AGPL3
|
||||
* Copyright (C) 2021+ WarheadCore <https://github.com/WarheadCore>
|
||||
*/
|
||||
|
||||
#ifndef __MESSAGEBUFFER_H_
|
||||
#define __MESSAGEBUFFER_H_
|
||||
|
||||
#include "Define.h"
|
||||
#include <vector>
|
||||
#include <cstring>
|
||||
|
||||
class MessageBuffer
|
||||
{
|
||||
using size_type = std::vector<uint8>::size_type;
|
||||
|
||||
public:
|
||||
MessageBuffer() : _wpos(0), _rpos(0), _storage()
|
||||
{
|
||||
_storage.resize(4096);
|
||||
}
|
||||
|
||||
explicit MessageBuffer(std::size_t initialSize) : _wpos(0), _rpos(0), _storage()
|
||||
{
|
||||
_storage.resize(initialSize);
|
||||
}
|
||||
|
||||
MessageBuffer(MessageBuffer const& right) :
|
||||
_wpos(right._wpos), _rpos(right._rpos), _storage(right._storage) { }
|
||||
|
||||
MessageBuffer(MessageBuffer&& right) noexcept :
|
||||
_wpos(right._wpos), _rpos(right._rpos), _storage(right.Move()) { }
|
||||
|
||||
void Reset()
|
||||
{
|
||||
_wpos = 0;
|
||||
_rpos = 0;
|
||||
}
|
||||
|
||||
void Resize(size_type bytes)
|
||||
{
|
||||
_storage.resize(bytes);
|
||||
}
|
||||
|
||||
uint8* GetBasePointer() { return _storage.data(); }
|
||||
uint8* GetReadPointer() { return GetBasePointer() + _rpos; }
|
||||
uint8* GetWritePointer() { return GetBasePointer() + _wpos; }
|
||||
|
||||
void ReadCompleted(size_type bytes) { _rpos += bytes; }
|
||||
void WriteCompleted(size_type bytes) { _wpos += bytes; }
|
||||
|
||||
[[nodiscard]] size_type GetActiveSize() const { return _wpos - _rpos; }
|
||||
[[nodiscard]] size_type GetRemainingSpace() const { return _storage.size() - _wpos; }
|
||||
[[nodiscard]] size_type GetBufferSize() const { return _storage.size(); }
|
||||
|
||||
// Discards inactive data
|
||||
void Normalize()
|
||||
{
|
||||
if (_rpos)
|
||||
{
|
||||
if (_rpos != _wpos)
|
||||
{
|
||||
memmove(GetBasePointer(), GetReadPointer(), GetActiveSize());
|
||||
}
|
||||
|
||||
_wpos -= _rpos;
|
||||
_rpos = 0;
|
||||
}
|
||||
}
|
||||
|
||||
// Ensures there's "some" free space, make sure to call Normalize() before this
|
||||
void EnsureFreeSpace()
|
||||
{
|
||||
// resize buffer if it's already full
|
||||
if (GetRemainingSpace() == 0)
|
||||
{
|
||||
_storage.resize(_storage.size() * 3 / 2);
|
||||
}
|
||||
}
|
||||
|
||||
void Write(void const* data, std::size_t size)
|
||||
{
|
||||
if (size)
|
||||
{
|
||||
memcpy(GetWritePointer(), data, size);
|
||||
WriteCompleted(size);
|
||||
}
|
||||
}
|
||||
|
||||
std::vector<uint8>&& Move()
|
||||
{
|
||||
_wpos = 0;
|
||||
_rpos = 0;
|
||||
|
||||
return std::move(_storage);
|
||||
}
|
||||
|
||||
MessageBuffer& operator=(MessageBuffer const& right)
|
||||
{
|
||||
if (this != &right)
|
||||
{
|
||||
_wpos = right._wpos;
|
||||
_rpos = right._rpos;
|
||||
_storage = right._storage;
|
||||
}
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
MessageBuffer& operator=(MessageBuffer&& right) noexcept
|
||||
{
|
||||
if (this != &right)
|
||||
{
|
||||
_wpos = right._wpos;
|
||||
_rpos = right._rpos;
|
||||
_storage = right.Move();
|
||||
}
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
private:
|
||||
size_type _wpos;
|
||||
size_type _rpos;
|
||||
std::vector<uint8> _storage;
|
||||
};
|
||||
|
||||
#endif /* __MESSAGEBUFFER_H_ */
|
||||
53
src/common/Utilities/Tuples.h
Normal file
53
src/common/Utilities/Tuples.h
Normal file
@@ -0,0 +1,53 @@
|
||||
/*
|
||||
* Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU AGPL v3 license: https://github.com/azerothcore/azerothcore-wotlk/blob/master/LICENSE-AGPL3
|
||||
* Copyright (C) 2021+ WarheadCore <https://github.com/WarheadCore>
|
||||
*/
|
||||
|
||||
#ifndef Tuples_h__
|
||||
#define Tuples_h__
|
||||
|
||||
#include <tuple>
|
||||
|
||||
namespace acore
|
||||
{
|
||||
template <typename T, typename Tuple>
|
||||
struct has_type;
|
||||
|
||||
template <typename T, typename... Us>
|
||||
struct has_type<T, std::tuple<Us...>> : std::disjunction<std::is_same<T, Us>...>
|
||||
{
|
||||
};
|
||||
|
||||
template <typename T, typename... Us>
|
||||
constexpr bool has_type_v = has_type<T, Us...>::value;
|
||||
|
||||
template<typename>
|
||||
struct is_tuple : std::false_type
|
||||
{
|
||||
};
|
||||
|
||||
template<typename... Ts>
|
||||
struct is_tuple<std::tuple<Ts...>> : std::true_type
|
||||
{
|
||||
};
|
||||
|
||||
template<typename... Ts>
|
||||
constexpr bool is_tuple_v = is_tuple<Ts...>::value;
|
||||
|
||||
namespace Impl
|
||||
{
|
||||
template <class T, class Tuple, size_t... I>
|
||||
T* new_from_tuple(Tuple&& args, std::index_sequence<I...>)
|
||||
{
|
||||
return new T(std::get<I>(std::forward<Tuple>(args))...);
|
||||
}
|
||||
}
|
||||
|
||||
template<class T, class Tuple>
|
||||
[[nodiscard]] T* new_from_tuple(Tuple&& args)
|
||||
{
|
||||
return Impl::new_from_tuple<T>(std::forward<Tuple>(args), std::make_index_sequence<std::tuple_size_v<std::remove_reference_t<Tuple>>>{});
|
||||
}
|
||||
}
|
||||
|
||||
#endif // Tuples_h__
|
||||
Reference in New Issue
Block a user