Struct Vertex

pub(crate) struct Vertex<'s, 'v> {
    pub(crate) neighbours: OnceCell<&'v [(Edge, &'v Vertex<'s, 'v>)]>,
    pub(crate) predecessor: Cell<Option<(u32, &'v Vertex<'s, 'v>)>>,
    pub(crate) lhs_syntax: Option<&'s Syntax<'s>>,
    pub(crate) rhs_syntax: Option<&'s Syntax<'s>>,
    parents: Stack<'v, EnteredDelimiter<'s, 'v>>,
    lhs_parent_id: Option<NonZeroU32>,
    rhs_parent_id: Option<NonZeroU32>,
}

A vertex in a directed acyclic graph that represents a diff.

Each vertex represents two pointers: one to the next unmatched LHS syntax, and one to the next unmatched RHS syntax.

For example, suppose we have X A on the LHS and A on the RHS. Our start vertex looks like this.

LHS: X A     RHS: A
     ^            ^

From this vertex, we could take Edge::NovelAtomLHS, bringing us to this vertex.

LHS: X A     RHS: A
       ^          ^

Alternatively, we could take the Edge::NovelAtomRHS, bringing us to this vertex.

LHS: X A     RHS: A
     ^              ^

Vertices are arena allocated (the ’v lifetime) and have references to syntax nodes (the ’s lifetime).

Fields

neighbours: OnceCell<&'v [(Edge, &'v Vertex<'s, 'v>)]>

The neighbours of this vertex. This is computed lazily, on first access.

predecessor: Cell<Option<(u32, &'v Vertex<'s, 'v>)>>

The predecessor of this vertex in the shortest route found so far.

This can change as Dijkstra runs: the first time we see the node in the to-visit set, we may not have reached it by the shortest route.

lhs_syntax: Option<&'s Syntax<'s>>

rhs_syntax: Option<&'s Syntax<'s>>

parents: Stack<'v, EnteredDelimiter<'s, 'v>>

lhs_parent_id: Option<NonZeroU32>

rhs_parent_id: Option<NonZeroU32>

Implementations

impl<'s, 'v> Vertex<'s, 'v>

pub(crate) fn is_end(&self) -> bool

pub(crate) fn new( lhs_syntax: Option<&'s Syntax<'s>>, rhs_syntax: Option<&'s Syntax<'s>>, ) -> Self

Trait Implementations

impl<'s, 'v> Clone for Vertex<'s, 'v>

fn clone(&self) -> Vertex<'s, 'v>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'s, 'v> Debug for Vertex<'s, 'v>

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

Formats the value using the given formatter.

impl Hash for Vertex<'_, '_>

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

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 PartialEq for Vertex<'_, '_>

fn eq(&self, other: &Self) -> 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 Vertex<'_, '_>