Struct Diff 

pub struct Diff {
    pub added: Vec<Component>,
    pub removed: Vec<Component>,
    pub changed: Vec<ComponentChange>,
    pub edge_diffs: Vec<EdgeDiff>,
    pub metadata_changed: Option<MetadataChange>,
    pub old_total: usize,
    pub new_total: usize,
    pub unchanged: usize,
    pub component_names: BTreeMap<ComponentId, String>,
}

the result of comparing two SBOMs.

contains lists of added, removed, and changed components, as well as dependency edge changes.

Fields

added: Vec<Component>

components present in the new SBOM but not the old.

removed: Vec<Component>

components present in the old SBOM but not the new.

changed: Vec<ComponentChange>

components present in both with field-level changes.

edge_diffs: Vec<EdgeDiff>

dependency edge changes between components.

metadata_changed: Option<MetadataChange>

structured metadata change details, or None if metadata is unchanged.

old_total: usize

total number of components in the old SBOM.

new_total: usize

total number of components in the new SBOM.

unchanged: usize

number of components present in both SBOMs with no changes.

component_names: BTreeMap<ComponentId, String>

human-readable display names for component IDs that appear in edge diffs.

maps hash-based IDs (h:...) to name@version or name so that edge diff output is readable without cross-referencing the full component list.

Implementations

impl Diff

pub fn is_empty(&self) -> bool

returns true if the diff contains no changes of any kind.

pub fn display_name<'a>(&'a self, id: &'a ComponentId) -> &'a str

returns a human-readable display name for a component ID.

looks up the ID in component_names; falls back to the raw ID string.

pub fn ecosystem_breakdown(&self) -> BTreeMap<String, EcosystemCounts>

groups added/removed/changed counts by package ecosystem.

components without an ecosystem are grouped under "unknown".

pub fn group_by_ecosystem(&self) -> GroupedDiff

groups the full diff by ecosystem, returning per-ecosystem slices.

components without an ecosystem are grouped under "unknown". this clones components out of the diff; use into_group_by_ecosystem to move them instead when you own the diff.

pub fn into_group_by_ecosystem(self) -> GroupedDiff

consuming variant of group_by_ecosystem that moves components instead of cloning them.

pub fn filter_by_ecosystem<F: Fn(Option<&str>) -> bool>( &mut self, matches: &F, filtered_old_total: usize, filtered_new_total: usize, component_ecosystems: &BTreeMap<ComponentId, Option<String>>, )

filters the diff to only include components whose ecosystem matches the given predicate. Adjusts old_total, new_total, and unchanged to reflect the filtered view.

filtered_old_total and filtered_new_total are the pre-counted number of components in each SBOM that pass the predicate. These must be computed before Differ::diff_owned consumes the SBOMs.

component_ecosystems maps component IDs to their ecosystem, built from both SBOMs before they are consumed. This is used to filter edge diffs by the parent component’s ecosystem.

Trait Implementations

impl Clone for Diff

fn clone(&self) -> Diff

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Diff

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

Formats the value using the given formatter.

impl Default for Diff

fn default() -> Diff

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Diff

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Diff

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

where __S: Serializer,

Serialize this value into the given Serde serializer.