raw data read/write methods implemented in PacketQueue

src/network/PacketQueue.cpp

@@ -7,10 +7,10 @@ namespace network
 
 //-------------------------------------------------------------
 PacketQueue::PacketQueue() :
-	first(0),
-	last(0),
-	start_index(0),
-	end_index(0)
+	m_first(0),
+	m_last(0),
+	m_start_index(0),
+	m_end_index(0)
 {
 
 }
@@ -23,8 +23,11 @@ PacketQueue::~PacketQueue()
 
 //-------------------------------------------------------------
 bool PacketQueue::add(const PacketData& pd)
-{
-	
+{	
+	// update last sequence number
+	m_last = pd.sequence; 
+	// update end index
+	m_end_index += sizeof(PacketData);
 }
 
 //-------------------------------------------------------------
@@ -58,182 +61,45 @@ int32_t PacketQueue::get_last() const
 }
 
 //-------------------------------------------------------------
-void PacketQueue::write_bits(int32_t value, int32_t num_bits)
+void PacketQueue::write_uint8(uint8_t value)
 {
-	int32_t		put;
-	int32_t		fraction;
-
-	// check if m_write is void
-	if (!m_write) 
-	{
-		printf( "cannot write to message" );
-	}
-	// check if the number of bits is valid
-	if (num_bits == 0 || num_bits < -31 || num_bits > 32) 
-	{
-		printf( "bad numBits %i", num_bits);
-	}
-
-	// check for value overflows
-	// this should be an error really, as it can go unnoticed and cause either bandwidth or corrupted data transmitted
-	if (num_bits != 32) 
-	{
-		if (num_bits > 0) 
-		{
-			if (value > (1 << num_bits) - 1) 
-			{
-				printf( "value overflow %d %d", value, num_bits );
-			} 
-			else if (value < 0) 
-			{
-				printf( "value overflow %d %d", value, num_bits );
-			}
-		} 
-		else 
-		{
-			int32_t r = 1 << (-1 - num_bits);
-			if (value > r - 1) 
-			{
-				printf( "value overflow %d %d", value, num_bits );
-			} 
-			else if (value < -r) 
-			{
-				printf( "value overflow %d %d", value, num_bits );
-			}
-		}
-	}
-
-	// Change sign if it's negative
-	if (num_bits < 0 ) 
-	{
-		num_bits = -num_bits;
-	}
-
-	// check for msg overflow
-	if (check_overflow(num_bits)) 
-	{
-		return;	
-	}
-
-	// write the bits
-	while(num_bits) 
-	{
-		if (m_write_bit == 0) 
-		{
-			m_write[m_cur_size] = 0;
-			m_cur_size++;
-		}
-		
-		put = 8 - m_write_bit;
-		if (put > num_bits) 
-		{
-			put = num_bits;
-		}
-		
-		fraction = value & ((1 << put) - 1);
-		m_write[m_cur_size - 1] |= fraction << m_write_bit;
-		num_bits -= put;
-		value >>= put;
-		m_write_bit = (m_write_bit + put) & 7;
-	}
+	m_buffer[m_end_index] = value;
+	m_end_index = (m_end_index + 1) & (MAX_QUEUE_SIZE - 1);
 }
 
 //-------------------------------------------------------------
 void PacketQueue::write_uint16(int32_t value)
 {
-	write_bits(c, 16);
+	write_uint8((value >> 0) & 255); 
+	write_uint8((value >> 8) & 255);
 }
 
 //-------------------------------------------------------------
 void PacketQueue::write_int32(int32_t value)
 {
-	write_bits(c, 32);
+	write_uint8((value >> 0) & 255); 
+	write_uint8((value >> 8) & 255);
+	write_uint8((value >> 16) & 255); 
+	write_uint8((value >> 24) & 255);	
 }
 
 //-------------------------------------------------------------
-int32_t PacketQueue::read_bits(int32_t num_bits)
+int8_t PacketQueue::read_uint8()
 {
-	int32_t		value;
-	int32_t		value_bits;
-	int32_t		get;
-	int32_t		fraction;
-	bool		sgn;
-
-	if (!m_read) 
-	{
-		printf("cannot read from message");
-	}
-
-	// check if the number of bits is valid
-	if ( num_bits == 0 || num_bits < -31 || num_bits > 32 ) 
-	{
-		printf("bad number of bits %i", num_bits );
-	}
-
-	value = 0;
-	value_bits = 0;
-
-	// change sign if it is negative
-	if (num_bits < 0) 
-	{
-		num_bits = -num_bits;
-		sgn = true;
-	}
-	else 
-	{
-		sgn = false;
-	}
-
-	// check for overflow
-	if (num_bits > get_remaining_read_bits()) 
-	{
-		return -1;
-	}
-
-	while (value_bits < num_bits) 
-	{
-		if (m_read_bit == 0) 
-		{
-			m_read_count++;
-		}
-		
-		get = 8 - m_read_bit;
-		
-		if (get > (num_bits - value_bits)) 
-		{
-			get = num_bits - value_bits;
-		}
-		
-		fraction = m_read[m_read_count - 1];
-		fraction >>= m_read_bit;
-		fraction &= (1 << get) - 1;
-		value |= fraction << value_bits;
-
-		value_bits += get;
-		m_read_bit = (m_read_bit + get) & 7;
-	}
-
-	if (sgn) 
-	{
-		if (value & (1 << (num_bits - 1))) 
-		{
-			value |= -1 ^ (( 1 << num_bits) - 1);
-		}
-	}
-
-	return value;  
+	uint8_t value = m_buffer[m_start_index];
+	m_start_index = (m_start_index + 1) & (MAX_QUEUE_SIZE - 1);
 }
 
 //-------------------------------------------------------------
 int32_t PacketQueue::read_uint16()
 {
-	return (int32_t)read_bits(16);  
+	return (read_uint8()) | (read_uint8() << 8);
 }
 
 //-------------------------------------------------------------
 int32_t PacketQueue::read_int32()
 {
-	return (int32_t)read_bits(32);  
+	return (read_uint8()) | (read_uint8() << 8) | (read_uint8() << 16) | (read_uint8() << 24);
 }
 
 }

src/network/PacketQueue.h

@@ -31,22 +31,22 @@ public:
 
 private:
 
-	void 					write_bits(int32_t value, int32_t num_bits);
+	void 					write_uint8(int32_t value);
 	void					write_uint16(int32_t value);
 	void 					write_int32(int32_t value);
 
-	int32_t					read_bits(int32_t num_bits);
-	int32_t					read_uint16(int16_t& value);
-	int32_t					read_int32(int32_t& value);
+	int32_t					read_uint8();
+	int32_t					read_uint16();
+	int32_t					read_int32();
 
 private:
 	static const uint32_t 	MAX_QUEUE_SIZE = 16384;	
 
-	uint8_t					buffer[MAX_QUEUE_SIZE];
-	uint32_t				first;							// sequence number of first message in queue
-	uint32_t				last;							// sequence number of last message in queue
-	uint32_t				start_index;					// index pointing to the first byte of the first message
-	uint32_t				end_index;						// index pointing to the first byte after the last message
+	uint8_t					m_buffer[MAX_QUEUE_SIZE];
+	uint32_t				m_first;							// sequence number of first message in queue
+	uint32_t				m_last;							// sequence number of last message in queue
+	uint32_t				m_start_index;					// index pointing to the first byte of the first message
+	uint32_t				m_end_index;						// index pointing to the first byte after the last message
 };
 
 } // namespace network