queue: add drain method, simplify popping

src/Server.zig

···
 const ChannelPrivileges = irc.ChannelPrivileges;
 const ChatHistory = irc.ChatHistory;
 const ClientMessage = irc.ClientMessage;
+const Http = @import("http.zig");
 const Message = irc.Message;
 const MessageIterator = irc.MessageIterator;
 const Queue = @import("queue.zig").Queue;
···
 const Server = @import("Server.zig");
 const Timestamp = irc.Timestamp;
 const User = irc.User;
-const Http = @import("http.zig");
 
 const assert = std.debug.assert;
 
···
         realname: []const u8,
     };
 };
+
+pub const WorkerQueue = Queue(WakeupResult, 128);
 
 pub const Options = struct {
     hostname: []const u8 = "localhost",

src/queue.zig

···
                 self.not_full.signal();
             }
 
-            const result = self.buf[self.mask(self.read_index)];
-            self.read_index = self.mask2(self.read_index + 1);
-            return result;
+            return self.popLH();
         }
 
         /// Push an item into the queue. Blocks until an item has been
···
         /// available.
         pub fn tryPop(self: *Self) ?T {
             self.mutex.lock();
-            if (self.isEmptyLH()) {
-                self.mutex.unlock();
-                return null;
-            }
-            self.mutex.unlock();
-            return self.pop();
+            defer self.mutex.unlock();
+            if (self.isEmptyLH()) return null;
+            return self.popLH();
         }
 
         /// Poll the queue. This call blocks until events are in the queue
···
             std.debug.assert(!self.isEmptyLH());
         }
 
+        pub fn lock(self: *Self) void {
+            self.mutex.lock();
+        }
+
+        pub fn unlock(self: *Self) void {
+            self.mutex.unlock();
+        }
+
+        /// Used to efficiently drain the queue while the lock is externally held
+        pub fn drain(self: *Self) ?T {
+            if (self.isEmptyLH()) return null;
+        }
+
         fn isEmptyLH(self: Self) bool {
             return self.write_index == self.read_index;
         }
···
         /// Returns `index` modulo twice the length of the backing slice.
         fn mask2(self: Self, index: usize) usize {
             return index % (2 * self.buf.len);
+        }
+
+        fn popLH(self: *Self) T {
+            const result = self.buf[self.mask(self.read_index)];
+            self.read_index = self.mask2(self.read_index + 1);
+            return result;
         }
     };
 }