Luce packages
LuceLuce BaseLuciaOS

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)