Fix possible race condition

since the queue was being set in an async task and we were then calling send asserting that the queue was set, we could have triggered a panic.
didn't run into it but seemed likely to cause issues in the future.

also compute the buffer size for operators at comptime.

1 files changed, 7 insertions, 7 deletions

diff --git a/src/server/client.zig b/src/server/client.zig
index 004b0f9..2ce3c38 100644
--- a/src/server/client.zig
+++ b/src/server/client.zig
@@ -6,18 +6,20 @@ const Client = @This();
 connect: ?Message.Connect,
 
 // Messages for this client to receive.
-recv_queue: ?*std.Io.Queue(Message) = null,
+recv_queue: *std.Io.Queue(Message),
 
 from_client: *std.Io.Reader,
 to_client: *std.Io.Writer,
 
 pub fn init(
     connect: ?Message.Connect,
+    recv_queue: *std.Io.Queue(Message),
     in: *std.Io.Reader,
     out: *std.Io.Writer,
 ) Client {
     return .{
         .connect = connect,
+        .recv_queue = recv_queue,
         .from_client = in,
         .to_client = out,
     };
@@ -30,17 +32,17 @@ pub fn deinit(self: *Client, alloc: std.mem.Allocator) void {
     self.* = undefined;
 }
 
-pub fn start(self: *Client, io: std.Io, alloc: std.mem.Allocator, queue: *std.Io.Queue(Message)) !void {
-    self.recv_queue = queue;
+pub fn start(self: *Client, io: std.Io, alloc: std.mem.Allocator) !void {
     var msgs: [8]Message = undefined;
 
     while (true) {
-        const len = try queue.get(io, &msgs, 1);
+        const len = try self.recv_queue.get(io, &msgs, 1);
         std.debug.assert(len <= msgs.len);
         for (0..len) |i| {
             const msg = msgs[i];
             defer switch (msg) {
                 .msg => |m| m.deinit(alloc),
+                .hmsg => |h| h.deinit(alloc),
                 else => {},
             };
             errdefer for (msgs[i + 1 .. len]) |mg| switch (mg) {
@@ -98,9 +100,7 @@ pub fn start(self: *Client, io: std.Io, alloc: std.mem.Allocator, queue: *std.Io
 }
 
 pub fn send(self: *Client, io: std.Io, msg: Message) !void {
-    if (self.recv_queue) |queue| {
-        try queue.putOne(io, msg);
-    } else @panic("Must start() the client before sending it messages.");
+    try self.recv_queue.putOne(io, msg);
 }
 
 pub fn next(self: *Client, allocator: std.mem.Allocator) !Message {