better tcp server code

diff --git a/core/net/tcp.onyx b/core/net/tcp.onyx
index d2f4a8e04b31239abbbd7ccd4807024200a44ba9..2db30b6d2fef79914e60e2f82536ede19f2a5996 100644 (file)
--- a/core/net/tcp.onyx
+++ b/core/net/tcp.onyx
@@ -23,44 +23,6 @@ TCP_Connection :: struct {
     event_cursor := 0;
 }
 
-TCP_Server :: struct {
-    use connection: TCP_Connection;
-
-    Client :: struct {
-        use socket  : Socket;
-        address : Socket_Address;
-        state   : State;
-
-        State :: enum {
-            Alive;
-            Dying;
-            Dead;
-        }
-    }
-    client_allocator: Allocator;
-    clients: [] ^Client;
-
-    // max clients is stored as clients.count.
-    client_count: u32;
-
-    listener_thread: thread.Thread;
-
-    alive         := true;
-    pulse_time_ms := 500;
-    
-    get_events :: tcp_get_events
-    listen     :: tcp_server_listen
-    pulse      :: tcp_server_pulse
-    send       :: tcp_server_send
-    broadcast  :: tcp_server_broadcast
-}
-
-TCP_Client :: struct {
-    use connection: TCP_Connection;
-
-    get_events :: tcp_get_events
-}
-
 TCP_Event :: struct {
     kind: Kind;
     data: rawptr;
@@ -69,7 +31,7 @@ TCP_Event :: struct {
         Undefined;
         Connection;
         Disconnection;
-        Message;
+        Data;
     }
 
     Connection :: struct {
@@ -86,7 +48,7 @@ TCP_Event :: struct {
         client  : ^TCP_Server.Client;
     }
 
-    Message :: struct {
+    Data :: struct {
         address: ^Socket_Address;
         // This is only set when the event is coming from the server.
         client  : ^TCP_Server.Client;
@@ -106,8 +68,8 @@ tcp_get_events :: (use conn: ^TCP_Connection) -> Iterator(TCP_Event) {
     close :: (use conn: ^TCP_Connection) {
         for events {
             switch it.kind {
-                case .Message {
-                    raw_free(event_allocator, (cast(^TCP_Event.Message) it.data).contents.data);
+                case .Data {
+                    raw_free(event_allocator, (cast(^TCP_Event.Data) it.data).contents.data);
                 }
             }
 
@@ -126,6 +88,44 @@ tcp_get_events :: (use conn: ^TCP_Connection) -> Iterator(TCP_Event) {
     };
 }
 
+
+//
+// TCP Server
+//
+
+TCP_Server :: struct {
+    use connection: TCP_Connection;
+
+    Client :: struct {
+        use socket  : Socket;
+        address : Socket_Address;
+        state   : State;
+
+        State :: enum {
+            Alive;
+            Dying;
+            Dead;
+        }
+    }
+    client_allocator: Allocator;
+    clients: [] ^Client;
+
+    // max clients is stored as clients.count.
+    client_count: u32;
+
+    listener_thread: thread.Thread;
+
+    alive         := true;
+    pulse_time_ms := 500;
+    
+    get_events    :: tcp_get_events
+    listen        :: tcp_server_listen
+    pulse         :: tcp_server_pulse
+    send          :: tcp_server_send
+    broadcast     :: tcp_server_broadcast
+    handle_events :: tcp_server_handle_events
+}
+
 tcp_server_make :: (max_clients := 32, allocator := context.allocator) -> ^TCP_Server {
     socket, err := socket_create(.Inet, .Stream); // IPv6?
     if err != .None do return null;
@@ -199,11 +199,11 @@ tcp_server_pulse :: (use server: ^TCP_Server) -> bool {
             continue;
         }
 
-        msg_event := new(TCP_Event.Message, allocator=server.event_allocator);
-        msg_event.client  = it;
-        msg_event.address = ^it.address;
-        msg_event.contents = memory.copy_slice(msg_buffer[0 .. bytes_read], allocator=server.event_allocator);
-        server.events << .{ .Message, msg_event };
+        data_event := new(TCP_Event.Data, allocator=server.event_allocator);
+        data_event.client  = it;
+        data_event.address = ^it.address;
+        data_event.contents = memory.copy_slice(msg_buffer[0 .. bytes_read], allocator=server.event_allocator);
+        server.events << .{ .Data, data_event };
     }
 
     for clients {
@@ -243,6 +243,28 @@ tcp_server_broadcast :: (use server: ^TCP_Server, data: [] u8, except: ^TCP_Serv
     }
 }
 
+tcp_server_handle_events :: macro (server: ^TCP_Server, handler: Code) {
+    while server->pulse() {
+        for server->get_events() {
+            #insert handler;
+        }
+    }
+}
+
+
+//
+// TCP Client
+//
+
+TCP_Client :: struct {
+    use connection: TCP_Connection;
+
+    get_events :: tcp_get_events
+}
+
+
+
+
 #local {
     tcp_server_kill_client :: (use server: ^TCP_Server, client: ^TCP_Server.Client) {
         client.state = .Dying;