dymokomi/luce-base
Source of release 0.42.0
0.42.0 / src / std / interop / object.lucb
#==============================================================================================
#
# object - The stable owner shell
#
# DESCRIPTION:
# Shared by every native reference and managed alias; its header participates directly in
# the collector, with no second reference count.
#
#==============================================================================================
## Stable shell shared by every native reference and managed alias. Its header
## participates directly in the shared collector; no second reference count exists.
pub struct Owner[T]:
## The shared collector header.
pub var header: ownership.Object
var information: ownership.Info
var declaration: Type[T]
var native: T*?
var native_allocator: memory.Allocator?
var closed: bool
var disposed: bool
var active: usize
## Whether the owner has not been closed.
pub static func is_open(object: ownership.Object*) -> bool:
ownership.check_alive(object)
return not ((Owner[T]*)object).closed
## Begin a native call guard, retaining the object.
pub static func enter(object: ownership.Object*):
_ = ownership.retain(object)
((Owner[T]*)object).active += 1
## End a native call guard, disposing the owner once closed and idle.
pub static func leave(object: ownership.Object*):
ownership.check_alive(object)
let owner = (Owner[T]*)object
if owner.active == 0:
trap("a native call guard was left twice")
owner.active -= 1
if owner.closed and owner.active == 0:
dispose_owner[T](owner)
ownership.release(object)
## The collector's finalizer: close the owner.
pub static func finish_owner(object: ownership.Object*):
close_owner[T]((Owner[T]*)object)
## Free the owner's native storage.
pub static func drop_owner(object: ownership.Object*):
let owner = (Owner[T]*)object
if let native = owner.native:
let allocator = owner.native_allocator else trap("native storage has no allocator")
owner.native = none
free(native) in allocator
## Visit the native value's strong references.
pub static func trace_owner(object: ownership.Object*, visit: func(ownership.Object*, void*) -> unit, context: void*):
let owner = (Owner[T]*)object
if owner.disposed:
return
if let native = owner.native:
if let trace = owner.declaration.trace:
trace(native, visit, context)
func close_owner[T](owner: Owner[T]*):
ownership.check_alive(&owner.header)
if owner.closed:
return
# Publish closure before package cleanup can call back into an alias.
owner.closed = true
if owner.active == 0:
dispose_owner[T](owner)
func dispose_owner[T](owner: Owner[T]*):
if owner.disposed:
return
owner.disposed = true
if let native = owner.native:
owner.declaration.dispose(native)
## Unpublished ownership storage. Reserve before running a native initializer;
## publish only after success, or cancel without running a successful finalizer.
pub struct Reservation[T]:
var owner: Owner[T]*?
## Reserve unpublished storage for `declaration`.
pub func init(declaration: Type[T]) -> !:
if declaration.main_thread and not thread.is_main():
error(wrong_thread, "this native type requires the process main thread")
var information = ownership.Info(name = declaration.name, size = memory.size_of(Owner[T]),
finish = Owner[T].finish_owner, drop = Owner[T].drop_owner, trace = Owner[T].trace_owner)
let owner = (Owner[T]*)try ownership.reserve(&information, memory.size_of(Owner[T]))
owner.information = information
owner.header.info = &owner.information
owner.declaration = declaration
self.owner = owner
## Publish the native value, yielding a reference and consuming the reservation.
pub func publish(native: T*, allocator: memory.Allocator? = none) -> Reference[T]:
let owner = self.owner else trap("native ownership has already been published or cancelled")
owner.native = native
owner.native_allocator = allocator else memory.allocator
self.owner = none
return Reference[T](owner)
## Discard the reservation without publishing.
pub func cancel():
if let owner = self.owner:
self.owner = none
ownership.discard_unpublished(&owner.header)