Struct libdiffsitter::input_processing::Entry

pub struct Entry<'a> {
    pub reference: TSNode<'a>,
    pub text: &'a str,
    pub start_position: Point,
    pub end_position: Point,
    pub kind_id: u16,
}

A mapping between a tree-sitter node and the text it corresponds to

This is also all of the metadata the diff rendering interface has access to, and also defines the data that will be output by the JSON serializer.

Fields

reference: TSNode<'a>

The node an entry in the diff vector refers to

We keep a reference to the leaf node so that we can easily grab the text and other metadata surrounding the syntax

text: &'a str

A reference to the text the node refers to

This is different from the source_text that the AstVector refers to, as the entry only holds a reference to the specific range of text that the node covers.

start_position: Point

The entry’s start position in the document.

end_position: Point

The entry’s end position in the document.

kind_id: u16

The cached kind_id from the TSNode reference.

Caching it here saves some time because it is queried repeatedly later.

Implementations

impl<'a> Entry<'a>

pub fn start_position(&self) -> Point

Get the start position of an entry

pub fn end_position(&self) -> Point

Get the end position of an entry

Trait Implementations

impl<'a> Clone for Entry<'a>

fn clone(&self) -> Entry<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Entry<'a>

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

Formats the value using the given formatter.

impl<'a> From<VectorLeaf<'a>> for Entry<'a>

fn from(leaf: VectorLeaf<'a>) -> Self

Converts to this type from the input type.

impl<'a> FromIterator<Entry<'a>> for HunkAppender<'a>

fn from_iter<T>(iter: T) -> Selfwhere T: IntoIterator<Item = Entry<'a>>,

Create an instance of Hunks from an iterator over entries.

The user is responsible for making sure that the hunks are in proper order, otherwise this constructor may panic.

impl<'a> PartialEq<Entry<'a>> for Entry<'a>

fn eq(&self, other: &Entry<'_>) -> 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<'a> Serialize for Entry<'a>

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

Serialize this value into the given Serde serializer.

impl<'a> Copy for Entry<'a>

impl<'a> Eq for Entry<'a>