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}")