Struct Capped 

pub struct Capped<T> { /* private fields */ }

A list that may have been truncated when it was produced, paired with the true count of items that existed at the source.

Exists so a truncated list can never be silently read as complete: items are only reachable through Capped::items and the real count only through Capped::total, so items().len() is never mistaken for “everything there is”. Both OSV lists capped at crate::osv::ADVISORY_DISPLAY_CAP use it — DependencyVulnerabilities::advisories and UpgradeStatus::CandidateVulnerable.

Examples

use deps_core::osv::Capped;

let truncated = Capped::new(vec!["A1".to_string(), "A2".to_string()], 5);
assert_eq!(truncated.items().len(), 2);
assert_eq!(truncated.total(), 5);
assert!(!truncated.is_complete());
assert_eq!(truncated.remaining(), 3);

let complete = Capped::new(vec!["A1".to_string()], 1);
assert!(complete.is_complete());
assert_eq!(complete.remaining(), 0);

Implementations

impl<T> Capped<T>

pub fn new(items: Vec<T>, total: usize) -> Self

Pairs an already-truncated items list with the total the source reported, which may exceed items.len().

pub fn items(&self) -> &[T]

The items actually retained — not necessarily all Self::total of them.

pub const fn total(&self) -> usize

The count the source reported, independent of how many items were retained.

pub fn is_complete(&self) -> bool

Whether Self::items holds everything the source reported.

pub fn remaining(&self) -> usize

How many items were dropped — the render layer’s “+N more” count.

Trait Implementations

impl<T: Clone> Clone for Capped<T>

fn clone(&self) -> Capped<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Capped<T>

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

Formats the value using the given formatter.

impl<T: Eq> Eq for Capped<T>

impl<T: PartialEq> PartialEq for Capped<T>

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