Struct NodeId 

pub struct NodeId(/* private fields */);

A content-addressed 128-bit node identity.

NodeId is the primary key used throughout the Fission pipeline to refer to a specific node. Because it is derived from BLAKE3 hashes, two nodes with the same derivation inputs always produce the same NodeId, which makes tree diffing cheap.

Construction

use fission_ir::NodeId;

// From a stable string key (good for well-known, named nodes):
let id = NodeId::explicit("sidebar");

// From a parent ID and a position path (good for list items):
let parent = NodeId::explicit("list");
let item_3 = NodeId::derived(parent.as_u128(), &[3]);

Equality and hashing

NodeId implements Eq, Hash, and Ord, so it can be used as a key in HashMap, BTreeMap, and HashSet.

Implementations

impl NodeId

pub const fn from_u128(val: u128) -> NodeId

Creates a NodeId from a raw 128-bit value.

This is intended for internal use or deserialization. In most cases you should use NodeId::explicit or NodeId::derived instead.

pub fn as_u128(&self) -> u128

Returns the underlying 128-bit value.

Useful when you need to feed a node’s identity into another hash (e.g., when deriving child IDs with NodeId::derived).

pub fn explicit(key: &str) -> NodeId

Creates a NodeId from a user-provided string key.

The key is hashed with BLAKE3 (prefixed with "explicit:"), producing a deterministic ID that is stable across rebuilds as long as the key string does not change. Use this for well-known, named nodes like "root" or "toolbar".

Example

use fission_ir::NodeId;
let a = NodeId::explicit("header");
let b = NodeId::explicit("header");
assert_eq!(a, b); // same key -> same ID

pub fn derived(parent: u128, path: &[u32]) -> NodeId

Creates a NodeId derived from a parent ID and a child-index path.

This implements structural identity: a node’s ID is determined by its position in the tree rather than by a user-provided name. Useful for dynamically generated children like list items.

Arguments

• parent – The parent node’s raw u128 value (see NodeId::as_u128).
• path – One or more child indices describing the path from the parent.

Example

use fission_ir::NodeId;
let parent = NodeId::explicit("list");
let item_0 = NodeId::derived(parent.as_u128(), &[0]);
let item_1 = NodeId::derived(parent.as_u128(), &[1]);
assert_ne!(item_0, item_1);

Trait Implementations

impl Clone for NodeId

fn clone(&self) -> NodeId

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for NodeId

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for NodeId

fn deserialize<__D>( __deserializer: __D, ) -> Result<NodeId, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for NodeId

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

Formats the value using the given formatter.

impl From<NodeId> for WidgetNodeId

fn from(node: NodeId) -> WidgetNodeId

Converts to this type from the input type.

impl From<WidgetNodeId> for NodeId

fn from(id: WidgetNodeId) -> NodeId

Converts to this type from the input type.

impl Hash for NodeId

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for NodeId

fn cmp(&self, other: &NodeId) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for NodeId

fn eq(&self, other: &NodeId) -> 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 PartialOrd for NodeId

fn partial_cmp(&self, other: &NodeId) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for NodeId

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for NodeId

impl Eq for NodeId

impl StructuralPartialEq for NodeId