Struct CoreIR 

pub struct CoreIR {
    pub nodes: HashMap<NodeId, CoreNode>,
    pub root: Option<NodeId>,
}

The root container for an intermediate representation graph.

CoreIR owns all nodes in the tree and knows which one is the root. It is the primary data structure you build when compiling a widget tree, and the primary input to the layout engine.

Example

use fission_ir::{CoreIR, NodeId, Op, LayoutOp};

let mut ir = CoreIR::new();
let root = NodeId::explicit("root");
ir.add_node(root, Op::Layout(LayoutOp::Box {
    width: None, height: None,
    min_width: None, max_width: None,
    min_height: None, max_height: None,
    padding: [0.0; 4], flex_grow: 1.0, flex_shrink: 1.0,
    aspect_ratio: None,
}), vec![]);
ir.set_root(root);
assert!(ir.root.is_some());

Fields

nodes: HashMap<NodeId, CoreNode>

All nodes in the graph, keyed by their NodeId.

root: Option<NodeId>

The root node of the tree, or None if the tree is empty.

Implementations

impl CoreIR

pub fn new() -> Self

Creates an empty IR with no nodes and no root.

pub fn add_node(&mut self, id: NodeId, op: Op, children: Vec<NodeId>)

Adds a node to the graph and wires up parent-child relationships.

Each child in children that already exists in the graph will have its parent field set to id. Add children before their parents to ensure the parent link is established.

Arguments

• id – The identity of the new node.
• op – What this node does (layout, paint, structural, or semantics).
• children – Ordered list of child NodeIds.

pub fn set_root(&mut self, id: NodeId)

Designates a node as the root of the tree.

The layout engine starts traversal from this node. There must be exactly one root; calling this again replaces the previous root.

Trait Implementations

impl Clone for CoreIR

fn clone(&self) -> CoreIR

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for CoreIR

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for CoreIR

fn default() -> CoreIR

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for CoreIR

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for CoreIR

fn eq(&self, other: &CoreIR) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for CoreIR

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for CoreIR