Core/Misc: Replaced boost::container::static_vector in packet classes with plain vector with custom static storage allocatlr

(cherry picked from commit b65c3f5f4a4edbc953c405bfacd33f186f3a1931)

3 files changed, 62 insertions, 122 deletions

diff --git a/src/common/CMakeLists.txt b/src/common/CMakeLists.txt
index 5258258a7c6..67d0d663c73 100644
--- a/src/common/CMakeLists.txt
+++ b/src/common/CMakeLists.txt
@@ -72,7 +72,8 @@ target_link_libraries(common
     openssl
     valgrind
     threads
-    jemalloc)
+    jemalloc
+    short_alloc)
 
 add_dependencies(common revision_data.h)
 
diff --git a/src/server/game/Server/Packets/PacketUtilities.cpp b/src/server/game/Server/Packets/PacketUtilities.cpp
index 862c643013c..fe7487daaee 100644
--- a/src/server/game/Server/Packets/PacketUtilities.cpp
+++ b/src/server/game/Server/Packets/PacketUtilities.cpp
@@ -17,10 +17,7 @@
 
 #include "PacketUtilities.h"
 #include "Hyperlinks.h"
-#include "Errors.h"
 #include <utf8.h>
-#include <sstream>
-#include <array>
 
 WorldPackets::InvalidStringValueException::InvalidStringValueException(std::string const& value) : ByteBufferInvalidValueException("string", value.c_str())
 {
@@ -61,12 +58,5 @@ bool WorldPackets::Strings::NoHyperlinks::Validate(std::string const& value)
 
 WorldPackets::PacketArrayMaxCapacityException::PacketArrayMaxCapacityException(std::size_t requestedSize, std::size_t sizeLimit)
 {
-    std::ostringstream builder;
-    builder << "Attempted to read more array elements from packet " << requestedSize << " than allowed " << sizeLimit;
-    message().assign(builder.str());
-}
-
-void WorldPackets::CheckCompactArrayMaskOverflow(std::size_t index, std::size_t limit)
-{
-    ASSERT(index < limit, "Attempted to insert " SZFMTD " values into CompactArray but it can only hold " SZFMTD, index, limit);
+    message().assign("Attempted to read more array elements from packet " + Trinity::ToString(requestedSize) + " than allowed " + Trinity::ToString(sizeLimit));
 }
diff --git a/src/server/game/Server/Packets/PacketUtilities.h b/src/server/game/Server/Packets/PacketUtilities.h
index 0c06be5ea71..8b05803bb2b 100644
--- a/src/server/game/Server/Packets/PacketUtilities.h
+++ b/src/server/game/Server/Packets/PacketUtilities.h
@@ -20,6 +20,7 @@
 
 #include "ByteBuffer.h"
 #include "Tuples.h"
+#include <short_alloc/short_alloc.h>
 #include <string_view>
 
 namespace WorldPackets
@@ -114,21 +115,49 @@ namespace WorldPackets
     /**
      * Utility class for automated prevention of loop counter spoofing in client packets
      */
-    template<typename T, std::size_t N = 1000 /*select a sane default limit*/>
+    template<typename T, std::size_t N>
     class Array
     {
-        typedef std::vector<T> storage_type;
+    public:
+        using allocator_type = short_alloc::short_alloc<T, (N * sizeof(T) + (alignof(std::max_align_t) - 1)) & ~(alignof(std::max_align_t) - 1)>;
+        using arena_type = typename allocator_type::arena_type;
 
-        typedef typename storage_type::value_type value_type;
-        typedef typename storage_type::size_type size_type;
-        typedef typename storage_type::reference reference;
-        typedef typename storage_type::const_reference const_reference;
-        typedef typename storage_type::iterator iterator;
-        typedef typename storage_type::const_iterator const_iterator;
+        using storage_type = std::vector<T, allocator_type>;
 
-    public:
-        Array() : _limit(N) { }
-        Array(size_type limit) : _limit(limit) { }
+        using max_capacity = std::integral_constant<std::size_t, N>;
+
+        using value_type = typename storage_type::value_type;
+        using size_type = typename storage_type::size_type;
+        using pointer = typename storage_type::pointer;
+        using const_pointer = typename storage_type::const_pointer;
+        using reference = typename storage_type::reference;
+        using const_reference = typename storage_type::const_reference;
+        using iterator = typename storage_type::iterator;
+        using const_iterator = typename storage_type::const_iterator;
+
+        Array() : _storage(_data) { }
+
+        Array(Array const& other) : Array()
+        {
+            for (T const& element : other)
+                _storage.push_back(element);
+        }
+
+        Array(Array&& other) noexcept = delete;
+
+        Array& operator=(Array const& other)
+        {
+            if (this == &other)
+                return *this;
+
+            _storage.clear();
+            for (T const& element : other)
+                _storage.push_back(element);
+
+            return *this;
+        }
+
+        Array& operator=(Array&& other) noexcept = delete;
 
         iterator begin() { return _storage.begin(); }
         const_iterator begin() const { return _storage.begin(); }
@@ -136,6 +165,9 @@ namespace WorldPackets
         iterator end() { return _storage.end(); }
         const_iterator end() const { return _storage.end(); }
 
+        pointer data() { return _storage.data(); }
+        const_pointer data() const { return _storage.data(); }
+
         size_type size() const { return _storage.size(); }
         bool empty() const { return _storage.empty(); }
 
@@ -144,132 +176,49 @@ namespace WorldPackets
 
         void resize(size_type newSize)
         {
-            if (newSize > _limit)
-                throw PacketArrayMaxCapacityException(newSize, _limit);
+            if (newSize > max_capacity::value)
+                throw PacketArrayMaxCapacityException(newSize, max_capacity::value);
 
             _storage.resize(newSize);
         }
 
-        void reserve(size_type newSize)
-        {
-            if (newSize > _limit)
-                throw PacketArrayMaxCapacityException(newSize, _limit);
-
-            _storage.reserve(newSize);
-        }
-
         void push_back(value_type const& value)
         {
-            if (_storage.size() >= _limit)
-                throw PacketArrayMaxCapacityException(_storage.size() + 1, _limit);
+            if (_storage.size() >= max_capacity::value)
+                throw PacketArrayMaxCapacityException(_storage.size() + 1, max_capacity::value);
 
             _storage.push_back(value);
         }
 
         void push_back(value_type&& value)
         {
-            if (_storage.size() >= _limit)
-                throw PacketArrayMaxCapacityException(_storage.size() + 1, _limit);
+            if (_storage.size() >= max_capacity::value)
+                throw PacketArrayMaxCapacityException(_storage.size() + 1, max_capacity::value);
 
             _storage.push_back(std::forward<value_type>(value));
         }
 
-    private:
-        storage_type _storage;
-        size_type _limit;
-    };
-
-    void CheckCompactArrayMaskOverflow(std::size_t index, std::size_t limit);
-
-    template <typename T>
-    class CompactArray
-    {
-    public:
-        CompactArray() : _mask(0) { }
-
-        CompactArray(CompactArray const& right)
-            : _mask(right._mask), _contents(right._contents) { }
-
-        CompactArray(CompactArray&& right)
-            : _mask(right._mask), _contents(std::move(right._contents))
-        {
-            right._mask = 0;
-        }
-
-        CompactArray& operator=(CompactArray const& right)
-        {
-            _mask = right._mask;
-            _contents = right._contents;
-            return *this;
-        }
-
-        CompactArray& operator=(CompactArray&& right)
+        template<typename... Args>
+        T& emplace_back(Args&&... args)
         {
-            _mask = right._mask;
-            right._mask = 0;
-            _contents = std::move(right._contents);
-            return *this;
+            _storage.emplace_back(std::forward<Args>(args)...);
+            return _storage.back();
         }
 
-        uint32 GetMask() const { return _mask; }
-        T const& operator[](std::size_t index) const { return _contents.at(index); }
-        std::size_t GetSize() const { return _contents.size(); }
-
-        void Insert(std::size_t index, T const& value)
+        iterator erase(const_iterator first, const_iterator last)
         {
-            CheckCompactArrayMaskOverflow(index, sizeof(_mask) * 8);
-
-            _mask |= 1 << index;
-            if (_contents.size() <= index)
-                _contents.resize(index + 1);
-            _contents[index] = value;
+            return _storage.erase(first, last);
         }
 
-        void Clear()
+        void clear()
         {
-            _mask = 0;
-            _contents.clear();
+            _storage.clear();
         }
 
-        bool operator==(CompactArray const& r) const
-        {
-            if (_mask != r._mask)
-                return false;
-
-            return _contents == r._contents;
-        }
-
-        bool operator!=(CompactArray const& r) const { return !(*this == r); }
-
     private:
-        uint32 _mask;
-        std::vector<T> _contents;
+        arena_type _data;
+        storage_type _storage;
     };
-
-    template <typename T>
-    ByteBuffer& operator<<(ByteBuffer& data, CompactArray<T> const& v)
-    {
-        uint32 mask = v.GetMask();
-        data << uint32(mask);
-        for (std::size_t i = 0; i < v.GetSize(); ++i)
-            if (mask & (1 << i))
-                data << v[i];
-
-        return data;
-    }
-
-    template <typename T>
-    ByteBuffer& operator>>(ByteBuffer& data, CompactArray<T>& v)
-    {
-        uint32 mask;
-        data >> mask;
-
-        for (std::size_t index = 0; mask != 0; mask >>= 1, ++index)
-            if ((mask & 1) != 0)
-                v.Insert(index, data.read<T>());
-
-        return data;
-    }
 }
 
 #endif // PacketUtilities_h__