Struct iroh_blobs::protocol::RangeSpecSeq

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

A chunk range specification for a sequence of blobs.

To select chunks in a sequence of blobs this is encoded as a sequence of (blob_offset, range_spec) tuples. Offsets are interpreted in an accumulating fashion.

Example:

Suppose two RangeSpecs range_a and range_b.

• [(0, range_a), (2, empty), (3, range_b), (1, empty)] encodes:
  • Select range_a for children in the range [0, 2)
  • do no selection (empty) for children in the range [2, 2+3) = [2, 5) (3 children)
  • Select range_b for children in the range [5, 5+1) = [5, 6) (1 children)
  • do no selection (empty) for children in the open range [6, inf)

Another way to understand this is that offsets represent the number of times the previous range appears.

Other examples:

• Select range_a from all blobs after the 5th one in the sequence: [(5, range_a)].

• Select range_a from all blobs in the sequence: [(0, range_a)].

• Select range_a from blob 1234: [(1234, range_a), (1, empty)].

• Select nothing: [].

This is a smallvec so that we can avoid allocations in the common case of a single child range.

Implementations

impl RangeSpecSeq

pub const fn empty() -> Self

A RangeSpecSeq containing no chunks from any blobs in the sequence.

RangeSpecSeq::iter, will return an empty range forever.

pub fn as_single(&self) -> Option<(u64, &RangeSpec)>

If this range seq describes a range for a single item, returns the offset and range spec for that item

pub fn all() -> Self

A RangeSpecSeq containing all chunks from all blobs.

RangeSpecSeq::iter, will return a full range forever.

pub fn from_ranges( ranges: impl IntoIterator<Item = impl AsRef<ChunkRangesRef>> ) -> Self

Convenience function to create a RangeSpecSeq from a finite sequence of range sets.

pub fn from_ranges_infinite( ranges: impl IntoIterator<Item = impl AsRef<ChunkRangesRef>> ) -> Self

Convenience function to create a RangeSpecSeq from a sequence of range sets.

Compared to RangeSpecSeq::from_ranges, this will not add an empty range spec at the end, so the final range spec will repeat forever.

pub fn new(children: impl IntoIterator<Item = RangeSpec>) -> Self

Creates a new range spec sequence from a sequence of range specs.

This will merge adjacent range specs with the same value and thus make sure that the resulting sequence is as compact as possible.

pub fn iter(&self) -> RequestRangeSpecIter<'_>

An infinite iterator of range specs for blobs in the sequence.

Each item yielded by the iterator is the RangeSpec for a blob in the sequence. Thus the first call to .next() returns the range spec for the first blob, the next call returns the range spec of the second blob, etc.

pub fn iter_non_empty(&self) -> NonEmptyRequestRangeSpecIter<'_>

An iterator over blobs in the sequence with a non-empty range spec.

This iterator will only yield items for blobs which have at least one chunk selected.

This iterator is infinite if the RangeSpecSeq ends on a non-empty RangeSpec, that is all further blobs have selected chunks spans.

Trait Implementations

impl Clone for RangeSpecSeq

fn clone(&self) -> RangeSpecSeq

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for RangeSpecSeq

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for RangeSpecSeq

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Hash for RangeSpecSeq

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for RangeSpecSeq

fn eq(&self, other: &RangeSpecSeq) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for RangeSpecSeq

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for RangeSpecSeq

impl StructuralPartialEq for RangeSpecSeq