Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-prism

Source of release 0.6.1

0.6.1 / src / evaluation / cache.lucb

## One owned derived value keyed by revision and time; failed producers retain it.
import interop
import ownership
from luce_std import math
from types import invalid

pub struct EvalKey:
    pub var revision: usize
    pub var time: f64

pub struct EvalCache[T]:
    var result: interop.Reference[T]?
    var key: EvalKey
    var cached: bool
    var producing: bool
    var close_pending: bool

    pub func init():
        return

    pub func valid(key: EvalKey) -> bool:
        return self.cached and self.key.revision == key.revision and self.key.time == key.time

    pub func invalidate():
        self.cached = false

    func finish():
        self.producing = false
        if self.close_pending:
            self.close_pending = false
            self.close()

    pub func evaluate(key: EvalKey, producer: interop.Callback[EvalKey, interop.Reference[T]]) -> interop.Reference[T]!:
        if not math.is_finite(key.time):
            error(invalid, "Prism evaluation cache time must be finite")
        if self.valid(key):
            return (self.result else error(invalid, "invalid Prism evaluation cache")).clone()
        if self.producing:
            error(invalid, "recursive Prism evaluation cache producer")
        self.producing = true
        defer self.finish()
        let output = producer.invoke(key)
        defer output.release()
        let produced = (try output.get()).clone()
        if let previous = self.result:
            previous.release()
        self.result = produced
        self.key = key
        self.cached = true
        return produced.clone()

    pub func trace(visit: func(ownership.Object*, void*) -> unit, context: void*):
        if let value = self.result:
            value.trace(visit, context)

    pub func close():
        if self.producing:
            self.close_pending = true
            return
        if let value = self.result:
            value.release()
        self.result = none
        self.cached = false