Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-prism

Source of release 0.6.0

0.6.0 / src / composition / event_log.lucb

## Monotonic commits, retained replay, catch-up deltas and history compaction.
import interop
import memory
import composition.layers as composition
import composition.delta
from model import DocumentData, drop_data, own_data
from document import Document, own_document, own_view, snapshot_document
from storage import List
from types import invalid, limit_exceeded

pub struct Changes:
    var layers: List[delta.Layer]

    pub func init():
        return

    pub func count() -> usize:
        return self.layers.count

    pub func at(index: usize) -> interop.Reference[Document]!:
        if index >= self.layers.count:
            error(invalid, "Prism change index is out of bounds")
        return try own_document(try delta.to_document(&self.layers.items[index]))

    pub func close():
        for i in 0..<self.layers.count:
            self.layers.items[i].close()
        self.layers.close()

pub let changes_type = interop.Type[Changes]("Prism changes", Changes.close, closeable = true)

pub struct EventLog:
    var base: DocumentData*
    var history: List[delta.Layer]
    var offset: usize

    pub func init(base: interop.Reference[Document]) -> !:
        var first = try snapshot_document(try base.get())
        errdefer first.close()
        self.base = try own_data(first)
        first = DocumentData()
        self.history = List[delta.Layer]()
        self.offset = 0

    pub func head_offset() -> usize:
        return self.offset + self.history.count

    pub func earliest_offset() -> usize:
        return self.offset

    pub func layer_count() -> usize:
        return self.history.count

    pub func head() -> interop.Reference[Document]!:
        return try self.at(self.head_offset())

    pub func commit(next: interop.Reference[Document]) -> usize!:
        let count = self.head_offset() +? 1 else error(limit_exceeded, "Prism event offset overflow")
        let current = try self.head()
        defer current.release()
        let patch = try current.value().diff(next)
        defer patch.release()
        var layer = try delta.from_document((try patch.get()).view_data())
        errdefer layer.close()
        try self.history.push(layer)
        layer = delta.Layer()
        return count

    func retained(offset: usize) -> usize!:
        if offset < self.offset:
            error(invalid, "Prism history was compacted; obtain a new snapshot")
        let count = offset - self.offset
        return count if count < self.history.count else self.history.count

    pub func at(offset: usize) -> interop.Reference[Document]!:
        let count = try self.retained(offset)
        var extra = try delta.collapse(self.base, self.history.span()[..<count])
        return try own_view(self.base, extra)

    pub func since(offset: usize) -> interop.Reference[Changes]!:
        let start = try self.retained(offset)
        var changes = Changes()
        errdefer changes.close()
        try changes.layers.reserve(self.history.count - start)
        for layer in self.history.span()[start..]:
            try changes.layers.push(try layer.copy())
        let owned = try new Changes() in memory.heap
        owned[0] = changes
        changes = Changes()
        return try interop.Reference[Changes].adopt(owned, changes_type, memory.heap)

    pub func compact(keep: usize) -> !:
        if keep >= self.history.count:
            return
        let folded = self.history.count - keep
        var baked = try self.base.copy()
        errdefer baked.close()
        for i in 0..<folded:
            try delta.apply(&baked, &self.history.items[i])
        let heap = try own_data(baked)
        baked = DocumentData()
        drop_data(self.base)
        self.base = heap
        for i in 0..<folded:
            self.history.items[i].close()
        for i in 0..<keep:
            self.history.items[i] = self.history.items[i + folded]
        self.history.count = keep
        self.offset += folded

    pub func close():
        drop_data(self.base)
        for i in 0..<self.history.count:
            self.history.items[i].close()
        self.history.close()

pub let event_log_type = interop.Type[EventLog]("Prism event log", EventLog.close, closeable = true)