summaryrefslogtreecommitdiffstats
path: root/source/ByteBuffer.h
blob: eb5ce5910d8bd2eb6df83a6fdc07e62dc81d7d94 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

// ByteStream.h

// Interfaces to the cByteBuffer class representing a ringbuffer of bytes





#pragma once





/** An object that can store incoming bytes and lets its clients read the bytes sequentially
The bytes are stored in a ringbuffer of constant size; if more than that size
is requested, the write operation fails.
The bytes stored can be retrieved using various ReadXXX functions; these assume that the needed
number of bytes are present in the buffer (ASSERT; for performance reasons).
The reading doesn't actually remove the bytes, it only moves the internal read ptr.
To remove the bytes, call CommitRead().
To re-start reading from the beginning, call ResetRead().
This class doesn't implement thread safety, the clients of this class need to provide
their own synchronization.
*/
class cByteBuffer
{
public:
	cByteBuffer(int a_BufferSize);
	~cByteBuffer();
	
	/// Writes the bytes specified to the ringbuffer. Returns true if successful, false if not
	bool Write(const char * a_Bytes, int a_Count);
	
	/// Returns the number of bytes that can be successfully written to the ringbuffer
	int  GetFreeSpace(void) const;
	
	/// Returns the number of bytes that are currently in the ringbuffer. Note GetReadableBytes()
	int  GetUsedSpace(void) const;
	
	/// Returns the number of bytes that are currently available for reading (may be less than UsedSpace due to some data having been read already)
	int  GetReadableSpace(void) const;
	
	/// Returns true if the specified amount of bytes are available for reading
	bool CanReadBytes(int a_Count) const;

	/// Returns true if the specified amount of bytes are available for writing
	bool CanWriteBytes(int a_Count) const;

	// Read the specified datatype and advance the read pointer; return true if successfully read:
	bool ReadChar           (char & a_Value);
	bool ReadByte           (unsigned char & a_Value);
	bool ReadBEShort        (short & a_Value);
	bool ReadBEInt          (int & a_Value);
	bool ReadBEInt64        (Int64 & a_Value);
	bool ReadBEFloat        (float & a_Value);
	bool ReadBEDouble       (double & a_Value);
	bool ReadBool           (bool & a_Value);
	bool ReadBEUTF16String16(AString & a_Value);  // string length as BE short, then string as UTF-16BE
	bool ReadVarInt         (UInt64 & a_Value);
	bool ReadVarUTF8String  (AString & a_Value);  // string length as VarInt, then string as UTF-8

	/// Reads VarInt, assigns it to anything that can be assigned from an UInt64 (unsigned int, short, char, Byte, double, ...)
	template <typename T> bool ReadVarUInt(T & a_Value)
	{
		UInt64 v;
		bool res = ReadVarInt(v);
		if (res)
		{
			a_Value = v;
		}
		return res;
	}

	// Write the specified datatype; return true if successfully written
	bool WriteChar           (char a_Value);
	bool WriteByte           (unsigned char a_Value);
	bool WriteBEShort        (short  a_Value);
	bool WriteBEInt          (int    a_Value);
	bool WriteBEInt64        (Int64  a_Value);
	bool WriteBEFloat        (float  a_Value);
	bool WriteBEDouble       (double a_Value);
	bool WriteBool           (bool   a_Value);
	bool WriteBEUTF16String16(const AString & a_Value);  // string length as BE short, then string as UTF-16BE
	bool WriteVarInt         (UInt64 a_Value);
	bool WriteVarUTF8String  (AString & a_Value);  // string length as VarInt, then string as UTF-8
	
	/// Reads a_Count bytes into a_Buffer; returns true if successful
	bool ReadBuf(void * a_Buffer, int a_Count);
	
	/// Writes a_Count bytes into a_Buffer; returns true if successful
	bool WriteBuf(const void * a_Buffer, int a_Count);
	
	/// Reads a_Count bytes into a_String; returns true if successful
	bool ReadString(AString & a_String, int a_Count);
	
	/// Reads 2 * a_NumChars bytes and interprets it as a UTF16-BE string, converting it into UTF8 string a_String
	bool ReadUTF16String(AString & a_String, int a_NumChars);
	
	/// Skips reading by a_Count bytes; returns false if not enough bytes in the ringbuffer
	bool SkipRead(int a_Count);
	
	/// Reads all available data into a_Data
	void ReadAll(AString & a_Data);
	
	/// Removes the bytes that have been read from the ringbuffer
	void CommitRead(void);
	
	/// Restarts next reading operation at the start of the ringbuffer
	void ResetRead(void);
	
	/// Re-reads the data that has been read since the last commit to the current readpos. Used by ProtoProxy to duplicate communication
	void ReadAgain(AString & a_Out);
	
	/// Checks if the internal state is valid (read and write positions in the correct bounds) using ASSERTs
	void CheckValid(void) const;

protected:
	char * m_Buffer;
	int    m_BufferSize;  // Total size of the ringbuffer
	
	#ifdef _DEBUG
	unsigned long m_ThreadID;  // Thread that is currently accessing the object, checked via cSingleThreadAccessChecker
	#endif  // _DEBUG
	
	int    m_DataStart;  // Where the data starts in the ringbuffer
	int    m_WritePos;   // Where the data ends in the ringbuffer
	int    m_ReadPos;    // Where the next read will start in the ringbuffer
	
	/// Advances the m_ReadPos by a_Count bytes
	void AdvanceReadPos(int a_Count);
} ;