Struct InternedInput 

pub struct InternedInput<T> {
    pub before: Vec<Token>,
    pub after: Vec<Token>,
    pub interner: Interner<T>,
}

Two lists of interned tokens that a Diff can be computed from.

A token represents the smallest possible unit of change during a diff. For text this is usually a line, a word or a single character. All algorithms operate on interned tokens instead of using the token data directly. This allows for much better performance by amortizing the cost of hashing/equality.

While you can intern tokens yourself it is strongly recommended to use InternedInput module.

Fields

before: Vec<Token>

The list of interned tokens from the first sequence (before changes).

after: Vec<Token>

The list of interned tokens from the second sequence (after changes).

interner: Interner<T>

The interner that stores the actual token data and maps tokens to their interned IDs.

Implementations

impl<T> InternedInput<T>

pub fn clear(&mut self)

Clears all token sequences and the interner.

This removes all tokens from both the before and after sequences, as well as clearing the interner’s storage.

Note that this will not free the allocated memory.

impl<T: Eq + Hash> InternedInput<T>

pub fn new<I: TokenSource<Token = T>>(before: I, after: I) -> Self

Creates a new InternedInput by tokenizing and interning two token sources.

Parameters

• before - The token source for the first sequence
• after - The token source for the second sequence

Returns

An InternedInput containing interned token sequences ready for diffing

pub fn reserve_for_token_source<S: TokenSource<Token = T> + ?Sized>( &mut self, before: &S, after: &S, )

Reserve capacity so that before and after would not need to allocate if their estimate_tokens would represent an exact match of their actual tokens.

Useful for minimization of allocation before calls to update_before and update_after.

pub fn reserve(&mut self, capacity_before: u32, capacity_after: u32)

Reserves capacity for the specified number of tokens in each sequence.

Parameters

• capacity_before - The number of tokens to reserve for the “before” sequence
• capacity_after - The number of tokens to reserve for the “after” sequence

pub fn update_before(&mut self, input: impl Iterator<Item = T>)

replaces self.before with the interned Tokens yielded by input Note that this does not erase any tokens from the interner and might therefore be considered a memory leak. If this function is called often over a long-running process consider clearing the interner with clear.

pub fn update_after(&mut self, input: impl Iterator<Item = T>)

replaces self.before with the interned Tokens yielded by input Note that this does not erase any tokens from the interner and might therefore be considered a memory leak. If this function is called often over a long-running process consider clearing the interner with clear or erase_tokens_after.

Trait Implementations

impl<T: Default> Default for InternedInput<T>

fn default() -> InternedInput<T>

Returns the “default value” for a type.