Struct CodebaseDiff 

pub struct CodebaseDiff { /* private fields */ }

Represents the differences between two states of a codebase, typically used for incremental analysis.

This structure uses a single fingerprint hash per symbol to determine changes. Any change to a symbol (signature, body, modifiers, attributes) produces a different hash, triggering re-analysis.

Provides a comprehensive API for modification and querying following established conventions.

Implementations

impl CodebaseDiff

pub fn new() -> Self

pub fn extend(&mut self, other: Self)

Merges changes from another CodebaseDiff into this one.

pub fn get_keep(&self) -> &HashSet<SymbolIdentifier>

Returns a reference to the set of symbols/members to keep unchanged.

pub fn get_changed(&self) -> &HashSet<SymbolIdentifier>

Returns a reference to the set of changed symbols/members.

pub fn get_diff_map(&self) -> &HashMap<FileId, Vec<DiffHunk>>

Returns a reference to the map of source files to text diff hunks.

pub fn get_deletion_ranges_map(&self) -> &HashMap<FileId, Vec<DeletionRange>>

Returns a reference to the map of source files to deletion ranges.

pub fn set_keep(&mut self, keep_set: impl IntoIterator<Item = SymbolIdentifier>)

Sets the ‘keep’ set, replacing the existing one.

pub fn with_keep( self, keep_set: impl IntoIterator<Item = SymbolIdentifier>, ) -> Self

Returns a new instance with the ‘keep’ set replaced.

pub fn add_keep_entry(&mut self, entry: SymbolIdentifier) -> bool

Adds a single entry to the ‘keep’ set. Returns true if the entry was not already present.

pub fn with_added_keep_entry(self, entry: SymbolIdentifier) -> Self

Returns a new instance with the entry added to the ‘keep’ set.

pub fn add_keep_entries( &mut self, entries: impl IntoIterator<Item = SymbolIdentifier>, )

Adds multiple entries to the ‘keep’ set.

pub fn with_added_keep_entries( self, entries: impl IntoIterator<Item = SymbolIdentifier>, ) -> Self

Returns a new instance with multiple entries added to the ‘keep’ set.

pub fn unset_keep(&mut self)

Clears the ‘keep’ set.

pub fn without_keep(self) -> Self

Returns a new instance with an empty ‘keep’ set.

pub fn set_changed( &mut self, change_set: impl IntoIterator<Item = SymbolIdentifier>, )

Sets the ‘changed’ set, replacing the existing one.

pub fn with_changed( self, change_set: impl IntoIterator<Item = SymbolIdentifier>, ) -> Self

Returns a new instance with the ‘changed’ set replaced.

pub fn add_changed_entry(&mut self, entry: SymbolIdentifier) -> bool

Adds a single entry to the ‘changed’ set. Returns true if the entry was not already present.

pub fn contains_changed_entry(&self, entry: &SymbolIdentifier) -> bool

Checks if the ‘changed’ set contains a specific entry.

pub fn with_added_changed_entry(self, entry: SymbolIdentifier) -> Self

Returns a new instance with the entry added to the ‘changed’ set.

pub fn add_changed_entries( &mut self, entries: impl IntoIterator<Item = SymbolIdentifier>, )

Adds multiple entries to the ‘changed’ set.

pub fn with_added_changed_entries( self, entries: impl IntoIterator<Item = SymbolIdentifier>, ) -> Self

Returns a new instance with multiple entries added to the ‘changed’ set.

pub fn unset_changed(&mut self)

Clears the ‘changed’ set.

pub fn without_changed(self) -> Self

Returns a new instance with an empty ‘changed’ set.

pub fn set_diff_map(&mut self, map: HashMap<FileId, Vec<DiffHunk>>)

Sets the diff map, replacing the existing one.

pub fn with_diff_map(self, map: HashMap<FileId, Vec<DiffHunk>>) -> Self

Returns a new instance with the diff map replaced.

pub fn add_diff_map_entry( &mut self, source: FileId, diffs: Vec<DiffHunk>, ) -> Option<Vec<DiffHunk>>

Adds or replaces the diff hunks for a specific source file. Returns previous hunks if any.

pub fn with_added_diff_map_entry( self, source: FileId, diffs: Vec<DiffHunk>, ) -> Self

Returns a new instance with the diff hunks for the source file added or updated.

pub fn add_diffs_for_source( &mut self, source: FileId, diffs: impl IntoIterator<Item = DiffHunk>, )

Extends the diff hunks for a specific source file.

pub fn with_added_diffs_for_source( self, source: FileId, diffs: impl IntoIterator<Item = DiffHunk>, ) -> Self

Returns a new instance with the diff hunks for the source file extended.

pub fn unset_diff_map(&mut self)

Clears the diff map.

pub fn without_diff_map(self) -> Self

Returns a new instance with an empty diff map.

pub fn set_deletion_ranges_map( &mut self, map: HashMap<FileId, Vec<DeletionRange>>, )

Sets the deletion ranges map, replacing the existing one.

pub fn with_deletion_ranges_map( self, map: HashMap<FileId, Vec<DeletionRange>>, ) -> Self

Returns a new instance with the deletion ranges map replaced.

pub fn add_deletion_ranges_entry( &mut self, source: FileId, ranges: Vec<DeletionRange>, ) -> Option<Vec<DeletionRange>>

Adds or replaces the deletion ranges for a specific source file. Returns previous ranges if any.

pub fn with_added_deletion_ranges_entry( self, file: FileId, ranges: Vec<DeletionRange>, ) -> Self

Returns a new instance with the deletion ranges for the source file added or updated.

pub fn add_deletion_ranges_for_source( &mut self, file: FileId, ranges: impl IntoIterator<Item = (usize, usize)>, )

Extends the deletion ranges for a specific source file.

pub fn with_added_deletion_ranges_for_source( self, file: FileId, ranges: impl IntoIterator<Item = (usize, usize)>, ) -> Self

Returns a new instance with the deletion ranges for the source file extended.

pub fn unset_deletion_ranges_map(&mut self)

Clears the deletion ranges map.

pub fn without_deletion_ranges_map(self) -> Self

Returns a new instance with an empty deletion ranges map.

Trait Implementations

impl Clone for CodebaseDiff

fn clone(&self) -> CodebaseDiff

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CodebaseDiff

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

Formats the value using the given formatter.

impl Default for CodebaseDiff

fn default() -> CodebaseDiff

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for CodebaseDiff

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for CodebaseDiff

fn eq(&self, other: &CodebaseDiff) -> 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 Serialize for CodebaseDiff

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for CodebaseDiff