Struct TreeCoordinate 

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

A node’s coordinates in the spanning tree.

Coordinates are the path from the node to the root: [self, parent, grandparent, ..., root]

Each entry carries the node address plus declaration metadata (sequence and timestamp) for the wire protocol. Routing operations (distance, LCA) use only the node addresses.

The coordinate enables greedy routing via tree distance calculation. Two nodes can compute the hops between them by finding their lowest common ancestor (LCA) in the tree.

Implementations

impl TreeCoordinate

pub fn new(path: Vec<CoordEntry>) -> Result<Self, TreeError>

Create a coordinate from a path of entries (self to root).

The path must be non-empty and ordered from the node to the root.

pub fn from_addrs(addrs: Vec<NodeAddr>) -> Result<Self, TreeError>

Create a coordinate from node addresses only (no metadata).

Convenience constructor for cases where only routing is needed. Each entry gets sequence=0, timestamp=0.

pub fn root(node_addr: NodeAddr) -> Self

Create a coordinate for a root node.

pub fn root_with_meta( node_addr: NodeAddr, sequence: u64, timestamp: u64, ) -> Self

Create a root coordinate with metadata.

pub fn node_addr(&self) -> &NodeAddr

The node this coordinate belongs to (first element).

pub fn root_id(&self) -> &NodeAddr

The root of the tree (last element).

pub fn parent_id(&self) -> &NodeAddr

The immediate parent (second element, or self if root).

pub fn depth(&self) -> usize

Depth in the tree (0 = root).

pub fn entries(&self) -> &[CoordEntry]

The full path of entries with metadata.

pub fn node_addrs(&self) -> impl DoubleEndedIterator<Item = &NodeAddr>

Iterator over node addresses in the path (self to root).

Use this for routing operations (distance, LCA, ancestor checks) that only need the address path.

pub fn is_root(&self) -> bool

Check if this coordinate is a root (length 1).

pub fn distance_to(&self, other: &TreeCoordinate) -> usize

Calculate tree distance to another coordinate.

Distance is hops through the lowest common ancestor (LCA). If the coordinates have different roots, returns usize::MAX.

pub fn lca_depth(&self, other: &TreeCoordinate) -> usize

Find the depth of the lowest common ancestor.

Since coordinates are self-to-root, common ancestry is a suffix match. Returns the depth (from root) of the LCA.

pub fn lca(&self, other: &TreeCoordinate) -> Option<&NodeAddr>

Get the lowest common ancestor node ID.

pub fn has_ancestor(&self, other: &NodeAddr) -> bool

Check if other is an ancestor (appears in our path after self).

pub fn contains(&self, other: &NodeAddr) -> bool

Check if other is in our ancestry (including self).

pub fn ancestor_at(&self, depth: usize) -> Option<&NodeAddr>

Get the ancestor at a specific depth from self.

ancestor_at(0) returns self, ancestor_at(1) returns parent, etc.

Trait Implementations

impl Clone for TreeCoordinate

fn clone(&self) -> TreeCoordinate

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TreeCoordinate

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

Formats the value using the given formatter.

impl PartialEq for TreeCoordinate

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

impl StructuralPartialEq for TreeCoordinate