///|
/// Generic resource table for long-lived native handles exposed to JavaScript.
struct ResourceTable[T] {
mut next_rid : Int
values : Map[Int, T]
}
///|
/// Creates an empty resource table.
/// Resource ids start at `1` so `0` can remain available as a sentinel in
/// external protocols.
pub fn[T] ResourceTable::new() -> ResourceTable[T] {
ResourceTable::{ next_rid: 1, values: Map([]) }
}
///|
/// Stores one value and returns its new resource id.
/// Resource ids grow monotonically for the lifetime of the table so callers can
/// hand them to JavaScript or native code safely.
pub fn[T] ResourceTable::add(self : ResourceTable[T], value : T) -> Int {
let rid = self.next_rid
self.next_rid += 1
self.values.set(rid, value)
rid
}
///|
/// Returns one resource by id when it is still registered.
/// `None` means the id was never issued or has already been released.
pub fn[T] ResourceTable::get(self : ResourceTable[T], rid : Int) -> T? {
self.values.get(rid)
}
///|
/// Removes one resource and returns its previous value when present.
/// This is the normal release path for long-lived native handles exposed to
/// JavaScript.
pub fn[T] ResourceTable::remove(self : ResourceTable[T], rid : Int) -> T? {
let value = self.values.get(rid)
self.values.remove(rid)
value
}
///|
/// Returns whether one resource id is currently registered.
/// Use this for validation when incoming ids may have been released already.
pub fn[T] ResourceTable::contains(self : ResourceTable[T], rid : Int) -> Bool {
self.values.get(rid) is Some(_)
}
///|
/// Returns every currently registered resource id.
/// The result is useful for bulk cleanup, diagnostics, or leak detection.
pub fn[T] ResourceTable::rids(self : ResourceTable[T]) -> Array[Int] {
let rids : Array[Int] = []
for rid, _ in self.values {
rids.push(rid)
}
rids
}