ByteBuffer.h

Go to the documentation of this file.

 
// ByteStream.h
 
// Interfaces to the cByteBuffer class representing a ringbuffer of bytes
 
 
 
 
 
#pragma once
 
 
 
 
 
// fwd:
class cUUID;
 
 
class cByteBuffer
{
public:
    cByteBuffer(size_t a_BufferSize);
    ~cByteBuffer();
 
    bool Write(const void * a_Bytes, size_t a_Count);
 
    size_t GetFreeSpace(void) const;
 
    size_t GetUsedSpace(void) const;
 
    size_t GetReadableSpace(void) const;
 
    size_t  GetDataStart(void) const { return m_DataStart; }
 
    bool CanReadBytes(size_t a_Count) const;
 
    bool CanWriteBytes(size_t a_Count) const;
 
    // Read the specified datatype and advance the read pointer; return true if successfully read:
    bool ReadBEInt8         (Int8 & a_Value);
    bool ReadBEInt16        (Int16 & a_Value);
    bool ReadBEInt32        (Int32 & a_Value);
    bool ReadBEInt64        (Int64 & a_Value);
    bool ReadBEUInt8        (UInt8 & a_Value);
    bool ReadBEUInt16       (UInt16 & a_Value);
    bool ReadBEUInt32       (UInt32 & a_Value);
    bool ReadBEUInt64       (UInt64 & a_Value);
    bool ReadBEFloat        (float & a_Value);
    bool ReadBEDouble       (double & a_Value);
    bool ReadBool           (bool & a_Value);
    bool ReadVarInt32       (UInt32 & a_Value);
    bool ReadVarInt64       (UInt64 & a_Value);
    bool ReadVarUTF8String  (AString & a_Value);  // string length as VarInt, then string as UTF-8
    bool ReadLEInt          (int & a_Value);
    bool ReadXYZPosition64  (int & a_BlockX, int & a_BlockY, int & a_BlockZ);
    bool ReadXYZPosition64  (Vector3i & a_Position);
    bool ReadXZYPosition64  (int & a_BlockX, int & a_BlockY, int & a_BlockZ);
    bool ReadXZYPosition64  (Vector3i & a_Position);
    bool ReadUUID           (cUUID & a_Value);
 
    template <typename T> bool ReadVarInt(T & a_Value)
    {
        UInt64 v;
        bool res = ReadVarInt64(v);
        if (res)
        {
            a_Value = static_cast<T>(v);
        }
        return res;
    }
 
    // Write the specified datatype; return true if successfully written
    bool WriteBEInt8         (Int8   a_Value);
    bool WriteBEInt8         (std::byte a_Value);
    bool WriteBEInt16        (Int16  a_Value);
    bool WriteBEInt32        (Int32  a_Value);
    bool WriteBEInt64        (Int64  a_Value);
    bool WriteBEUInt8        (UInt8  a_Value);
    bool WriteBEUInt16       (UInt16 a_Value);
    bool WriteBEUInt32       (UInt32 a_Value);
    bool WriteBEUInt64       (UInt64 a_Value);
    bool WriteBEFloat        (float  a_Value);
    bool WriteBEDouble       (double a_Value);
    bool WriteBool           (bool   a_Value);
    bool WriteVarInt32       (UInt32 a_Value);
    bool WriteVarInt64       (UInt64 a_Value);
    bool WriteVarUTF8String  (const AString & a_Value);  // string length as VarInt, then string as UTF-8
    bool WriteLEInt32        (Int32 a_Value);
    bool WriteXYZPosition64  (Int32 a_BlockX, Int32 a_BlockY, Int32 a_BlockZ);
    bool WriteXZYPosition64  (Int32 a_BlockX, Int32 a_BlockY, Int32 a_BlockZ);
 
    bool ReadBuf(void * a_Buffer, size_t a_Count);
 
    bool WriteBuf(const void * a_Buffer, size_t a_Count);
 
    bool WriteBuf(size_t a_Count, unsigned char a_Value);
 
    bool ReadSome(ContiguousByteBuffer & a_String, size_t a_Count);
 
    bool SkipRead(size_t a_Count);
 
    void ReadAll(ContiguousByteBuffer & a_Data);
 
    bool ReadToByteBuffer(cByteBuffer & a_Dst, size_t a_NumBytes);
 
    void CommitRead(void);
 
    void ResetRead(void);
 
    void ReadAgain(ContiguousByteBuffer & a_Out);
 
    void CheckValid(void) const;
 
    static size_t GetVarIntSize(UInt32 a_Value);
 
protected:
 
    std::byte * m_Buffer;
    size_t m_BufferSize;  // Total size of the ringbuffer
 
    size_t m_DataStart;  // Where the data starts in the ringbuffer
    size_t m_WritePos;   // Where the data ends in the ringbuffer
    size_t m_ReadPos;    // Where the next read will start in the ringbuffer
 
    #ifndef NDEBUG
 
        mutable std::thread::id m_ThreadID;
    #endif
 
    void AdvanceReadPos(size_t a_Count);
} ;