Struct difft::diff::graph::Vertex

pub(crate) struct Vertex<'s, 'b> {
    pub(crate) neighbours: RefCell<Option<&'b [(Edge, &'b Vertex<'s, 'b>)]>>,
    pub(crate) predecessor: Cell<Option<(u32, &'b Vertex<'s, 'b>)>>,
    pub(crate) lhs_syntax: Option<&'s Syntax<'s>>,
    pub(crate) rhs_syntax: Option<&'s Syntax<'s>>,
    parents: Stack<'b, EnteredDelimiter<'s, 'b>>,
    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
     ^              ^

Fields

neighbours: RefCell<Option<&'b [(Edge, &'b Vertex<'s, 'b>)]>>

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

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

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

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

lhs_parent_id: Option<NonZeroU32>

rhs_parent_id: Option<NonZeroU32>

Implementations

impl<'s, 'b> Vertex<'s, 'b>

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, 'b> Clone for Vertex<'s, 'b>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

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

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

Formats the value using the given formatter.

impl<'s, 'b> Hash for Vertex<'s, 'b>

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

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<'s, 'b> Eq for Vertex<'s, 'b>