Delete network folder

engine/CMakeLists.txt

@@ -246,14 +246,6 @@ set (INPUT_HEADERS
 	input/Touch.h
 )
 
-set (NETWORK_SRC
-	network/BitMessage.cpp
-)
-
-set (NETWORK_HEADERS
-	network/BitMessage.h
-)
-
 set (RENDERERS_BACKEND_SRC
 )
 
@@ -778,6 +770,5 @@ install (TARGETS ${CROWN_EXECUTABLE_NAME} DESTINATION bin)
 #
 #install (FILES ${INPUT_HEADERS} DESTINATION include/${CMAKE_PROJECT_NAME}/input)
 #install (FILES ${RENDERERS_HEADERS} DESTINATION include/${CMAKE_PROJECT_NAME}/renderers)
-#install (FILES ${NETWORK_HEADERS} DESTINATION include/${CMAKE_PROJECT_NAME}/network)
 #install (FILES ${OS_HEADERS} DESTINATION include/${CMAKE_PROJECT_NAME}/os)
 #install (FILES ${LUA_HEADERS} DESTINATION include/${CMAKE_PROJECT_NAME}/lua)

engine/network/BitMessage.cpp

@@ -1,743 +0,0 @@
-/*
-Copyright (c) 2013 Daniele Bartolini, Michele Rossi
-Copyright (c) 2012 Daniele Bartolini, Simone Boscaratto
-
-Permission is hereby granted, free of charge, to any person
-obtaining a copy of this software and associated documentation
-files (the "Software"), to deal in the Software without
-restriction, including without limitation the rights to use,
-copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the
-Software is furnished to do so, subject to the following
-conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
-OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
-HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
-OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-#include "Assert.h"
-#include <cstring>
-
-#include "NetAddress.h"
-#include "BitMessage.h"
-
-namespace crown
-{
-namespace network
-{
-
-//---------------------------------------------------------------------------------------------
-BitMessage::BitMessage(Allocator& allocator) :
-	m_allocator(allocator),
-	m_header(NULL),
-	m_data(NULL),
-	m_write(NULL), 
-	m_read(NULL), 
-	m_max_size(0), 
-	m_cur_size(0), 
-	m_read_count(0),
-	m_write_bit(0), 
-	m_read_bit(0),
-	m_overflowed(false),
-	m_init(false)
-{
-}
-
-//---------------------------------------------------------------------------------------------
-BitMessage::~BitMessage()
-{
-	if (m_header)
-	{
-		m_allocator.deallocate((void*)m_header);
-	}
-	if (m_data)
-	{
-		  m_allocator.deallocate((void*)m_data);
-	}
-}
-
-//---------------------------------------------------------------------------------------------
-uint8_t* BitMessage::get_byte_space(int32_t len)
-{
-	uint8_t *ptr;
-
-	if (!m_write) 
-	{
-		printf("cannot write to message");
-	}
-
-	// round up to the next byte
-	write_byte_align();
-
-	// check for overflow
-	check_overflow(len << 3);
-
-	// allocate space
-	ptr = m_write + m_cur_size;
-	m_cur_size += len;
-	
-	return ptr;  
-}
-
-//---------------------------------------------------------------------------------------------
-bool BitMessage::check_overflow(uint32_t num_bits)
-{
-	if (num_bits > get_remaining_write_bits()) 
-	{
-		if (num_bits > (m_max_size << 3)) 
-		{
-			printf(" %i bits is > full message size", num_bits );
-		}
-		printf("overflow\n");
-		begin_writing();
-		m_overflowed = true;
-		return true;
-	}
-	return false;
-}
-
-//---------------------------------------------------------------------------------------------
-void BitMessage::init(int32_t len)
-{
-	m_header = (uint8_t*)m_allocator.allocate(12);
-	
-	m_data = (uint8_t*)m_allocator.allocate(len);
-	
-	m_write = m_data;
-	m_read = m_data;
-	m_max_size = len;
-	
-	m_init = true;
-}
-
-//---------------------------------------------------------------------------------------------
-void BitMessage::set_header(uint32_t id, uint16_t sequence, uint16_t ack, uint32_t ack_bits)
-{
-	uint8_t header[12];
-	header[0]	= (uint8_t)(id >> 24);
-	header[1]	= (uint8_t)(id >> 16);
-	header[2]	= (uint8_t)(id >> 8);
-	header[3]	= (uint8_t)id;
-	header[4]	= (uint8_t)(sequence >> 8);
-	header[5]	= (uint8_t)sequence;
-	header[6]	= (uint8_t)(ack >> 8);
-	header[7]	= (uint8_t)ack;
-	header[8]	= (uint8_t)(ack_bits >> 24);
-	header[9]	= (uint8_t)(ack_bits >> 16);
-	header[10]	= (uint8_t)(ack_bits >> 8);
-	header[11]	= (uint8_t)(ack_bits);
-	
-	memcpy(m_header, header, 12);
-}
-
-//---------------------------------------------------------------------------------------------
-uint8_t* BitMessage::get_header()
-{
-	return m_header;
-}
-
-//---------------------------------------------------------------------------------------------
-const uint8_t* BitMessage::get_header() const
-{
-	return m_header;
-}
-//---------------------------------------------------------------------------------------------
-uint8_t* BitMessage::get_data()
-{
-	return m_write;
-}
-
-//---------------------------------------------------------------------------------------------
-const uint8_t* BitMessage::get_data() const
-{
-	return m_read;
-}
-
-//---------------------------------------------------------------------------------------------
-size_t BitMessage::get_max_size() const
-{
-	return m_max_size;
-}
-
-//---------------------------------------------------------------------------------------------
-bool BitMessage::is_overflowed()
-{
-	return m_overflowed;
-}
-
-//---------------------------------------------------------------------------------------------
-bool BitMessage::is_init()
-{
-	return m_init;
-}
-
-//---------------------------------------------------------------------------------------------
-size_t BitMessage::get_header_size() const
-{
-	return 12;
-}
-
-//---------------------------------------------------------------------------------------------
-size_t BitMessage::get_size() const
-{
-	return m_cur_size;
-}
-
-//---------------------------------------------------------------------------------------------
-void BitMessage::set_size(size_t size)
-{
-	if (size > m_max_size)
-	{
-		m_cur_size = m_max_size;
-	}
-	else
-	{
-		m_cur_size = size;
-	}
-}
-
-//---------------------------------------------------------------------------------------------
-int32_t BitMessage::get_write_bit() const
-{
-	return m_write_bit;
-}
-
-//---------------------------------------------------------------------------------------------
-void BitMessage::set_write_bit(int32_t bit)
-{
-	m_write_bit = bit & 7;
-	if (m_write_bit) 
-	{
-		m_write[m_cur_size-1] &= (1 << m_write_bit) - 1;
-	}
-}
-
-//---------------------------------------------------------------------------------------------
-int32_t BitMessage::get_num_bits_written() const
-{
-	return ((m_cur_size << 3) - ((8 - m_write_bit) & 7));  
-}
-
-//---------------------------------------------------------------------------------------------
-int32_t BitMessage::get_remaining_write_bits() const
-{
-	return (m_max_size << 3) - get_num_bits_written(); 
-}
-
-//---------------------------------------------------------------------------------------------
-void BitMessage::save_write_state(int32_t& s,int32_t& b) const
-{
-	s = m_cur_size;
-	b = m_write_bit;
-}
-
-//---------------------------------------------------------------------------------------------
-void BitMessage::restore_write_state(int32_t s,int32_t b)
-{
-	m_cur_size = s;
-	m_write_bit = b & 7;
-	
-	if (m_write_bit) 
-	{
-		m_write[m_cur_size-1] &= (1 << m_write_bit) - 1;
-	}  
-}
-
-//---------------------------------------------------------------------------------------------
-int32_t BitMessage::get_read_count() const
-{
-	return m_read_count;
-}
-
-//---------------------------------------------------------------------------------------------
-void BitMessage::set_read_count(int32_t bytes)
-{
-	m_read_count = bytes;
-}
-
-//---------------------------------------------------------------------------------------------
-int32_t BitMessage::get_read_bit() const
-{
-	return m_read_bit;
-}
-
-//---------------------------------------------------------------------------------------------
-void BitMessage::set_read_bit(int32_t bit)
-{
-	m_read_bit = bit & 7;
-}
-
-//---------------------------------------------------------------------------------------------
-int32_t BitMessage::get_num_bits_read() const
-{
-	return ((m_read_count << 3) - ((8 - m_read_bit) & 7));  
-}
-
-//---------------------------------------------------------------------------------------------
-int32_t BitMessage::get_remaining_read_bits() const
-{
-	return (m_cur_size << 3) - get_num_bits_read();
-}
-
-//---------------------------------------------------------------------------------------------
-void BitMessage::save_read_state(int32_t& c, int32_t& b) const
-{
-	c = m_read_count;
-	b = m_read_bit;
-}
-
-//---------------------------------------------------------------------------------------------
-void BitMessage::restore_read_state(int32_t c, int32_t b)
-{
-	m_read_count = c;
-	m_read_bit = b & 7;
-}
-
-//---------------------------------------------------------------------------------------------
-void BitMessage::begin_writing()
-{
-	m_cur_size = 0;
-	m_write_bit = 0;
-	m_overflowed = false;
-}
-
-//---------------------------------------------------------------------------------------------
-int32_t BitMessage::get_remaining_space() const
-{
-	return m_max_size - m_cur_size;
-}
-
-//---------------------------------------------------------------------------------------------
-void BitMessage::write_byte_align()
-{
-	m_write_bit = 0;
-}
-
-//---------------------------------------------------------------------------------------------
-void BitMessage::write_bits(int32_t value, int32_t num_bits)
-{
-	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 floatly, 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;
-	}
-}
-
-//---------------------------------------------------------------------------------------------
-void BitMessage::write_int8(int32_t c)
-{
-	write_bits(c, -8);
-}
-
-//---------------------------------------------------------------------------------------------
-void BitMessage::write_uint8(int32_t c)
-{
-	write_bits(c, 8);  
-}
-
-//---------------------------------------------------------------------------------------------
-void BitMessage::write_int16(int32_t c)
-{
-	write_bits(c, -16);  
-}
-
-//---------------------------------------------------------------------------------------------
-void BitMessage::write_uint16(int32_t c)
-{
-	write_bits(c, 16);
-}
-
-//---------------------------------------------------------------------------------------------
-void BitMessage::write_int32(int32_t c)
-{
-	write_bits(c, 32);
-}
-
-//---------------------------------------------------------------------------------------------
-void BitMessage::write_float(float f)
-{
-	write_bits(*reinterpret_cast<int32_t *>(&f), 32);  
-}
-
-//---------------------------------------------------------------------------------------------
-void BitMessage::write_vec3(const Vector3& v)
-{
-	write_float(v.x);
-	write_float(v.y);
-	write_float(v.z);
-}
-
-//---------------------------------------------------------------------------------------------
-void BitMessage::write_string(const char* s, int32_t max_len, bool make_7_bit)
-{
-	if (!s) 
-	{
-		write_data("", 1);
-	}
-	else 
-	{
-		int32_t i;
-		int32_t len = std::strlen(s);
-		uint8_t* data_ptr;
-		const uint8_t* byte_ptr;
-		
-		// calculates length
-		len = std::strlen(s);
-		
-		if (max_len >= 0 && len >= max_len) 
-		{
-			len = max_len - 1;
-		}
-		
-		data_ptr = get_byte_space(len + 1);
-		byte_ptr = reinterpret_cast<const uint8_t*>(s);
-		if (make_7_bit) 
-		{
-			for (i = 0; i < len; i++) 
-			{
-				if ( byte_ptr[i] > 127 ) 
-				{
-					data_ptr[i] = '.';
-				} 
-				else 
-				{
-					data_ptr[i] = byte_ptr[i];
-				}
-			}
-		}
-		else 
-		{
-			for (i = 0; i < len; i++) 
-			{
-				data_ptr[i] = byte_ptr[i];
-			}
-		}
-		
-		data_ptr[i] = '\0';
-	}  
-}
-
-//---------------------------------------------------------------------------------------------
-void BitMessage::write_data(const void* data, int32_t length)
-{
-	memcpy(get_byte_space(length), data, length);
-}
-
-//---------------------------------------------------------------------------------------------
-void BitMessage::write_netaddr(const os::NetAddress addr)
-{
-	uint8_t* ptr;
-	
-	ptr = get_byte_space(4);
-	memcpy(ptr, addr.m_address, 4);
-	write_uint16(addr.port());
-}
-
-//---------------------------------------------------------------------------------------------
-void BitMessage::begin_reading() const
-{
-	m_read_count = 0;
-	m_read_bit = 0;
-}
-
-//---------------------------------------------------------------------------------------------
-int32_t BitMessage::get_remaing_data() const
-{
-	return m_cur_size - m_read_count;
-}
-
-//---------------------------------------------------------------------------------------------
-void BitMessage::read_byte_align() const
-{
-	m_read_bit = 0;
-}
-
-//---------------------------------------------------------------------------------------------
-int32_t BitMessage::read_bits(int32_t num_bits) const
-{
-	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;  
-}
-
-//---------------------------------------------------------------------------------------------
-int32_t BitMessage::read_int8() const
-{
-	return (int32_t)read_bits(-8);
-}
-
-//---------------------------------------------------------------------------------------------
-int32_t BitMessage::read_uint8() const
-{
-  	return (int32_t)read_bits(8);
-
-}
-
-//---------------------------------------------------------------------------------------------
-int32_t BitMessage::read_int16() const
-{
-	return (int32_t)read_bits(-16);  
-}
-
-//---------------------------------------------------------------------------------------------
-int32_t BitMessage::read_uint16() const
-{
-	return (int32_t)read_bits(16);  
-}
-
-//---------------------------------------------------------------------------------------------
-int32_t BitMessage::read_int32() const
-{
-	return (int32_t)read_bits(32);
-}
-
-//---------------------------------------------------------------------------------------------
-float BitMessage::read_float() const
-{
-	float value;
-	*reinterpret_cast<int*>(&value) = read_bits(32);
-	return value;  
-}
-
-//---------------------------------------------------------------------------------------------
-Vector3 BitMessage::read_vec3() const
-{
-	Vector3 v;
-	
-	v.x = read_float();
-	v.y = read_float();
-	v.z = read_float();
-	
-	return v;
-}
-
-//---------------------------------------------------------------------------------------------
-int32_t BitMessage::read_string(char* buffer, int32_t buffer_size) const
-{
-	int	l = 0;
-	int c;
-
-	read_byte_align();
-	
-	while(1) 
-	{
-		c = read_uint8();
-		if (c <= 0 || c >= 255) 
-		{
-			break;
-		}
-		// translate all fmt spec to avoid crash bugs in string routines
-		if ( c == '%' ) 
-		{
-			c = '.';
-		}
-
-		// we will read past any excessively long string, so
-		// the following data can be read, but the string will
-		// be truncated
-		if (l < buffer_size - 1) 
-		{
-			buffer[l] = c;
-			l++;
-		}
-	}
-	
-	buffer[l] = 0;
-	return l;  
-}
-
-//---------------------------------------------------------------------------------------------
-int32_t BitMessage::read_data(void* data, int32_t length) const
-{
-	int count;
-
-	read_byte_align();
-	
-	count = m_read_count;
-
-	if (m_read_count + length > m_cur_size) 
-	{
-		if (data) 
-		{
-			memcpy(data, m_read + m_read_count, get_remaing_data());
-		}
-		m_read_count = m_cur_size;
-	} 
-	else 
-	{
-		if (data) 
-		{
-			memcpy(data, m_read + m_read_count, length);
-		}
-		m_read_count += length;
-	}
-
-	return (m_read_count - count);  
-}
-
-//---------------------------------------------------------------------------------------------
-void BitMessage::read_netaddr(os::NetAddress* addr) const
-{
-	for (int i = 0; i < 4; i++) 
-	{
-		addr->m_address[i] = read_uint8();
-	}
-	
-	addr->m_port = read_uint16();  
-}
-
-//---------------------------------------------------------------------------------------------
-void BitMessage::print() const
-{
-	os::printf("MAX_SIZE: %d\n", m_max_size);
-	os::printf("CUR_SIZE: %d\n", m_cur_size);
-}
-  
-}	//namespace network
-}	//namespace crown

engine/network/BitMessage.h

@@ -1,137 +0,0 @@
-/*
-Copyright (c) 2013 Daniele Bartolini, Michele Rossi
-Copyright (c) 2012 Daniele Bartolini, Simone Boscaratto
-
-Permission is hereby granted, free of charge, to any person
-obtaining a copy of this software and associated documentation
-files (the "Software"), to deal in the Software without
-restriction, including without limitation the rights to use,
-copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the
-Software is furnished to do so, subject to the following
-conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
-OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
-HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
-OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-#pragma once
-
-#include "Types.h"
-#include "Allocator.h"
-#include "Vector3.h"
-#include "NetAddress.h"
-
-namespace crown
-{
-namespace network
-{
-
-/// Bit-packet reliable message.
-/// Usage: After every instantition, must be initialized with @a init(len)
-/// TODO: rework as POD is needed; this feature provides compatibility with queue
-class BitMessage
-{
-public:
-						BitMessage(Allocator& allocator);
-						~BitMessage();
-
-	void				init(int32_t len);									// init with data length in byte
-	void				set_header(uint32_t id, uint16_t sequence, uint16_t ack, uint32_t ack_bits);
-	uint8_t*			get_header();										// get message header for writing
-	const uint8_t*		get_header() const;									// get message header for reading
-	uint8_t*			get_data();											// get message data for writing
-	const uint8_t*		get_data() const;									// get message data for reading
-	size_t				get_max_size() const;								// get the maximum message size
-	bool 				is_overflowed();									// is message overflowed
-	bool				is_init();											// is message initialized
-	
-	size_t				get_header_size() const;							// return 12 bytes
-	size_t				get_size() const;									// size of the message in bytes
-	void				set_size(size_t size);								// set the message size
-	int32_t				get_write_bit() const;								// get current write bit
-	void				set_write_bit(int32_t bit);							// set current write bit
-	int32_t				get_num_bits_written() const;						// returns number of bits written
-	int32_t				get_remaining_write_bits() const;					// space left in bits for writing
-	void				save_write_state(int32_t& s,int32_t& b) const;		// save the write state
-	void				restore_write_state(int32_t s,int32_t b);			// restore the write state
-
-	int32_t				get_read_count() const;								// bytes read so far
-	void				set_read_count(int32_t bytes);						// set the number of bytes and bits read
-	int32_t				get_read_bit() const;								// get current read bit
-	void				set_read_bit(int32_t bit);							// set current read bit
-	int32_t				get_num_bits_read() const;							// returns number of bits read
-	int32_t				get_remaining_read_bits() const;					// number of bits left to read
-	void				save_read_state(int32_t& c, int32_t& b) const;		// save the read state
-	void				restore_read_state(int32_t c, int32_t b);			// restore the read state
-						// write state utilities
-	void				begin_writing();									// begin writing
-	int32_t				get_remaining_space() const;						// space left in bytes
-	void				write_byte_align();									// write up to the next byte boundary
-	void				write_bits(int32_t value, int32_t num_bits);		// write the specified number of bits
-	void				write_int8(int32_t c);
-	void				write_uint8(int32_t c);
-	void				write_int16(int32_t c);
-	void				write_uint16(int32_t c);
-	void				write_int32(int32_t c);
-	void				write_float(float f);
-	void				write_vec3(const Vector3& v);
-	void				write_string(const char* s, int32_t max_len = -1, bool make_7_bit = true);
-	void				write_data(const void* data, int32_t length);
-	void				write_netaddr(const os::NetAddress addr);
-
-						// read state utilities
-	void				begin_reading() const;								// begin reading.
-	int32_t				get_remaing_data() const;							// number of bytes left to read
-	void				read_byte_align() const;							// read up to the next byte boundary
-	int32_t				read_bits(int32_t num_bits) const;					// read the specified number of bits
-	int32_t				read_int8() const;
-	int32_t				read_uint8() const;
-	int32_t				read_int16() const;
-	int32_t				read_uint16() const;
-	int32_t				read_int32() const;
-	float				read_float() const;
-	Vector3				read_vec3() const;
-	int32_t				read_string(char* buffer, int32_t buffer_size) const;
-	int32_t				read_data(void* data, int32_t length) const;
-	void				read_netaddr(os::NetAddress* addr) const;
-	
-	void				print() const;
-
-private:
-  
-	uint8_t*			get_byte_space(int32_t len);
-	bool 				check_overflow(uint32_t num_bits);			// check buffer overflow	
-	
-private:
-	
-	Allocator&			m_allocator;								// memory allocator
-	
-	uint8_t*			m_header;
-	uint8_t*			m_data;
-	uint8_t*			m_write;									// pointer to data for writing
-	const uint8_t*		m_read;										// point32_ter to data for reading
-	
-	size_t				m_max_size;									// maximum size of message in bytes
-	size_t				m_cur_size;									// current size of message in bytes
-	mutable int32_t		m_read_count;								// number of bytes read so far
-	
-	int32_t				m_write_bit;								// number of bits written to the last written byte
-	mutable int32_t		m_read_bit;									// number of bits read from the last read byte
-	
-	bool 				m_overflowed;								// overflow flag
-	bool				m_init;										// is init flag	
-};
-
-} // namespace network
-} // namespace crown
-