58 lines
1.5 KiB
Zig
58 lines
1.5 KiB
Zig
const std = @import("../std.zig");
|
|
const RwLock = std.event.RwLock;
|
|
|
|
/// Thread-safe async/await RW lock that protects one piece of data.
|
|
/// Functions which are waiting for the lock are suspended, and
|
|
/// are resumed when the lock is released, in order.
|
|
pub fn RwLocked(comptime T: type) type {
|
|
return struct {
|
|
lock: RwLock,
|
|
locked_data: T,
|
|
|
|
const Self = @This();
|
|
|
|
pub const HeldReadLock = struct {
|
|
value: *const T,
|
|
held: RwLock.HeldRead,
|
|
|
|
pub fn release(self: HeldReadLock) void {
|
|
self.held.release();
|
|
}
|
|
};
|
|
|
|
pub const HeldWriteLock = struct {
|
|
value: *T,
|
|
held: RwLock.HeldWrite,
|
|
|
|
pub fn release(self: HeldWriteLock) void {
|
|
self.held.release();
|
|
}
|
|
};
|
|
|
|
pub fn init(data: T) Self {
|
|
return Self{
|
|
.lock = RwLock.init(),
|
|
.locked_data = data,
|
|
};
|
|
}
|
|
|
|
pub fn deinit(self: *Self) void {
|
|
self.lock.deinit();
|
|
}
|
|
|
|
pub async fn acquireRead(self: *Self) HeldReadLock {
|
|
return HeldReadLock{
|
|
.held = self.lock.acquireRead(),
|
|
.value = &self.locked_data,
|
|
};
|
|
}
|
|
|
|
pub async fn acquireWrite(self: *Self) HeldWriteLock {
|
|
return HeldWriteLock{
|
|
.held = self.lock.acquireWrite(),
|
|
.value = &self.locked_data,
|
|
};
|
|
}
|
|
};
|
|
}
|