dymokomi/luce-base
Source of release 0.46.0
0.46.0 / src / std / interop / lease.lucb
#==============================================================================================
#
# lease - A one-shot validity scope
#
# DESCRIPTION:
# Tied to an owning native object: keeping the lease alive keeps its checks safe, and
# invalidation never extends the resource's scope.
#
#==============================================================================================
## A one-shot validity scope tied to an owning native object. Keeping a lease
## alive keeps its checks safe; invalidation never extends the resource's scope.
struct LeaseState:
var header: ownership.Object
var owner: ownership.Object*
var open: func(ownership.Object*) -> bool
var begin: func(ownership.Object*) -> unit
var end: func(ownership.Object*) -> unit
var valid: bool
func drop_lease(object: ownership.Object*):
let state = (LeaseState*)object
ownership.release_held(state.owner)
func trace_lease(object: ownership.Object*, visit: func(ownership.Object*, void*) -> unit, context: void*):
visit(((LeaseState*)object).owner, context)
var lease_info: ownership.Info = ownership.Info(name = "native lease", size = memory.size_of(LeaseState),
finish = none, drop = drop_lease, trace = trace_lease)
## A one-shot validity scope over an owning native object.
pub struct Lease:
var state: LeaseState*
var generation: u64
func init(owner: ownership.Object*, open: func(ownership.Object*) -> bool,
begin: func(ownership.Object*) -> unit, end: func(ownership.Object*) -> unit) -> !:
ownership.check_alive(owner)
let state = (LeaseState*)try ownership.reserve(&lease_info, memory.size_of(LeaseState))
state.owner = ownership.retain(owner)
state.open = open
state.begin = begin
state.end = end
state.valid = true
self.state = state
self.generation = state.header.generation
func alive():
ownership.check_alive(&self.state.header)
if self.generation != self.state.header.generation:
trap("a native lease has a stale generation")
## Another edge to the same lease.
pub func clone() -> Lease:
self.alive()
_ = ownership.retain(&self.state.header)
return self
## Drop this lease's edge.
pub func release():
self.alive()
ownership.release_held(&self.state.header)
## Mark the scope invalid; later checks fail.
pub func invalidate():
self.alive()
self.state.valid = false
## Whether the scope is still valid and its owner open.
pub func is_valid() -> bool:
self.alive()
return self.state.valid and self.state.open(self.state.owner)
## Error `expired` when the scope is no longer valid.
pub func check() -> !:
if not self.is_valid():
error(expired, "a native view has expired")
## An active invocation postpones physical disposal of its native owner.
## Operational closure/expiry is still visible immediately to every alias.
pub func enter() -> !:
try self.check()
_ = ownership.retain(&self.state.header)
self.state.begin(self.state.owner)
## End a guarded invocation, releasing the owner.
pub func leave():
self.alive()
self.state.end(self.state.owner)
ownership.release_held(&self.state.header)
## Visit the owner 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)