Struct Ranges

pub struct Ranges(/* private fields */);

Implementations

impl Ranges

pub fn new(limit: usize) -> Self

pub fn insert_packet_number_range( &mut self, pn_range: PacketNumberRange, ) -> Result<(), Error>

Inserts a packet number; dropping smaller values if needed

pub fn insert_packet_number( &mut self, packet_number: PacketNumber, ) -> Result<(), Error>

Inserts a packet number; dropping smaller values if needed

pub fn spread(&self) -> usize

Returns the overall range of the ack_ranges

Methods from Deref<Target = IntervalSet<PacketNumber>>

pub fn set_limit(&mut self, limit: NonZeroUsize)

Sets an element limit for the given IntervalSet. The number of elements in the set cannot exceed this amount, otherwise insert calls will be rejected

Note: calling this will not drop existing intervals that exceed the new limit and will only be applied to later calls to insert.

Examples

use core::num::NonZeroUsize;
let mut set = IntervalSet::new();
assert!(set.insert(0..4).is_ok());
set.set_limit(NonZeroUsize::new(1).unwrap());
assert!(set.insert(4..8).is_ok());
assert!(set.insert(12..16).is_err());

pub fn remove_limit(&mut self)

Removes the element limit for the given IntervalSet.

Examples

use core::num::NonZeroUsize;
let mut set = IntervalSet::with_limit(NonZeroUsize::new(1).unwrap());
assert!(set.insert(0..4).is_ok());
assert!(set.insert(4..8).is_ok());
assert!(set.insert(12..16).is_err());
set.remove_limit();
assert!(set.insert(12..16).is_ok());

pub fn interval_len(&self) -> usize

Returns the number of intervals in IntervalSet.

Examples

let mut set = IntervalSet::new();
assert_eq!(set.interval_len(), 0);
assert!(set.insert(0..4).is_ok());
assert_eq!(set.interval_len(), 1);

pub fn capacity(&self) -> usize

Returns the allocated capacity of the IntervalSet.

Examples

let mut set = IntervalSet::with_capacity(1);
assert_eq!(set.capacity(), 1);
assert!(set.insert(0..4).is_ok());
assert!(set.insert(6..10).is_ok());
assert!(set.capacity() > 1);

pub fn clear(&mut self)

Clears all elements contained in the IntervalSet.

Examples

let mut set = IntervalSet::new();
assert!(set.insert(0..4).is_ok());
set.clear();
assert!(set.is_empty());

pub fn pop_min(&mut self) -> Option<Interval<T>>

Removes the lowest Interval in the set, if any

Examples

let mut set = IntervalSet::new();
assert_eq!(set.pop_min(), None);
assert!(set.insert(0..4).is_ok());
assert_eq!(set.pop_min(), Some((0..4).into()));

pub fn count(&self) -> usize

Returns the number of elements in IntervalSet.

Examples

let mut set = IntervalSet::new();
assert_eq!(set.count(), 0);
assert!(set.insert(0..4).is_ok());
assert_eq!(set.count(), 4);

pub fn is_empty(&self) -> bool

Returns true if the IntervalSet has no intervals.

Examples

let mut set = IntervalSet::new();
assert!(set.is_empty());
assert!(set.insert(0..4).is_ok());
assert!(!set.is_empty());

pub fn insert<R: RangeBounds<T>>( &mut self, interval: R, ) -> Result<(), IntervalSetError>

Inserts the supplied interval into the IntervalSet

Examples

let mut set = IntervalSet::new();
assert!(set.insert(0..4).is_ok());
assert!(set.contains(&3));
assert!(!set.contains(&5));

pub fn insert_front<R: RangeBounds<T>>( &mut self, interval: R, ) -> Result<(), IntervalSetError>

Inserts the supplied interval at the beginning of the IntervalSet. This method can be used to optimize insertion when the interval is less than all of the current intervals.

Examples

let mut set = IntervalSet::new();
assert!(set.insert_front(0..4).is_ok());
assert!(set.contains(&3));
assert!(!set.contains(&5));

pub fn insert_value(&mut self, value: T) -> Result<(), IntervalSetError>

Inserts a single value into the IntervalSet

Examples

let mut set = IntervalSet::new();
assert!(set.insert_value(1).is_ok());
assert!(set.contains(&1));
assert!(!set.contains(&0));
assert!(!set.contains(&2));

pub fn union(&mut self, other: &Self) -> Result<(), IntervalSetError>

Performs a union, i.e., all the values in self or other will be present in self

Examples

let mut a = IntervalSet::new();
assert!(a.insert(0..4).is_ok());
let mut b = IntervalSet::new();
assert!(b.insert(4..8).is_ok());
a.union(&b);
assert_eq!(a.iter().collect::<Vec<_>>(), (0..8).collect::<Vec<_>>());

pub fn remove<R: RangeBounds<T>>( &mut self, interval: R, ) -> Result<(), IntervalSetError>

Removes the supplied interval from the IntervalSet

Examples

let mut set = IntervalSet::new();
assert!(set.insert(1..3).is_ok());
assert!(set.remove(0..4).is_ok());
assert!(set.is_empty());

pub fn remove_value(&mut self, value: T) -> Result<(), IntervalSetError>

Removes a single value from the IntervalSet

Examples

let mut set = IntervalSet::new();
assert!(set.insert_value(1).is_ok());
assert!(set.remove_value(1).is_ok());
assert!(!set.contains(&1));

pub fn difference(&mut self, other: &Self) -> Result<(), IntervalSetError>

Performs a difference, i.e., all the values that are in self but not in other will be present in self.

Examples

let mut set_a = IntervalSet::new();
assert!(set_a.insert(0..=10).is_ok());
let mut set_b = IntervalSet::new();
assert!(set_b.insert(4..=8).is_ok());
assert!(set_a.difference(&set_b).is_ok());
assert_eq!(set_a.iter().collect::<Vec<_>>(), vec![0, 1, 2, 3, 9, 10]);

pub fn intersection(&mut self, other: &Self) -> Result<(), IntervalSetError>

Performs an intersection, i.e., all the values in both self and other will be present in self.

Examples

let mut set_a = IntervalSet::new();
assert!(set_a.insert(0..=10).is_ok());
let mut set_b = IntervalSet::new();
assert!(set_b.insert(4..=8).is_ok());
assert!(set_a.intersection(&set_b).is_ok());
assert_eq!(set_a.iter().collect::<Vec<_>>(), vec![4, 5, 6, 7, 8]);

pub fn intersection_iter<'a>(&'a self, other: &'a Self) -> Intersection<'a, T>

Returns an iterator of Intervals over the intersection, i.e., all the values in both self and other will be returned.

Examples

let mut set_a = IntervalSet::new();
assert!(set_a.insert(0..=10).is_ok());
let mut set_b = IntervalSet::new();
assert!(set_b.insert(4..=8).is_ok());
let intersection = set_a.intersection_iter(&set_b).flatten();
assert_eq!(intersection.collect::<Vec<_>>(), vec![4, 5, 6, 7, 8]);

pub fn iter(&self) -> Iter<'_, T>

Returns an iterator over all of the values contained in the given IntervalSet.

Examples

let mut set = IntervalSet::new();
assert!(set.insert(0..5).is_ok());
assert!(set.insert(10..15).is_ok());
let items: Vec<_> = set.iter().collect();
assert_eq!(vec![0, 1, 2, 3, 4, 10, 11, 12, 13, 14], items);

pub fn min_value(&self) -> Option<T>

Returns the smallest value in the given IntervalSet. If no items are present in the set, None is returned.

Examples

let mut set = IntervalSet::new();
assert_eq!(set.min_value(), None);
assert!(set.insert(0..5).is_ok());
assert_eq!(set.min_value(), Some(0));

pub fn max_value(&self) -> Option<T>

Returns the largest value in the given IntervalSet. If no items are present in the set, None is returned.

Examples

let mut set = IntervalSet::new();
assert_eq!(set.max_value(), None);
assert!(set.insert(0..5).is_ok());
assert_eq!(set.max_value(), Some(4));

pub fn contains(&self, value: &T) -> bool

Returns true if the set contains a value

Examples

let mut set = IntervalSet::new();
assert_eq!(set.contains(&1), false);
assert!(set.insert(0..5).is_ok());
assert_eq!(set.contains(&1), true);

pub fn intervals(&self) -> IntervalIter<'_, T>

Returns an iterator of Intervals contained in the IntervalSet

Examples

let mut set = IntervalSet::new();
set.insert(0..=10);
assert_eq!(set.intervals().collect::<Vec<_>>(), vec![0..=10]);

pub fn ranges(&self) -> RangeIter<'_, T>

Returns an iterator of Ranges contained in the IntervalSet

Examples

let mut set = IntervalSet::new();
set.insert(0..=10);
assert_eq!(set.ranges().collect::<Vec<_>>(), vec![0..11]);

pub fn inclusive_ranges(&self) -> RangeInclusiveIter<'_, T>

Returns an iterator of RangeInclusives contained in the IntervalSet

Examples

let mut set = IntervalSet::new();
set.insert(0..=10);
assert_eq!(set.inclusive_ranges().collect::<Vec<_>>(), vec![0..=10]);

Trait Implementations

impl<'a> AckRanges for &'a Ranges

type Iter = Map<Rev<RangeInclusiveIter<'a, PacketNumber>>, fn(RangeInclusive<PacketNumber>) -> RangeInclusive<VarInt>>

fn ack_ranges(&self) -> Self::Iter

fn largest_acknowledged(&self) -> VarInt

impl Clone for Ranges

fn clone(&self) -> Ranges

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Ranges

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

Formats the value using the given formatter.

impl Default for Ranges

fn default() -> Self

Returns the “default value” for a type.

impl Deref for Ranges

type Target = IntervalSet<PacketNumber>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl DerefMut for Ranges

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.