tiny.ui.View

1/// `View` holds typed slices over one publish buffer. In a view from `bind`, every nonempty2/// table field is a slice into `bytes`, so the view owns no memory. The default `View` is empty.3pub const View = struct {4    /// `View.bytes` is the whole buffer.5    bytes: []align(8) const u8 = &.{},6    /// `View.header` is a copy of its 152 byte header.7    header: Header = .{},8    nodes: []const Node = &.{},9    /// `View.identity` points to the `Store`'s current id-to-index map. `View.prior` points to the10    /// packed correspondence from the most recent publish. A `View` made by `bind` or by a caller11    /// can omit identity and prior: their defaults are null and empty. The correspondence describes12    /// only the immediately preceding retained tree, and remains valid until the next publish13    /// modifies the scratch arrays.14    identity: ?*const map.Map = null,15    prior: []const u32 = &.{},16    declarations: []const Declaration = &.{},17    classes: []const u32 = &.{},18    texts: []const TextRecord = &.{},19    runs: []const TextRun = &.{},20    relations: []const Relation = &.{},21    atoms: []const Atom = &.{},22    strings: []const u8 = &.{},23    solved_roots: []const SolvedRoot = &.{},24    solved_rects: []const Rect = &.{},2526    /// `View.text` returns the bytes of one atom from the string table. It returns an27    /// empty slice for `atom_absent`.28    pub fn text(self: View, atom: u32) []const u8 {29        if (atom == abi.atom_absent) return &.{};30        std.debug.assert(atom < self.atoms.len);31        const record = self.atoms[atom];32        std.debug.assert(record.offset + record.len <= self.strings.len);33        return self.strings[record.offset..][0..record.len];34    }3536    /// `View.declarationsOf` returns the declarations of node `node`, as a slice into37    /// the buffer.38    pub fn declarationsOf(self: View, node: u32) []const Declaration {39        std.debug.assert(node < self.nodes.len);40        const record = self.nodes[node];41        const first = record.declaration_first;42        std.debug.assert(first + record.declaration_count <= self.declarations.len);43        return self.declarations[first..][0..record.declaration_count];44    }4546    /// `View.classesOf` returns the class entries of node `node`.47    pub fn classesOf(self: View, node: u32) []const u32 {48        std.debug.assert(node < self.nodes.len);49        const record = self.nodes[node];50        std.debug.assert(record.class_first + record.class_count <= self.classes.len);51        return self.classes[record.class_first..][0..record.class_count];52    }5354    /// `View.textOf` returns a pointer to the text record of node `node`, or null55    /// when the node has no text.56    pub fn textOf(self: View, node: u32) ?*const TextRecord {57        std.debug.assert(node < self.nodes.len);58        const index = self.nodes[node].text;59        if (index == abi.text_absent) return null;60        std.debug.assert(index < self.texts.len);61        return &self.texts[index];62    }6364    /// `View.runsOf` returns the runs of one text record, as a slice into the buffer.65    pub fn runsOf(self: View, record: *const TextRecord) []const TextRun {66        std.debug.assert(record.run_first + record.run_count <= self.runs.len);67        return self.runs[record.run_first..][0..record.run_count];68    }6970    /// `View.children` returns an iterator over the direct children of node `node`.71    pub fn children(self: View, node: u32) walk.Children {72        return walk.children(self.nodes, node);73    }7475    /// `View.subtree` returns node `node` followed by all of its descendants.76    pub fn subtree(self: View, node: u32) []const Node {77        return walk.subtree(self.nodes, node);78    }7980    /// `View.solvedRectsOf` returns the `subtree_count + 1` rects of one solved root,81    /// starting at its `rect_first`.82    pub fn solvedRectsOf(self: View, root: SolvedRoot) []const Rect {83        std.debug.assert(root.node < self.nodes.len);84        const span = self.nodes[root.node].subtree_count + 1;85        std.debug.assert(root.rect_first + span <= self.solved_rects.len);86        return self.solved_rects[root.rect_first..][0..span];87    }88};

1pub const View = tree.View;