Struct libdiffsitter::input_processing::Vector

pub struct Vector<'a> {
    pub leaves: Vec<VectorLeaf<'a>>,
    pub source_text: &'a str,
}

A vector that allows for linear traversal through the leafs of an AST.

This representation of the tree leaves is much more convenient for things like dynamic programming, and provides useful for formatting.

Fields

leaves: Vec<VectorLeaf<'a>>

The leaves of the AST, build with an in-order traversal

source_text: &'a str

The full source text that the AST refers to

Implementations

impl<'a> Vector<'a>

pub fn from_ts_tree(tree: &'a TSTree, text: &'a str) -> Self

Create a DiffVector from a tree_sitter tree

This method calls a helper function that does an in-order traversal of the tree and adds leaf nodes to a vector

pub fn len(&self) -> usize

Return the number of nodes in the diff vector

pub fn is_empty(&self) -> bool

Return whether there are any leaves in the diff vector.

Trait Implementations

impl<'a> Debug for Vector<'a>

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

Formats the value using the given formatter.

impl<'a> From<&'a Vector<'a>> for Vec<Entry<'a>>

fn from(ast_vector: &'a Vector<'a>) -> Self

Converts to this type from the input type.

impl<'a> Index<usize> for Vector<'a>

type Output = VectorLeaf<'a>

The returned type after indexing.

fn index(&self, index: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<'a> PartialEq<Vector<'a>> for Vector<'a>

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