Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-vector

Source of release 0.6.0

0.6.0 / src / vector / files.lucb

#==============================================================================================
#
#   vector/files - A vector layer's elements in a Prism manifest
#
#   DESCRIPTION:
#       An .l2d manifest keeps `vectors`, how many elements a layer holds, and for each,
#       bottom first, by its place j:
#
#           vector_j_name   its name
#           vector_j        its spec's values in `shape_values` order (22), then 1 or 0 for
#                           visible, then 1 or 0 for closed
#           vector_j_path   a path's anchors, six values each (none for the other kinds)
#           vector_j_runs   anchors in each run of a path of several (none for one)
#
#==============================================================================================

## Values `vector_j` holds.
let element_value_count: usize = 24

## The most anchors an element's path may bring back from a file.
let file_anchor_limit: usize = 1000000

## `list` into the manifest's `element`.
pub func write_elements(manifest: prism.Document*, element: str, list: const VectorElement[]) -> !:
    let count = try prism.Value.integer((i64)list.length)
    defer count.release()
    try manifest.set(element, "vectors", count)
    var key: u8[48]
    for at in 0..<list.length:
        let spec = list[at].spec
        let name = try prism.Value.text(list[at].name)
        defer name.release()
        try manifest.set(element, try member_name(key, at, "_name"), name)
        let shape = shape_values(spec)
        var values: f64[24] = ---
        for index in 0..<(usize)22:
            values[index] = shape[index]
        values[22] = 1.0 if list[at].visible else 0.0
        values[23] = 1.0 if spec.closed else 0.0
        var shape_of: i64[1] = [(i64)element_value_count]
        let numbers = try prism.Value.numbers(shape_of[..<1], values[..<24])
        defer numbers.release()
        try manifest.set(element, try member_name(key, at, ""), numbers)
        if spec.path.length > 0:
            shape_of[0] = (i64)spec.path.length
            let path = try prism.Value.numbers(shape_of[..<1], spec.path)
            defer path.release()
            try manifest.set(element, try member_name(key, at, "_path"), path)
        if spec.subpaths.length > 0:
            let runs = try new f64[spec.subpaths.length] --- in memory.heap
            defer free(runs) in memory.heap
            for index in 0..<runs.length:
                runs[index] = (f64)spec.subpaths[index]
            shape_of[0] = (i64)runs.length
            let value = try prism.Value.numbers(shape_of[..<1], runs)
            defer value.release()
            try manifest.set(element, try member_name(key, at, "_runs"), value)

## Element `at` of `element`, owning its name and path.
func read_element(doc: prism.Document*, element: str, at: usize) -> VectorElement!:
    var key: u8[48]
    let holder = try doc.get(element, try member_name(key, at, ""))
    defer holder.release()
    let numbers = holder.value()
    if numbers.count() != element_value_count:
        error(invalid, "a vector element's values are damaged")
    var values: f64[24] = ---
    for index in 0..<element_value_count:
        values[index] = try numbers.number_at(index)
    var spec = try shape_from_values(values[..<22])
    spec.closed = values[23] != 0.0
    if spec.kind == 4:
        spec.path = try read_numbers(doc, element, try member_name(key, at, "_path"), anchor_values)
        errdefer release_spec_path(&spec)
        let runs = read_numbers(doc, element, try member_name(key, at, "_runs"), 1) catch _:
            recover no_numbers()
        defer:
            if runs.length > 0:
                free(runs) in memory.heap
        if runs.length > 0:
            let sizes = try new u32[runs.length] --- in memory.heap
            defer free(sizes) in memory.heap
            for index in 0..<runs.length:
                if runs[index] < 1.0 or runs[index] > (f64)file_anchor_limit:
                    error(invalid, "a path's runs are damaged")
                sizes[index] = (u32)runs[index]
            spec.subpaths = try owned_subpaths(sizes, spec.path.length // anchor_values)
    let name_value = doc.get(element, try member_name(key, at, "_name")) catch failure:
        release_spec_path(&spec)
        error(failure.code, failure.message)
    defer name_value.release()
    let name = name_value.value().text_at() catch failure:
        release_spec_path(&spec)
        error(failure.code, failure.message)
    var made = try made_element(name, spec)
    made.visible = values[22] != 0.0
    return made

## Numbers at `element`.`name` as a new heap array, a multiple of `step` long.
pub func read_numbers(doc: prism.Document*, element: str, name: str, step: usize) -> f64[]!:
    let holder = try doc.get(element, name)
    defer holder.release()
    let value = holder.value()
    let count = value.count()
    if count == 0 or count % step != 0 or count > file_anchor_limit * anchor_values:
        error(invalid, "a vector element's numbers are damaged")
    let numbers = try new f64[count] --- in memory.heap
    errdefer free(numbers) in memory.heap
    for index in 0..<count:
        numbers[index] = try value.number_at(index)
        if not math.is_finite(numbers[index]):
            error(invalid, "a vector element's numbers must be finite")
    return numbers

pub func no_numbers() -> f64[]:
    var none_here: f64[]
    return none_here

## The elements `element` holds, bottom first; none when it holds none (not
## a vector layer).
pub func read_elements(doc: prism.Document*, element: str) -> VectorElement[]?!:
    let count = integer_named(doc, element, "vectors") catch _:
        return none
    if count < 0 or count > 100000:
        error(invalid, "a vector layer's element count is damaged")
    var list: VectorElement[]
    for at in 0..<(usize)count:
        let read = read_element(doc, element, at) catch failure:
            free_list(list)
            error(failure.code, failure.message)
        list = try list_with(list, at, read)
    return list

## The integer `name` of `element`.
func integer_named(doc: prism.Document*, element: str, name: str) -> i64!:
    let holder = try doc.get(element, name)
    defer holder.release()
    return try holder.value().integer_at()

## Element `at`'s member called `suffix` in the manifest: `vector_3_path`.
func member_name(buffer: u8[], at: usize, suffix: str) -> str!:
    return try strings.format(buffer, f"vector_{at}{suffix}")