Struct DagStats 

pub struct DagStats {
    pub unique_cids: usize,
    pub total_links: usize,
    pub max_depth: usize,
    pub leaf_count: usize,
    pub intermediate_count: usize,
}

Statistics about a DAG structure

Fields

unique_cids: usize

Total number of unique CIDs in the DAG

total_links: usize

Total number of links (including duplicates)

max_depth: usize

Maximum depth of the DAG

leaf_count: usize

Number of leaf nodes (nodes with no outgoing links)

intermediate_count: usize

Number of intermediate nodes (nodes with outgoing links)

Implementations

impl DagStats

pub fn new() -> Self

Create empty DAG statistics

pub fn from_ipld(ipld: &Ipld) -> Self

Calculate statistics for an IPLD structure

Note: This only analyzes the structure of the IPLD data provided, it does not follow CID links to fetch additional blocks.

Arguments

• ipld - The IPLD data to analyze

Returns

Statistics about the DAG structure

Examples

use ipfrs_core::{Ipld, CidBuilder};
use ipfrs_core::dag::DagStats;
use std::collections::BTreeMap;

let cid = CidBuilder::new().build(b"data").unwrap();
let mut map = BTreeMap::new();
map.insert("link".to_string(), Ipld::link(cid));
let ipld = Ipld::Map(map);

let stats = DagStats::from_ipld(&ipld);
assert_eq!(stats.total_links, 1);
assert_eq!(stats.unique_cids, 1);

pub fn deduplication_ratio(&self) -> f64

Calculate the deduplication ratio

Returns the ratio of duplicate links to total links. A value of 0.0 means no duplication, 1.0 means all links are duplicates.

Trait Implementations

impl Clone for DagStats

fn clone(&self) -> DagStats

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DagStats

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

Formats the value using the given formatter.

impl Default for DagStats

fn default() -> DagStats

Returns the “default value” for a type.

impl Eq for DagStats

impl PartialEq for DagStats

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