dymokomi/luce-base
Source of release 0.46.0
0.46.0 / src / std / interop / signal.lucb
#==============================================================================================
#
# signal - A native multicast signal
#
# DESCRIPTION:
# A retained signal that fans an argument out to every connected callback; connecting
# yields a `Connection` token whose last reference disconnects.
#
#==============================================================================================
struct Subscription[A]:
let identifier: u64
let callback: Callback[A, unit]
var next: Subscription[A]*?
struct Delivery[A]:
let identifier: u64
let callback: Callback[A, unit]
struct SignalState[A]:
var header: ownership.Object
var information: ownership.Info
var allocator: memory.Allocator
var first: Subscription[A]*?
var last: Subscription[A]*?
var serial: u64
var count: usize
var closed: bool
static func contains(object: ownership.Object*, identifier: u64) -> bool:
let state = (SignalState[A]*)object
var cursor = state.first
while let entry = cursor:
if entry.identifier == identifier:
return true
cursor = entry.next
return false
static func remove(object: ownership.Object*, identifier: u64):
let state = (SignalState[A]*)object
var previous: Subscription[A]*? = none
var cursor = state.first
while let entry = cursor:
if entry.identifier == identifier:
if let before = previous:
before.next = entry.next
else:
state.first = entry.next
if state.last == entry:
state.last = previous
state.count -= 1
# Detach before releasing: callback destruction can reenter us.
entry.callback.release()
free(entry) in state.allocator
return
previous = entry
cursor = entry.next
static func close(object: ownership.Object*):
let state = (SignalState[A]*)object
state.closed = true
var cursor = state.first
state.first = none
state.last = none
state.count = 0
while let entry = cursor:
cursor = entry.next
entry.callback.release()
free(entry) in state.allocator
static func trace(object: ownership.Object*, visit: func(ownership.Object*, void*) -> unit, context: void*):
var cursor = ((SignalState[A]*)object).first
while let entry = cursor:
entry.callback.trace(visit, context)
cursor = entry.next
## Ordered, thread-bound delivery. Base copies borrow this carrier; clone/release
## manage ownership. Package owners close their signal before releasing it.
# mark: The signal carrier =====================================================================
## A typed, connectable signal: an owned carrier its aliases share by reference count.
pub struct Signal[A]:
let state: SignalState[A]*
## A custom allocator must outlive the signal and its connection aliases.
pub func init(allocator: memory.Allocator? = none) -> !:
let selected = allocator else memory.heap
var information = ownership.Info(name = "signal", size = memory.size_of(SignalState[A]),
finish = none, drop = SignalState[A].close, trace = SignalState[A].trace)
let state = (SignalState[A]*)try ownership.reserve(&information, memory.size_of(SignalState[A]), selected)
state.information = information
state.header.info = &state.information
state.allocator = selected
self.state = state
## Another strong reference to the same signal.
pub func clone() -> Signal[A]:
_ = ownership.retain(&self.state.header)
return self
## Drop this signal's edge.
pub func release():
ownership.release_held(&self.state.header)
## Close the signal; further connects and emits fail.
pub func close():
ownership.check_alive(&self.state.header)
SignalState[A].close(&self.state.header)
## Whether the signal has been closed.
pub func is_closed() -> bool:
ownership.check_alive(&self.state.header)
return self.state.closed
## Visit the signal state as a strong reference.
pub func trace(visit: func(ownership.Object*, void*) -> unit, context: void*):
ownership.check_thread(&self.state.header)
visit(&self.state.header, context)
## Register `callback`, returning a `Connection` token.
pub func connect(callback: Callback[A, unit]) -> Reference[Connection]!:
ownership.check_alive(&self.state.header)
ownership.check_alive(callback.owner)
if self.state.closed:
error(invalid, "a signal is closed")
let identifier = self.state.serial +? 1 else error(invalid, "signal registration identities exhausted")
var reservation = try Reservation[Connection](connection_type)
errdefer reservation.cancel()
let token = reservation.publish(try new Connection(&self.state.header, identifier,
SignalState[A].remove, SignalState[A].contains) in self.state.allocator, self.state.allocator)
errdefer token.release()
let entry = try new Subscription[A](identifier, callback.clone(), none) in self.state.allocator
self.state.serial = identifier
self.state.count += 1
if let last = self.state.last:
last.next = entry
else:
self.state.first = entry
self.state.last = entry
return token
## Deliver `argument` to every connected callback.
pub func emit(argument: A) -> Outcome[unit]:
_ = ownership.retain(&self.state.header)
defer ownership.release_held(&self.state.header)
if self.state.closed:
return Outcome[unit].failure(invalid, Owned[str]("a signal is closed"))
if self.state.count == 0:
return Outcome[unit].success(Owned[unit](()))
let snapshot = new Delivery[A][self.state.count] --- in self.state.allocator catch failure:
return failed_outcome[unit](failure.code, failure.message)
defer free(snapshot) in self.state.allocator
var cursor = self.state.first
var count: usize = 0
while let entry = cursor:
snapshot[count] = Delivery[A](entry.identifier, entry.callback.clone())
count += 1
cursor = entry.next
defer release_deliveries[A](snapshot)
for delivery in snapshot:
if not SignalState[A].contains(&self.state.header, delivery.identifier):
continue
let result = delivery.callback.invoke(argument)
if not result.is_success():
return result
result.release()
return Outcome[unit].success(Owned[unit](()))
func release_deliveries[A](deliveries: const Delivery[A][]):
for delivery in deliveries:
delivery.callback.release()