Struct Offsets 

pub struct Offsets<O = Vec<usize>>(/* private fields */);

A collection of offsets into another collection. This newtype is intended to verify basic invariants about offsets into another collection, namely that the collection is monotonically increasing and non-empty.

Implementations

impl<'a> Offsets<&'a [usize]>

pub fn separate_offsets_with_overlap( self, index: usize, ) -> (Offsets<&'a [usize]>, Offsets<&'a [usize]>)

Separate the offsets into two groups overlapping by one chunk at the given index.

impl<O: RemovePrefix + Set> Offsets<O>

pub unsafe fn remove_prefix_unchecked(&mut self, n: usize)

Unchecked version of RemovePrefix::remove_prefix.

Safety

This function may cause undefined behaviour in safe APIs if calling this function produces an empty offsets collection.

impl Offsets<&[usize]>

pub unsafe fn remove_suffix_unchecked(&mut self, n: usize)

Remove n offsets from the end.

Safety

This function may cause undefined behaviour in safe APIs if calling this function produces an empty offsets collection.

impl<O: AsRef<[usize]> + Set> Offsets<O>

pub fn sizes(&self) -> Sizes<'_>

Returns an iterator over chunk sizes represented by the stored Offsets.

pub fn iter(&self) -> impl Iterator<Item = usize> + '_

Returns an iterator over offsets.

pub fn values(&self) -> OffsetValues<'_>

Returns an iterator over offset values.

pub fn ranges(&self) -> Ranges<'_>

Returns an iterator over offset ranges.

impl<O: AsRef<[usize]>> Offsets<O>

pub fn new(offsets: O) -> Self

Construct a set Offsets from a given set of offsets.

Panics

The given offsets must be a non-empty collection, otherwise this function will panic.

pub unsafe fn from_raw(offsets: O) -> Self

An unchecked version of the new constructor.

Safety

Calling this function with empty offsets may cause undefined behaviour in safe APIs.

impl<O> Offsets<O>

pub fn into_inner(self) -> O

impl<O: AsMut<[usize]>> Offsets<O>

pub fn move_back(&mut self, at: usize, by: usize)

Moves an offset back by a specified amount.

This effectively transfers by elements to the specified at chunk from the preceeding chunk.

Panics

This function panics if at is out of bounds.

If at it zero, the beginning of the indexed range is simply extended, but an overflow panic will be caused if the first offset is moved below zero since offsets are represented by unsigned integers.

It is a logic error to move an offset past its preceeding offset because this will break the monotonicity of the offset sequence, which can cause panics from other function on the Offsets.

Example

use flatk::Offsets;
let mut o = Offsets::new(vec![0, 4, 9]);
o.move_back(1, 2);
assert_eq!(o, vec![0, 2, 9].into());

pub fn move_forward(&mut self, at: usize, by: usize)

Moves an offset forward by a specified amount.

This effectively transfers by elements to the specified at chunk from the succeeding chunk.

If at indexes the last offset, then the indexed range is simply increased.

Panics

This function panics if at is out of bounds.

It is a logic error to move an offset past its succeeding offset because this will break the monotonicity of the offset sequence, which can cause panics from other function on the Offsets.

Example

use flatk::Offsets;
let mut o = Offsets::new(vec![0, 4, 9]);
o.move_forward(1, 2);
assert_eq!(o, vec![0, 6, 9].into());

pub fn extend_last(&mut self, by: usize)

Extend the last offset.

This effectively increases the last chunk size. This function is the same as self.move_forward(self.len() - 1, by).

Example

use flatk::Offsets;
let mut o = Offsets::new(vec![0, 4, 9]);
o.extend_last(2);
assert_eq!(o, vec![0, 4, 11].into());

pub fn shrink_last(&mut self, by: usize)

Shrink the last offset.

This effectively decreases the last chunk size. This function is the same as self.move_back(self.len() - 1, by).

Panics

It is a logic error to move an offset past its preceeding offset because this will break the monotonicity of the offset sequence, which can cause panics from other function on the Offsets.

Example

use flatk::Offsets;
let mut o = Offsets::new(vec![0, 4, 9]);
o.shrink_last(2);
assert_eq!(o, vec![0, 4, 7].into());

Trait Implementations

impl<O: AsMut<[usize]>> AsMut<[usize]> for Offsets<O>

fn as_mut(&mut self) -> &mut [usize]

Converts this type into a mutable reference of the (usually inferred) input type.

impl<O: AsRef<[usize]>> AsRef<[usize]> for Offsets<O>

fn as_ref(&self) -> &[usize]

Converts this type into a shared reference of the (usually inferred) input type.

impl<O: AsRef<[usize]>> BinarySearch<usize> for Offsets<O>

fn binary_search(&self, off: &usize) -> Result<usize, usize>

Binary search the offsets for a given offset off.

off is expected to be with respect to the beginning of the range represented by the current offsets. In other words, we are searching for offsets, not raw offset values stored in Offsets.

The semantics of this function are identical to Rust’s std::slice::binary_search.

impl Clear for Offsets

fn clear(&mut self)

Remove all elements from the current set without necessarily deallocating the space previously used.

impl<O: Clone> Clone for Offsets<O>

fn clone(&self) -> Offsets<O>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<O: Debug> Debug for Offsets<O>

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

Formats the value using the given formatter.

impl Default for Offsets<Vec<usize>>

A default set of offsets must allocate.

fn default() -> Self

Returns the “default value” for a type.

impl<O: Dummy> Dummy for Offsets<O>

unsafe fn dummy() -> Self

Constructs a potentially invalid instance of a type.

impl Extend<usize> for Offsets

fn extend<T: IntoIterator<Item = usize>>(&mut self, iter: T)

Extend this set of offsets with a given iterator of offsets.

This operation automatically shifts the merged offsets in the iterator to start from the last offset in self.

Note that there will be 1 less offset added to self than produced by iter since the first offset is only used to determine the relative magnitude of the rest and corresponds to the last offset in self.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<O: AsRef<[usize]> + Set> From<ClumpedOffsets<O>> for Offsets

fn from(clumped_offsets: ClumpedOffsets<O>) -> Self

Convert ClumpedOffsets into owned Offsets.

This function causes allocations.

impl<O: AsRef<[usize]>> From<O> for Offsets<O>

fn from(offsets: O) -> Self

Converts to this type from the input type.

impl<O: AsRef<[usize]> + Set> From<Offsets<O>> for ClumpedOffsets

fn from(offsets: Offsets<O>) -> Self

Convert Offsets to owned ClumpedOffsets.

This function causes allocations.

Example

use flatk::{Offsets, ClumpedOffsets};
let offsets = Offsets::new(vec![0, 3, 6, 9, 12, 16, 20, 24, 27, 30, 33, 36, 39]);
let clumped_offsets = ClumpedOffsets::new(vec![0, 4, 7, 12], vec![0, 12, 24, 39]);
assert_eq!(ClumpedOffsets::from(offsets), clumped_offsets);

impl<O: FromIterator<usize> + AsRef<[usize]>> FromIterator<usize> for Offsets<O>

fn from_iter<T>(iter: T) -> Self

where T: IntoIterator<Item = usize>,

Creates a value from an iterator.

impl<'a, O: Get<'a, usize>> GetIndex<'a, Offsets<O>> for &usize

type Output = <O as Get<'a, usize>>::Output

fn get(self, offsets: &Offsets<O>) -> Option<Self::Output>

Gets the value in the set at this index.

unsafe fn at_unchecked(self, set: &S) -> Self::Output

where Self: Sized,

Gets the value in the set at this index.

impl<'a, O: Get<'a, Range<usize>>> GetIndex<'a, Offsets<O>> for Range<usize>

type Output = Offsets<<O as Get<'a, Range<usize>>>::Output>

fn get(self, offsets: &Offsets<O>) -> Option<Self::Output>

Gets the value in the set at this index.

unsafe fn at_unchecked(self, set: &S) -> Self::Output

where Self: Sized,

Gets the value in the set at this index.

impl<'a, O: Get<'a, usize>> GetIndex<'a, Offsets<O>> for usize

type Output = <O as Get<'a, usize>>::Output

fn get(self, offsets: &Offsets<O>) -> Option<Self::Output>

Gets the value in the set at this index.

unsafe fn at_unchecked(self, set: &S) -> Self::Output

where Self: Sized,

Gets the value in the set at this index.

impl<O: AsRef<[usize]>> GetOffset for Offsets<O>

unsafe fn offset_value_unchecked(&self, index: usize) -> usize

A version of offset_value without bounds checking.

Safety

It is assumed that index is strictly less than self.num_offsets().

fn num_offsets(&self) -> usize

Get the total number of offsets.

This is one more than the number of chunks represented.

fn chunk_len(&self, chunk_index: usize) -> usize

Get the length of the chunk at the given index.

unsafe fn chunk_len_unchecked(&self, chunk_index: usize) -> usize

Get the length of the chunk at the given index without bounds checking.

fn offset_value(&self, index: usize) -> usize

Return the raw value corresponding to the offset at the given index.

fn offset(&self, index: usize) -> usize

Returns the offset at the given index with respect to (minus) the first offset. This function returns the total length of data if index is equal to self.len().

unsafe fn offset_unchecked(&self, index: usize) -> usize

A version of offset without bounds checking.

fn last_offset(&self) -> usize

Get the last offset.

fn first_offset(&self) -> usize

Get the first offset.

fn last_offset_value(&self) -> usize

Get the raw value corresponding to the last offset.

fn first_offset_value(&self) -> usize

Get the raw value corresponding to the first offset.

impl<I: SliceIndex<[usize]>, O: AsRef<[usize]>> Index<I> for Offsets<O>

type Output = <I as SliceIndex<[usize]>>::Output

The returned type after indexing.

fn index(&self, index: I) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<I: SliceIndex<[usize]>, O: AsRef<[usize]> + AsMut<[usize]>> IndexMut<I> for Offsets<O>

fn index_mut(&mut self, index: I) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<O: AsRef<[usize]> + Set> IndexRange for Offsets<O>

fn index_range(&self, range: Range<usize>) -> Option<Range<usize>>

Return the [begin..end) bound of the chunk at the given index.

unsafe fn index_range_unchecked(&self, range: Range<usize>) -> Range<usize>

Safety

impl<'a> IntoOffsetValuesAndSizes for Offsets<&'a [usize]>

fn into_offset_values_and_sizes(self) -> OffsetValuesAndSizes<'a>

Returns an iterator over offset value and chunk size pairs.

type Iter = OffsetValuesAndSizes<'a>

impl<O: IntoOwned> IntoOwned for Offsets<O>

type Owned = Offsets<<O as IntoOwned>::Owned>

fn into_owned(self) -> Self::Owned

fn clone_into(self, target: &mut Self::Owned)

impl<'a> IntoParOffsetValuesAndSizes for Offsets<&'a [usize]>

fn into_par_offset_values_and_sizes(self) -> Self::ParIter

Returns a parallel iterator over chunk sizes represented by the stored Offsets.

type ParIter = ParOffsetValuesAndSizes<'a>

impl<'a> IntoRanges for Offsets<&'a [usize]>

fn into_ranges(self) -> Ranges<'a>

Returns an iterator over offset ranges represented by the stored Offsets.

type Iter = Ranges<'a>

impl<'a> IntoSizes for Offsets<&'a [usize]>

fn into_sizes(self) -> Sizes<'a>

Returns an iterator over chunk sizes represented by the stored Offsets.

type Iter = Sizes<'a>

impl<'a> IntoValues for Offsets<&'a [usize]>

fn into_values(self) -> OffsetValues<'a>

Returns an iterator over offset values represented by the stored Offsets.

type Iter = OffsetValues<'a>

impl<O: Isolate<Range<usize>>> IsolateIndex<Offsets<O>> for Range<usize>

type Output = Offsets<<O as Isolate<Range<usize>>>::Output>

unsafe fn isolate_unchecked(self, offsets: Offsets<O>) -> Self::Output

Attempts to isolate a value in the given set at this index.

fn try_isolate(self, offsets: Offsets<O>) -> Option<Self::Output>

Attempts to isolate a value in the given set at this index.

impl<O: Isolate<usize>> IsolateIndex<Offsets<O>> for usize

type Output = <O as Isolate<usize>>::Output

unsafe fn isolate_unchecked(self, offsets: Offsets<O>) -> Self::Output

Attempts to isolate a value in the given set at this index.

fn try_isolate(self, offsets: Offsets<O>) -> Option<Self::Output>

Attempts to isolate a value in the given set at this index.

impl<O: PartialEq> PartialEq for Offsets<O>

fn eq(&self, other: &Offsets<O>) -> 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<O: Push<usize>> Push<usize> for Offsets<O>

fn push(&mut self, item: usize)

impl<O: RemovePrefix + Set> RemovePrefix for Offsets<O>

fn remove_prefix(&mut self, n: usize)

Remove the first n offsets.

Panics

This function will panic if all offsets are removed, which violates the Offsets invariant that there must always be at least one offset.

impl<O: Reserve> Reserve for Offsets<O>

fn reserve_with_storage(&mut self, n: usize, storage_n: usize)

fn reserve(&mut self, n: usize)

impl<O: Set<Elem = usize, Atom = usize>> Set for Offsets<O>

type Elem = usize

Owned element of the set.

type Atom = usize

The most basic element contained by this collection. If this collection contains other collections, this type should be different than Elem.

fn len(&self) -> usize

fn is_empty(&self) -> bool

impl<'a> SplitOffsetsAt for Offsets<&'a [usize]>

fn split_offsets_with_intersection_at( self, mid: usize, ) -> (Offsets<&'a [usize]>, Offsets<&'a [usize]>, usize)

Same as split_offsets_at, but in addition, return the offset of the middle element (intersection): this is the value offsets[mid] - offsets[0].

Panics

Calling this function with an empty slice or with mid greater than or equal to its length will cause a panic.

fn split_offsets_at( self, mid: usize, ) -> (Offsets<&'a [usize]>, Offsets<&'a [usize]>)

Splits a slice of offsets at the given index into two slices such that each slice is a valid slice of offsets. This means that the element at index mid is shared between the two output slices.

Panics

Calling this function with an empty slice or with mid greater than or equal to its length will cause a panic.

impl<O: Truncate> Truncate for Offsets<O>

fn truncate(&mut self, new_len: usize)

impl<'a, O: AsRef<[usize]>> View<'a> for Offsets<O>

type Type = Offsets<&'a [usize]>

fn view(&'a self) -> Self::Type

impl<'a, O: AsMut<[usize]>> ViewMut<'a> for Offsets<O>

type Type = Offsets<&'a mut [usize]>

fn view_mut(&'a mut self) -> Self::Type

impl<O: Copy> Copy for Offsets<O>

impl<O> StructuralPartialEq for Offsets<O>

impl<O: Viewed> Viewed for Offsets<O>