From 9002c009f053da615744b2263585792d476dbdba Mon Sep 17 00:00:00 2001
From: Shauren <shauren.trinity@gmail.com>
Date: Wed, 31 Jul 2024 11:43:39 +0200
Subject: Core/PacketIO: Added new packet reading/writing utilities for type
 casting, optionals and bits

(cherry picked from commit f41ab921b9e32bd952ab712f99aa9754753ba43e)
---
 src/server/game/Server/Packets/PacketUtilities.h | 116 +++++++++++++++++++++++
 1 file changed, 116 insertions(+)

(limited to 'src')

diff --git a/src/server/game/Server/Packets/PacketUtilities.h b/src/server/game/Server/Packets/PacketUtilities.h
index 9810ae932f4..30973bb3f07 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 "Duration.h"
+#include "Optional.h"
 #include "Tuples.h"
 #include <short_alloc/short_alloc.h>
 #include <string_view>
@@ -317,6 +318,121 @@ namespace WorldPackets
     private:
         ChronoDuration _value = ChronoDuration::zero();
     };
+
+    template<typename Underlying, typename T>
+    struct AsWriter
+    {
+        T const& Value;
+
+        friend inline ByteBuffer& operator<<(ByteBuffer& data, AsWriter const& opt)
+        {
+            data << Underlying(opt.Value);
+            return data;
+        }
+    };
+
+    template<typename Underlying, typename T>
+    struct AsReaderWriter : AsWriter<Underlying, T>
+    {
+        friend inline ByteBuffer& operator>>(ByteBuffer& data, AsReaderWriter const& opt)
+        {
+            Underlying temp;
+            data >> temp;
+            const_cast<T&>(opt.Value) = static_cast<T>(temp);
+            return data;
+        }
+    };
+
+    template<typename Underlying, typename T>
+    inline AsWriter<Underlying, T> As(T const& value) { return { value }; }
+
+    template<typename Underlying, typename T>
+    inline AsReaderWriter<Underlying, T> As(T& value) { return { value }; }
+
+    template<typename T>
+    struct OptionalInitWriter
+    {
+        Optional<T> const& Opt;
+
+        friend inline ByteBuffer& operator<<(ByteBuffer& data, OptionalInitWriter const& opt)
+        {
+            data.WriteBit(opt.Opt.has_value());
+            return data;
+        }
+    };
+
+    template<typename T>
+    struct OptionalInitReaderWriter : OptionalInitWriter<T>
+    {
+        friend inline ByteBuffer& operator>>(ByteBuffer& data, OptionalInitReaderWriter const& opt)
+        {
+            if (data.ReadBit())
+                const_cast<Optional<T>&>(opt.Opt).emplace();
+            return data;
+        }
+    };
+
+    template<typename T>
+    inline OptionalInitWriter<T> OptionalInit(Optional<T> const& value) { return { value }; }
+
+    template<typename T>
+    inline OptionalInitReaderWriter<T> OptionalInit(Optional<T>& value) { return { value }; }
+
+    template<uint32 BitCount, typename T>
+    struct BitsWriter
+    {
+        T const& Value;
+
+        friend inline ByteBuffer& operator<<(ByteBuffer& data, BitsWriter const& bits)
+        {
+            data.WriteBits(static_cast<uint32>(bits.Value), BitCount);
+            return data;
+        }
+    };
+
+    template<uint32 BitCount, typename T>
+    struct BitsReaderWriter : BitsWriter<BitCount, T>
+    {
+        friend inline ByteBuffer& operator>>(ByteBuffer& data, BitsReaderWriter const& bits)
+        {
+            const_cast<T&>(bits.Value) = static_cast<T>(data.ReadBits(BitCount));
+            return data;
+        }
+    };
+
+    template<uint32 BitCount, typename T>
+    inline BitsWriter<BitCount, T> Bits(T const& value) { return { value }; }
+
+    template<uint32 BitCount, typename T>
+    inline BitsReaderWriter<BitCount, T> Bits(T& value) { return { value }; }
+
+    template<uint32 BitCount, typename Container>
+    struct BitsSizeWriter
+    {
+        Container const& Value;
+
+        friend inline ByteBuffer& operator<<(ByteBuffer& data, BitsSizeWriter const& bits)
+        {
+            data.WriteBits(static_cast<uint32>(bits.Value.size()), BitCount);
+            return data;
+        }
+    };
+
+    template<uint32 BitCount, typename Container>
+    struct BitsSizeReaderWriter : BitsSizeWriter<BitCount, Container>
+    {
+        friend inline ByteBuffer& operator>>(ByteBuffer& data, BitsSizeReaderWriter const& bits)
+        {
+            const_cast<Container&>(bits.Value).resize(data.ReadBits(BitCount));
+            return data;
+        }
+    };
+
+    template<uint32 BitCount, typename Container>
+    inline BitsSizeWriter<BitCount, Container> BitsSize(Container const& value) { return { value }; }
+
+    template<uint32 BitCount, typename Container>
+    inline BitsSizeReaderWriter<BitCount, Container> BitsSize(Container& value) { return { value }; }
 }
 
 #endif // PacketUtilities_h__
-- 
cgit v1.2.3