Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-prism

Source of release 0.6.1

0.6.1 / src / composition / merge.lucb

## Public conflict reports and retained layer histories.
import interop
import memory
from document import Document, own_document, own_view, snapshot_document
from model import DocumentData, drop_data, own_data
from storage import List
from types import invalid
import composition.conflicts
import composition.layers
import composition.delta

pub struct MergeResult:
    var items: List[conflicts.Conflict]
    var merged: DocumentData = DocumentData()

    pub func init():
        return

    pub func ok() -> bool:
        return self.items.count == 0

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

    pub func path_at(index: usize) -> str!:
        if index >= self.items.count:
            error(invalid, "Prism conflict index is out of bounds")
        return self.items.items[index].path.view()

    pub func detail_at(index: usize) -> str!:
        if index >= self.items.count:
            error(invalid, "Prism conflict index is out of bounds")
        return self.items.items[index].detail.view()

    pub func document() -> interop.Reference[Document]!:
        if not self.ok():
            error(invalid, "Prism merge has unresolved conflicts")
        return try own_document(try self.merged.copy())

    pub func close():
        conflicts.close_conflicts(&self.items)
        self.merged.close()

pub let merge_type = interop.Type[MergeResult]("Prism merge result", MergeResult.close, closeable = true)

pub func merge(base: interop.Reference[Document], a: interop.Reference[Document], b: interop.Reference[Document]) -> interop.Reference[MergeResult]!:
    let result = try new MergeResult() in memory.heap
    populate(result, base, a, b) catch failure:
        result.close()
        free(result) in memory.heap
        error(failure.code, failure.message)
    return try interop.Reference[MergeResult].adopt(result, merge_type, memory.heap)

func populate(output: MergeResult*, base: interop.Reference[Document], a: interop.Reference[Document], b: interop.Reference[Document]) -> !:
    let before = (try base.get()).view_data()
    let left = (try a.get()).view_data()
    let right = (try b.get()).view_data()
    output.items = try conflicts.collect(left, right)
    if output.items.count == 0:
        let opinions: DocumentData[2] = [left[0], right[0]]
        output.merged = try layers.overlay(before, opinions)

pub struct LayerStack:
    var foundation: DocumentData*
    var opinions: List[delta.Layer]

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

    pub func push(layer: interop.Reference[Document]) -> !:
        var snap = try snapshot_document(try layer.get())
        defer snap.close()
        var owned = try delta.from_document(&snap)
        errdefer owned.close()
        try self.opinions.push(owned)
        owned = delta.Layer()

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

    pub func base() -> interop.Reference[Document]!:
        return try own_view(self.foundation, delta.Layer())

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

    pub func resolve() -> interop.Reference[Document]!:
        var extra = try delta.collapse(self.foundation, self.opinions.span())
        return try own_view(self.foundation, extra)

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

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

pub let layer_stack_type = interop.Type[LayerStack]("Prism layer stack", LayerStack.close, closeable = true)