Rename IPv4Address to NetAddress

src/CMakeLists.txt

@@ -68,7 +68,6 @@ set (CORE_HEADERS
 	core/Delegate.h
 	core/Exceptions.h
 	core/SignalSlot.h
-	core/Singleton.h
 	core/Types.h
 	core/VertexData.h
 	core/WithProperties.h
@@ -235,11 +234,11 @@ set (WIN_SRC
 )
 
 set (NETWORK_SRC
-	network/Message.h
+	network/BitMessage.h
 )
 
 set (NETWORK_HEADERS
-	network/Message.cpp
+	network/BitMessage.cpp
 )
 
 set (SOURCES

src/core/containers/Queue.h

@@ -190,7 +190,7 @@ inline void Queue<T>::push_front(const T& item)
 
 	m_read = (m_read - 1 + m_queue.size()) % m_queue.size();
 
-	(this*)[0] = item;
+	(*this)[0] = item;
 
 	m_size++;
 }

src/network/BitMessage.cpp

@@ -1,28 +1,28 @@
 #include <cassert>
 #include <cstring>
 
-#include "Message.h"
+#include "BitMessage.h"
 
 namespace crown
 {
 namespace network
 {
   
-Message::Message() : w_data(NULL), r_data(NULL), max_size(0), cur_size(0), write_bit(0), read_count(0), read_bit(0)
+BitMessage::BitMessage() : w_data(NULL), r_data(NULL), max_size(0), cur_size(0), write_bit(0), read_count(0), read_bit(0)
 {
   
 }
 
 //---------------------------------------------------------------------------------------------
 
-Message::~Message()
+BitMessage::~BitMessage()
 {
   
 }
 
 //---------------------------------------------------------------------------------------------
 
-uint8_t* Message::get_byte_space(int32_t len)
+uint8_t* BitMessage::get_byte_space(int32_t len)
 {
 	uint8_t *ptr;
 
@@ -46,7 +46,7 @@ uint8_t* Message::get_byte_space(int32_t len)
 
 //---------------------------------------------------------------------------------------------
 
-bool Message::check_overflow(int32_t num_bits)
+bool BitMessage::check_overflow(int32_t num_bits)
 {
 	assert( num_bits >= 0 );
 	
@@ -66,7 +66,7 @@ bool Message::check_overflow(int32_t num_bits)
 
 //---------------------------------------------------------------------------------------------
 
-void Message::init(uint8_t *data, int32_t len)
+void BitMessage::init(uint8_t *data, int32_t len)
 {
 	w_data = data;
 	r_data = data;
@@ -75,7 +75,7 @@ void Message::init(uint8_t *data, int32_t len)
 
 //---------------------------------------------------------------------------------------------
 
-void Message::init(const uint8_t *data, int32_t len)
+void BitMessage::init(const uint8_t *data, int32_t len)
 {
 	w_data = NULL;
 	r_data = data;
@@ -84,42 +84,42 @@ void Message::init(const uint8_t *data, int32_t len)
 
 //---------------------------------------------------------------------------------------------
 
-uint8_t* Message::get_data()
+uint8_t* BitMessage::get_data()
 {
 	return w_data;
 }
 
 //---------------------------------------------------------------------------------------------
 
-const uint8_t* Message::get_data() const
+const uint8_t* BitMessage::get_data() const
 {
 	return r_data;
 }
 
 //---------------------------------------------------------------------------------------------
 
-int32_t Message::get_max_size() const
+int32_t BitMessage::get_max_size() const
 {
 	return max_size;
 }
 
 //---------------------------------------------------------------------------------------------
 
-bool Message::is_overflowed()
+bool BitMessage::is_overflowed()
 {
 	return overflowed;
 }
 
 //---------------------------------------------------------------------------------------------
 
-int32_t Message::get_size() const
+int32_t BitMessage::get_size() const
 {
 	return cur_size;
 }
 
 //---------------------------------------------------------------------------------------------
 
-void Message::set_size(int32_t size)
+void BitMessage::set_size(int32_t size)
 {
 	if (size > max_size)
 	{
@@ -133,14 +133,14 @@ void Message::set_size(int32_t size)
 
 //---------------------------------------------------------------------------------------------
 
-int32_t Message::get_write_bit() const
+int32_t BitMessage::get_write_bit() const
 {
 	return write_bit;
 }
 
 //---------------------------------------------------------------------------------------------
 
-void Message::set_write_bit(int32_t bit)
+void BitMessage::set_write_bit(int32_t bit)
 {
 	write_bit = bit & 7;
 	if (write_bit) 
@@ -151,21 +151,21 @@ void Message::set_write_bit(int32_t bit)
 
 //---------------------------------------------------------------------------------------------
 
-int32_t Message::get_num_bits_written() const
+int32_t BitMessage::get_num_bits_written() const
 {
 	return ((cur_size << 3) - ((8 - write_bit) & 7));  
 }
 
 //---------------------------------------------------------------------------------------------
 
-int32_t Message::get_remaining_write_bits() const
+int32_t BitMessage::get_remaining_write_bits() const
 {
 	return (max_size << 3) - get_num_bits_written(); 
 }
 
 //---------------------------------------------------------------------------------------------
 
-void Message::save_write_state(int32_t& s,int32_t& b) const
+void BitMessage::save_write_state(int32_t& s,int32_t& b) const
 {
 	s = cur_size;
 	b = write_bit;
@@ -173,7 +173,7 @@ void Message::save_write_state(int32_t& s,int32_t& b) const
 
 //---------------------------------------------------------------------------------------------
 
-void Message::restore_write_state(int32_t s,int32_t b)
+void BitMessage::restore_write_state(int32_t s,int32_t b)
 {
 	cur_size = s;
 	write_bit = b & 7;
@@ -186,49 +186,49 @@ void Message::restore_write_state(int32_t s,int32_t b)
 
 //---------------------------------------------------------------------------------------------
 
-int32_t Message::get_read_count() const
+int32_t BitMessage::get_read_count() const
 {
 	return read_count;
 }
 
 //---------------------------------------------------------------------------------------------
 
-void Message::set_read_count(int32_t bytes)
+void BitMessage::set_read_count(int32_t bytes)
 {
 	read_count = bytes;
 }
 
 //---------------------------------------------------------------------------------------------
 
-int32_t Message::get_read_bit() const
+int32_t BitMessage::get_read_bit() const
 {
 	return read_bit;
 }
 
 //---------------------------------------------------------------------------------------------
 
-void Message::set_read_bit(int32_t bit)
+void BitMessage::set_read_bit(int32_t bit)
 {
 	read_bit = bit & 7;
 }
 
 //---------------------------------------------------------------------------------------------
 
-int32_t Message::get_num_bits_read() const
+int32_t BitMessage::get_num_bits_read() const
 {
 	return ((read_count << 3) - ((8 - read_bit) & 7));  
 }
 
 //---------------------------------------------------------------------------------------------
 
-int32_t Message::get_remaining_read_bits() const
+int32_t BitMessage::get_remaining_read_bits() const
 {
 	return (cur_size << 3) - get_num_bits_read();
 }
 
 //---------------------------------------------------------------------------------------------
 
-void Message::save_read_state(int32_t& c, int32_t& b) const
+void BitMessage::save_read_state(int32_t& c, int32_t& b) const
 {
 	c = read_count;
 	b = read_bit;
@@ -236,7 +236,7 @@ void Message::save_read_state(int32_t& c, int32_t& b) const
 
 //---------------------------------------------------------------------------------------------
 
-void Message::restore_read_state(int32_t c, int32_t b)
+void BitMessage::restore_read_state(int32_t c, int32_t b)
 {
 	read_count = c;
 	read_bit = b & 7;
@@ -244,7 +244,7 @@ void Message::restore_read_state(int32_t c, int32_t b)
 
 //---------------------------------------------------------------------------------------------
 
-void Message::begin_writing()
+void BitMessage::begin_writing()
 {
 	cur_size = 0;
 	write_bit = 0;
@@ -253,21 +253,21 @@ void Message::begin_writing()
 
 //---------------------------------------------------------------------------------------------
 
-int32_t Message::get_remaining_space() const
+int32_t BitMessage::get_remaining_space() const
 {
 	return max_size - cur_size;
 }
 
 //---------------------------------------------------------------------------------------------
 
-void Message::write_byte_align()
+void BitMessage::write_byte_align()
 {
 	write_bit = 0;
 }
 
 //---------------------------------------------------------------------------------------------
 
-void Message::write_bits(int32_t value, int32_t num_bits)
+void BitMessage::write_bits(int32_t value, int32_t num_bits)
 {
 	int32_t		put;
 	int32_t		fraction;
@@ -349,56 +349,56 @@ void Message::write_bits(int32_t value, int32_t num_bits)
 
 //---------------------------------------------------------------------------------------------
 
-void Message::write_int8(int32_t c)
+void BitMessage::write_int8(int32_t c)
 {
 	write_bits(c, -8);
 }
 
 //---------------------------------------------------------------------------------------------
 
-void Message::write_uint8(int32_t c)
+void BitMessage::write_uint8(int32_t c)
 {
 	write_bits(c, 8);  
 }
 
 //---------------------------------------------------------------------------------------------
 
-void Message::write_int16(int32_t c)
+void BitMessage::write_int16(int32_t c)
 {
 	write_bits(c, -16);  
 }
 
 //---------------------------------------------------------------------------------------------
 
-void Message::write_uint16(int32_t c)
+void BitMessage::write_uint16(int32_t c)
 {
 	write_bits(c, 16);
 }
 
 //---------------------------------------------------------------------------------------------
 
-void Message::write_int32(int32_t c)
+void BitMessage::write_int32(int32_t c)
 {
 	write_bits(c, 32);
 }
 
 //---------------------------------------------------------------------------------------------
 
-void Message::write_real(real f)
+void BitMessage::write_real(real f)
 {
 	write_bits(*reinterpret_cast<int32_t *>(&f), 32);  
 }
 
 //---------------------------------------------------------------------------------------------
 
-void Message::write_vec3(const Vec3& v, int32_t num_bits)
+void BitMessage::write_vec3(const Vec3& v, int32_t num_bits)
 {
 	write_bits(vec3_to_bits(v, num_bits), num_bits);
 }
 
 //---------------------------------------------------------------------------------------------
 
-void Message::write_string(const char* s, int32_t max_len, bool make_7_bit)
+void BitMessage::write_string(const char* s, int32_t max_len, bool make_7_bit)
 {
 	if (!s) 
 	{
@@ -449,14 +449,14 @@ void Message::write_string(const char* s, int32_t max_len, bool make_7_bit)
 
 //---------------------------------------------------------------------------------------------
 
-void Message::write_data(const void* data, int32_t length)
+void BitMessage::write_data(const void* data, int32_t length)
 {
 	memcpy(get_byte_space(length), data, length);
 }
 
 //---------------------------------------------------------------------------------------------
 
-void Message::write_ipv4addr(const os::IPv4Address addr)
+void BitMessage::write_ipv4addr(const os::NetAddress addr)
 {
 	uint8_t* ptr;
 	
@@ -467,7 +467,7 @@ void Message::write_ipv4addr(const os::IPv4Address addr)
 
 //---------------------------------------------------------------------------------------------
 
-void Message::begin_reading() const
+void BitMessage::begin_reading() const
 {
 	read_count = 0;
 	read_bit = 0;
@@ -475,21 +475,21 @@ void Message::begin_reading() const
 
 //---------------------------------------------------------------------------------------------
 
-int32_t Message::get_remaing_data() const
+int32_t BitMessage::get_remaing_data() const
 {
 	cur_size - read_count;
 }
 
 //---------------------------------------------------------------------------------------------
 
-void Message::read_byte_align() const
+void BitMessage::read_byte_align() const
 {
 	read_bit = 0;
 }
 
 //---------------------------------------------------------------------------------------------
 
-int32_t Message::read_bits(int32_t num_bits) const
+int32_t BitMessage::read_bits(int32_t num_bits) const
 {
 	int32_t		value;
 	int32_t		value_bits;
@@ -564,14 +564,14 @@ int32_t Message::read_bits(int32_t num_bits) const
 
 //---------------------------------------------------------------------------------------------
 
-int32_t Message::read_int8() const
+int32_t BitMessage::read_int8() const
 {
 	return (int32_t)read_bits(-8);
 }
 
 //---------------------------------------------------------------------------------------------
 
-int32_t Message::read_uint8() const
+int32_t BitMessage::read_uint8() const
 {
   	return (int32_t)read_bits(8);
 
@@ -579,28 +579,28 @@ int32_t Message::read_uint8() const
 
 //---------------------------------------------------------------------------------------------
 
-int32_t Message::read_int16() const
+int32_t BitMessage::read_int16() const
 {
 	return (int32_t)read_bits(-16);  
 }
 
 //---------------------------------------------------------------------------------------------
 
-int32_t Message::read_uint16() const
+int32_t BitMessage::read_uint16() const
 {
 	return (int32_t)read_bits(16);  
 }
 
 //---------------------------------------------------------------------------------------------
 
-int32_t Message::read_int32() const
+int32_t BitMessage::read_int32() const
 {
 	return (int32_t)read_bits(32);
 }
 
 //---------------------------------------------------------------------------------------------
 
-real Message::read_real() const
+real BitMessage::read_real() const
 {
 	float value;
 	*reinterpret_cast<int*>(&value) = read_bits(32);
@@ -609,14 +609,14 @@ real Message::read_real() const
 
 //---------------------------------------------------------------------------------------------
 
-Vec3 Message::read_vec3(int32_t num_bits) const
+Vec3 BitMessage::read_vec3(int32_t num_bits) const
 {
 	return bits_to_vec3(read_bits(num_bits), num_bits);
 }
 
 //---------------------------------------------------------------------------------------------
 
-int32_t Message::read_string(char* buffer, int32_t buffer_size) const
+int32_t BitMessage::read_string(char* buffer, int32_t buffer_size) const
 {
 	int	l = 0;
 	int c;
@@ -652,7 +652,7 @@ int32_t Message::read_string(char* buffer, int32_t buffer_size) const
 
 //---------------------------------------------------------------------------------------------
 
-int32_t Message::read_data(void* data, int32_t length) const
+int32_t BitMessage::read_data(void* data, int32_t length) const
 {
 	int count;
 
@@ -682,7 +682,7 @@ int32_t Message::read_data(void* data, int32_t length) const
 
 //---------------------------------------------------------------------------------------------
 
-void Message::read_ipv4addr(os::IPv4Address* addr) const
+void BitMessage::read_ipv4addr(os::NetAddress* addr) const
 {
 
 	for (int i = 0; i < 4; i++) 
@@ -695,7 +695,7 @@ void Message::read_ipv4addr(os::IPv4Address* addr) const
 
 //---------------------------------------------------------------------------------------------
 
-int32_t Message::vec3_to_bits(const Vec3& v, int32_t num_bits)
+int32_t BitMessage::vec3_to_bits(const Vec3& v, int32_t num_bits)
 {
 	assert(num_bits >= 6 && num_bits <= 32);
 	assert(v.squared_length() - 1.0f < 0.01f);
@@ -720,7 +720,7 @@ int32_t Message::vec3_to_bits(const Vec3& v, int32_t num_bits)
 
 //---------------------------------------------------------------------------------------------
 
-Vec3 Message::bits_to_vec3(int32_t bits, int32_t num_bits)
+Vec3 BitMessage::bits_to_vec3(int32_t bits, int32_t num_bits)
 {
 	assert(num_bits >= 6 && num_bits <= 32);
   

src/network/BitMessage.h

@@ -12,11 +12,11 @@ namespace network
 	* bit-packet reliable message
 	*/
 	
-	class Message
+	class BitMessage
 	{
 	public:
-						Message();
-						~Message();
+						BitMessage();
+						~BitMessage();
 
 		void			init(uint8_t *data, int32_t len);
 		void			init(const uint8_t *data, int32_t len);
@@ -57,7 +57,7 @@ namespace network
 		void			write_vec3(const Vec3& v, int32_t num_bits);
 		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_ipv4addr(const os::IPv4Address addr);
+		void			write_ipv4addr(const os::NetAddress addr);
 
 		void			begin_reading() const;					// begin reading.
 		int32_t			get_remaing_data() const;				// number of bytes left to read
@@ -72,7 +72,7 @@ namespace network
 		Vec3			read_vec3(int32_t num_bits) const;
 		int32_t			read_string(char* buffer, int32_t buffer_size) const;
 		int32_t			read_data(void* data, int32_t length) const;
-		void			read_ipv4addr(os::IPv4Address* addr) const;
+		void			read_ipv4addr(os::NetAddress* addr) const;
 
  		static int32_t	vec3_to_bits(const Vec3& v, int32_t num_bits);
  		static Vec3		bits_to_vec3(int32_t bits, int32_t num_bits);

src/os/OS.cpp

@@ -6,21 +6,21 @@ namespace crown
 namespace os
 {
 
-static OSEvent		event_queue[MAX_OS_EVENTS];
+static OSEvent			event_queue[MAX_EVENTS];
 static int32_t			event_queue_head = 0;
 static int32_t			event_queue_tail = 0;
 
 //-----------------------------------------------------------------------------
 void push_event(OSEventType type, int32_t data_a, int32_t data_b, int32_t data_c, int32_t data_d)
 {
-	if ((event_queue_tail + 1) % MAX_OS_EVENTS == event_queue_head)
+	if ((event_queue_tail + 1) % MAX_EVENTS == event_queue_head)
 	{
 		os::printf("OS event queue full!\n");
 		return;
 	}
 
 	OSEvent* event = &event_queue[event_queue_tail];
-	event_queue_tail = (event_queue_tail + 1) % MAX_OS_EVENTS;
+	event_queue_tail = (event_queue_tail + 1) % MAX_EVENTS;
 
 	event->type = type;
 	event->data_a = data_a;
@@ -41,7 +41,7 @@ OSEvent& pop_event()
 	}
 
 	event = event_queue[event_queue_head];
-	event_queue_head = (event_queue_head + 1) % MAX_OS_EVENTS;
+	event_queue_head = (event_queue_head + 1) % MAX_EVENTS;
 
 	return event;
 }

src/os/OS.h

@@ -41,17 +41,17 @@ namespace os
 
 //-----------------------------------------------------------------------------
 #ifdef LINUX
-const size_t	MAX_OS_PATH_LENGTH = 1024;
+const size_t	MAX_PATH_LENGTH = 1024;
 const char		PATH_SEPARATOR = '/';
-const size_t	MAX_OS_EVENTS = 512;
 
+const size_t	MAX_EVENTS = 512;
 #endif
 
 #ifdef WINDOWS
-const size_t	MAX_OS_PATH_LENGTH = 1024;
+const size_t	MAX_PATH_LENGTH = 1024;
 const char		PATH_SEPARATOR = '\\';
 
-const size_t	MAX_OS_EVENTS = 512;
+const size_t	MAX_EVENTS = 512;
 #endif
 
 //-----------------------------------------------------------------------------
@@ -119,10 +119,10 @@ struct OSEvent
 	int32_t			data_d;
 };
 
-//! Pushes @a event int32_to @a event_queue
+//! Pushes @a event into @a event_queue
 void				push_event(OSEventType type, int32_t data_a, int32_t data_b, int32_t data_c, int32_t data_d);
 
-//! Returns the event on top of the @a event_queue	
+//! Returns the event on top of the event_queue	
 OSEvent&			pop_event();
 
 
@@ -131,7 +131,7 @@ OSEvent&			pop_event();
 //		Networking
 //-----------------------------------------------------------------------------
 
-struct IPv4Address
+struct NetAddress
 {
 	uint8_t 	address[4];
 	uint16_t 	port;
@@ -182,9 +182,9 @@ public:
 				// Open connection
 	bool 		open(uint16_t port);
 				 // Send data through socket
-	bool 		send(IPv4Address &receiver, const void* data, int32_t size );
+	bool 		send(NetAddress &receiver, const void* data, int32_t size );
 				// Receive data through socket
-	int32_t 	receive(IPv4Address &sender, void* data, int32_t size);
+	int32_t 	receive(NetAddress &sender, void* data, int32_t size);
 				// Close connection
 	void 		close();
 				// Is connection open?
@@ -207,7 +207,7 @@ public:
 				// Open connection (server side)
 	bool 		open(uint16_t port);
 				// Connect (client side)
-	bool		connect(IPv4Address& destination);
+	bool		connect(NetAddress& destination);
 				// Close connection
 	int32_t		close();
 				// Send data through socket

src/os/linux/LinuxOS.cpp

@@ -139,8 +139,8 @@ bool rmdir(const char* path)
 //-----------------------------------------------------------------------------
 const char* get_cwd()
 {
-	static char cwdBuf[MAX_OS_PATH_LENGTH];
-	if (getcwd(cwdBuf, MAX_OS_PATH_LENGTH) == NULL)
+	static char cwdBuf[MAX_PATH_LENGTH];
+	if (getcwd(cwdBuf, MAX_PATH_LENGTH) == NULL)
 	{
 		return Str::EMPTY;
 	}

src/os/linux/LinuxTCPSocket.cpp

@@ -67,7 +67,7 @@ bool TCPSocket::open(uint16_t port)
 	return true;  
 }
 
-bool TCPSocket::connect(IPv4Address& destination)
+bool TCPSocket::connect(NetAddress& destination)
 {
 	int32_t sd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
 

src/os/linux/LinuxUDPSocket.cpp

@@ -58,7 +58,7 @@ bool UDPSocket::open(uint16_t port)
 		return true;
 }
 
-bool UDPSocket::send(IPv4Address &receiver, const void* data, int32_t size)
+bool UDPSocket::send(NetAddress &receiver, const void* data, int32_t size)
 {
 	assert(data);
 	assert(size > 0);
@@ -81,7 +81,7 @@ bool UDPSocket::send(IPv4Address &receiver, const void* data, int32_t size)
 	return sent_bytes == size;
 }
 
-int32_t UDPSocket::receive(IPv4Address &sender, void* data, int32_t size)
+int32_t UDPSocket::receive(NetAddress &sender, void* data, int32_t size)
 {
 	assert(data);
 	assert(size > 0);