Packetizer.h

Go to the documentation of this file.

// 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"



class cByteBuffer;


// fwd:
class cUUID;





class cPacketizer
{
public:
    cPacketizer(cProtocol & a_Protocol, cProtocol::ePacketType 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.WriteVarInt32(m_Protocol.GetPacketID(a_PacketType));
    }

    ~cPacketizer();

    inline void WriteBool(bool a_Value)
    {
        VERIFY(m_Out.WriteBool(a_Value));
    }

    inline void WriteBEUInt8(UInt8 a_Value)
    {
        VERIFY(m_Out.WriteBEUInt8(a_Value));
    }


    inline void WriteBEInt8(Int8 a_Value)
    {
        VERIFY(m_Out.WriteBEInt8(a_Value));
    }


    inline void WriteBEInt16(Int16 a_Value)
    {
        VERIFY(m_Out.WriteBEInt16(a_Value));
    }


    inline void WriteBEUInt16(UInt16 a_Value)
    {
        VERIFY(m_Out.WriteBEUInt16(a_Value));
    }


    inline void WriteBEInt32(Int32 a_Value)
    {
        VERIFY(m_Out.WriteBEInt32(a_Value));
    }


    inline void WriteBEUInt32(UInt32 a_Value)
    {
        VERIFY(m_Out.WriteBEUInt32(a_Value));
    }


    inline void WriteBEInt64(Int64 a_Value)
    {
        VERIFY(m_Out.WriteBEInt64(a_Value));
    }


    inline void WriteBEUInt64(UInt64 a_Value)
    {
        VERIFY(m_Out.WriteBEUInt64(a_Value));
    }


    inline void WriteBEFloat(float a_Value)
    {
        VERIFY(m_Out.WriteBEFloat(a_Value));
    }


    inline void WriteBEDouble(double a_Value)
    {
        VERIFY(m_Out.WriteBEDouble(a_Value));
    }


    inline void WriteVarInt32(UInt32 a_Value)
    {
        VERIFY(m_Out.WriteVarInt32(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));
    }


    inline void WritePosition64(int a_BlockX, int a_BlockY, int a_BlockZ)
    {
        VERIFY(m_Out.WritePosition64(a_BlockX, a_BlockY, a_BlockZ));
    }

    void WriteByteAngle(double a_Angle);

    void WriteFPInt(double a_Value);

    void WriteUUID(const cUUID & a_UUID);

    cProtocol::ePacketType GetPacketType() const { return m_PacketType; }

    static AString PacketTypeToStr(cProtocol::ePacketType a_PacketType);

protected:
    cProtocol & m_Protocol;

    cByteBuffer & m_Out;

    cCSLock m_Lock;

    cProtocol::ePacketType m_PacketType;
} ;