1 files changed, 149 insertions, 0 deletions

diff --git a/src/Protocol/Packetizer.h b/src/Protocol/Packetizer.h
new file mode 100644
index 000000000..98b50c73f
--- /dev/null
+++ b/src/Protocol/Packetizer.h
@@ -0,0 +1,149 @@
+
+// Packetizer.h
+
+// Declares the cPacketizer class representing a wrapper for sending a single packet over a protocol.
+// The class provides auto-locking, serialization and send-on-instance-destroy semantics
+
+
+
+
+
+#pragma once
+
+#include "Protocol.h"
+#include "../ByteBuffer.h"
+
+
+
+
+
+/** Composes an individual packet in the protocol's m_OutPacketBuffer; sends it just before being destructed. */
+class cPacketizer
+{
+public:
+	/** Starts serializing a new packet into the protocol's m_OutPacketBuffer.
+	Locks the protocol's m_CSPacket to avoid multithreading issues. */
+	cPacketizer(cProtocol & a_Protocol, UInt32 a_PacketType) :
+		m_Protocol(a_Protocol),
+		m_Out(a_Protocol.m_OutPacketBuffer),
+		m_Lock(a_Protocol.m_CSPacket),
+		m_PacketType(a_PacketType)  // Used for logging purposes
+	{
+		m_Out.WriteVarInt(a_PacketType);
+	}
+
+	/** Sends the packet via the contained protocol's SendPacket() function. */
+	~cPacketizer();
+
+	inline void WriteBool(bool a_Value)
+	{
+		VERIFY(m_Out.WriteBool(a_Value));
+	}
+
+	inline void WriteByte(Byte a_Value)
+	{
+		VERIFY(m_Out.WriteBEUInt8(a_Value));
+	}
+
+
+	inline void WriteChar(char a_Value)
+	{
+		VERIFY(m_Out.WriteBEInt8(a_Value));
+	}
+
+
+	inline void WriteShort(short a_Value)
+	{
+		VERIFY(m_Out.WriteBEInt16(a_Value));
+	}
+
+
+	inline void WriteBEUInt16(short a_Value)
+	{
+		VERIFY(m_Out.WriteBEUInt16(a_Value));
+	}
+
+
+	inline void WriteInt(Int32 a_Value)
+	{
+		VERIFY(m_Out.WriteBEInt32(a_Value));
+	}
+
+
+	inline void WriteUInt32(UInt32 a_Value)
+	{
+		VERIFY(m_Out.WriteBEUInt32(a_Value));
+	}
+
+
+	inline void WriteInt64(Int64 a_Value)
+	{
+		VERIFY(m_Out.WriteBEInt64(a_Value));
+	}
+
+
+	inline void WriteFloat(float a_Value)
+	{
+		VERIFY(m_Out.WriteBEFloat(a_Value));
+	}
+
+
+	inline void WriteDouble(double a_Value)
+	{
+		VERIFY(m_Out.WriteBEDouble(a_Value));
+	}
+
+
+	inline void WriteVarInt(UInt32 a_Value)
+	{
+		VERIFY(m_Out.WriteVarInt(a_Value));
+	}
+
+
+	inline void WriteString(const AString & a_Value)
+	{
+		VERIFY(m_Out.WriteVarUTF8String(a_Value));
+	}
+
+
+	inline void WriteBuf(const char * a_Data, size_t a_Size)
+	{
+		VERIFY(m_Out.Write(a_Data, a_Size));
+	}
+
+
+	/** Writes the specified block position as a single encoded 64-bit BigEndian integer. */
+	inline void WritePosition(int a_BlockX, int a_BlockY, int a_BlockZ)
+	{
+		VERIFY(m_Out.WritePosition64(a_BlockX, a_BlockY, a_BlockZ));
+	}
+
+	/** Writes the specified angle using a single byte. */
+	void WriteByteAngle(double a_Angle);
+
+	/** Writes the double value as a 27:5 fixed-point integer. */
+	void WriteFPInt(double a_Value);
+
+	/** Writes the specified UUID as a 128-bit BigEndian integer. */
+	void WriteUUID(const AString & a_UUID);
+
+	UInt32 GetPacketType(void) const { return m_PacketType; }
+
+protected:
+	/** The protocol instance in which the packet is being constructed. */
+	cProtocol & m_Protocol;
+
+	/** The protocol's buffer for the constructed packet data. */
+	cByteBuffer & m_Out;
+
+	/** The RAII lock preventing multithreaded access to the protocol buffer while constructing the packet. */
+	cCSLock m_Lock;
+
+	/** Type of the contained packet.
+	Used for logging purposes, the packet type is encoded into m_Out immediately in constructor. */
+	UInt32 m_PacketType;
+} ;
+
+
+
+