adding client/server prototype

include/client.hpp

@@ -0,0 +1,29 @@
+#pragma once
+
+#include <boost/asio.hpp>
+#include "boost/bind.hpp"
+#include <functional>
+#include <sstream>
+#include <string>
+#include <vector>
+
+class client
+{
+public:
+  client(boost::asio::io_service& io_service,
+         const boost::asio::ip::address& multicast_address,
+         short multicast_port,
+         unsigned short tcp_port);
+
+  void init();
+  void set_outbound_interface(const boost::asio::ip::address_v4& address);
+  void handle_send_to(const boost::system::error_code& error);
+  void handle_timeout(const boost::system::error_code& error);
+
+private:
+  boost::asio::ip::udp::endpoint endpoint_;
+  boost::asio::ip::udp::socket socket_;
+  boost::asio::deadline_timer timer_;
+  std::string message_;
+  unsigned short port_;
+};

include/protocol.hpp

@@ -91,12 +91,12 @@ struct composed_message : public generic_message<Type::COMPOSED_MESSAGE>
 
 struct vec2 
 {
-  float x,y;
+  int x,y;
 };
 
 struct vec3 
 {
-  float x,y,z;
+  int x,y,z;
 };
 
 struct draw_rectangle : public generic_message<Type::DRAW_RECTANGLE>
@@ -126,42 +126,42 @@ struct draw_pixel : public generic_message<Type::DRAW_PIXEL>
   vec3 color;
 };
 
-uint32_t get_size(Type type)
-{
-  static std::map<Type, uint32_t> type_map{};
-
-  //initalizes map on first run
-  static bool run_once = [&](){
-    type_map.emplace(Type::DRAW_PIXEL, sizeof(draw_pixel));
-    type_map.emplace(Type::DRAW_RECTANGLE, sizeof(draw_rectangle));
-    type_map.emplace(Type::COMPOSED_MESSAGE, sizeof(composed_message));
-    return true;
-  }();
-
-  return type_map[type];
-}
+//uint32_t get_size(Type type)
+//{
+//  static std::map<Type, uint32_t> type_map{};
+//
+//  //initalizes map on first run
+//  static bool run_once = [&](){
+//    type_map.emplace(Type::DRAW_PIXEL, sizeof(draw_pixel));
+//    type_map.emplace(Type::DRAW_RECTANGLE, sizeof(draw_rectangle));
+//    type_map.emplace(Type::COMPOSED_MESSAGE, sizeof(composed_message));
+//    return true;
+//  }();
+//
+//  return type_map[type];
+//}
 
 
-generic_message_base* get_object(Type type, generic_message_base* msg)
-{
-	switch(type)
-	{
-		case Type::COMPOSED_MESSAGE:
-			{
-				return reinterpret_cast<composed_message*>(msg);
-			}
-		case Type::DRAW_RECTANGLE:
-			{
-				return reinterpret_cast<draw_rectangle*>(msg);
-			}
-		case Type::DRAW_PIXEL:
-			{
-				return reinterpret_cast<draw_pixel*>(msg);
-			}
-		default:
-			return nullptr;
-	}
-}
+//generic_message_base* get_object(Type type, generic_message_base* msg)
+//{
+//	switch(type)
+//	{
+//		case Type::COMPOSED_MESSAGE:
+//			{
+//				return reinterpret_cast<composed_message*>(msg);
+//			}
+//		case Type::DRAW_RECTANGLE:
+//			{
+//				return reinterpret_cast<draw_rectangle*>(msg);
+//			}
+//		case Type::DRAW_PIXEL:
+//			{
+//				return reinterpret_cast<draw_pixel*>(msg);
+//			}
+//		default:
+//			return nullptr;
+//	}
+//}
 
 //template<Type T>
 //auto* get_object(generic_message_base* msg)

include/server.hpp

@@ -0,0 +1,65 @@
+#pragma once
+
+#include <cstdlib>
+#include <iostream>
+#include <boost/asio.hpp>
+
+#include "protocol.hpp"
+
+using boost::asio::ip::udp;
+
+class server
+{
+public:
+  server(boost::asio::io_context& io_context, short port)
+    : socket_(io_context, udp::endpoint(udp::v4(), port))
+  {
+    do_receive();
+  }
+
+  void do_receive()
+  {
+    std::cout << "do_receive\n";
+    socket_.async_receive_from(
+        boost::asio::buffer(data_, max_length), sender_endpoint_,
+        [this](boost::system::error_code ec, std::size_t bytes_recvd)
+        {
+          if (!ec && bytes_recvd > 0)
+          {
+            std::cout << data_ << std::endl;
+
+            auto* msg_obj = reinterpret_cast<commons::protocol::generic_message_base*>(data_);
+
+            std::cout << "Received Type: " << static_cast<int>(msg_obj->get_type()) << "\n";
+            std::cout << "Received Size: " << msg_obj->get_size() << "\n";
+
+            auto* casted_obj = reinterpret_cast<commons::protocol::draw_rectangle*>(msg_obj);
+
+            std::cout << "Positon: X = " << casted_obj->position.x
+                              << " Y = " << casted_obj->position.y << std::endl;
+
+            do_send(bytes_recvd);
+          }
+          else
+          {
+            do_receive();
+          }
+        });
+  }
+
+  void do_send(std::size_t length)
+  {
+    socket_.async_send_to(
+        boost::asio::buffer(data_, length), sender_endpoint_,
+        [this](boost::system::error_code /*ec*/, std::size_t /*bytes_sent*/)
+        {
+          do_receive();
+        });
+  }
+
+private:
+  udp::socket socket_;
+  udp::endpoint sender_endpoint_;
+  enum { max_length = 1024 };
+  char data_[max_length];
+};