[−][src]Struct indexing::container::Container

pub struct Container<'id, Array, Mode = ()> { /* fields omitted */ }

A branded container, that allows access only to indices and ranges with the exact same brand in the 'id parameter.

The elements in the underlying data structure are accessible partly through special purpose methods, and through indexing/slicing.

The Container can be indexed like self[i] where i is a trusted dereferenceable index or range, and equivalently using &self[i..] or &self[..i] where i is a trusted index. Indexing like this uses no runtime bounds checking at all, and it statically guaranteed to be in bounds.

The container can also be sliced for its complete range: &self[..].

Methods

`impl<'id, Array, T, Mode> Container<'id, Array, Mode> where Array: Trustworthy<Item = T>,` [src]

`pub fn len(&self) -> usize`[src]

`pub fn only_index(self) -> Container<'id, Array, OnlyIndex>`[src]

Convert the container into an only-indexing container.

The container no longer allows pointer access. This unlocks some features.

`pub fn empty_range(&self) -> Range<'id>`[src]

Return the range [0, 0)

`pub fn range(&self) -> Range<'id>`[src]

Return the full range of the Container.

`pub fn vet(&self, index: usize) -> Result<Index<'id>, IndexingError>`[src]

Vet the absolute index.

`pub fn vet_range(&self, r: Range<usize>) -> Result<Range<'id>, IndexingError>`[src]

Vet the range r.

`pub fn split_at(&self, index: Index<'id, P>) -> (Range<'id>, Range<'id, P>)`[src]

`pub fn split_after( &self, index: Index<'id> ) -> (Range<'id, NonEmpty>, Range<'id>)`[src]

Split in two ranges, where the first includes the index and the second starts with the following index.

`pub fn split_around(&self, r: Range<'id, P>) -> (Range<'id>, Range<'id>)`[src]

Split around the Range r: Return ranges corresponding to 0..r.start and r.end...

So that input r and return values (s, t) cover the whole container in the order s, r, t.

`pub fn before(&self, index: Index<'id, P>) -> Range<'id>`[src]

Return the range before (not including) the index itself

`pub fn after(&self, index: Index<'id>) -> Range<'id>`[src]

Return the range after (not including) the index itself

`pub fn range_of<P, R>(&self, r: R) -> Range<'id> where R: OnePointRange<Index<'id, P>>,` [src]

`pub fn forward(&self, index: &mut Index<'id>) -> bool`[src]

Increment index, if doing so would still be in bounds.

Return true if the index was incremented.

`pub fn forward_by(&self, index: &mut Index<'id>, offset: usize) -> bool`[src]

Increment index, if doing so would still be in bounds.

Return true if the index was incremented.

`pub fn forward_range_by(&self, r: Range<'id, P>, offset: usize) -> Range<'id>`[src]

Increment r, clamping to the end of the Container.

`pub fn backward(&self, index: &mut Index<'id>) -> bool`[src]

Decrement index, if doing so would still be in bounds.

Return true if the index was decremented.

`pub fn scan_from<'b, F>( &'b self, index: Index<'id>, f: F ) -> Range<'id, NonEmpty> where F: FnMut(&'b T) -> bool, T: 'b, Array: Contiguous<Item = T>,` [src]

Examine the elements after index in order from lower indices towards higher. While the closure returns true, continue scan and include the scanned element in the range.

Result always includes index in the range

`pub fn scan_from_rev<'b, F>( &'b self, index: Index<'id>, f: F ) -> Range<'id, NonEmpty> where F: FnMut(&'b T) -> bool, T: 'b, Array: Contiguous<Item = T>,` [src]

Examine the elements before index in order from higher indices towards lower. While the closure returns true, continue scan and include the scanned element in the range.

Result always includes index in the range.

`pub fn scan_range<'b, F, P>( &'b self, range: Range<'id, P>, f: F ) -> (Range<'id>, Range<'id>) where F: FnMut(&'b T) -> bool, T: 'b, Array: Contiguous<Item = T>,` [src]

Examine the elements range in order from lower indices towards higher. While the closure returns true, continue scan and include the scanned element in the range.

`pub fn swap(&mut self, i: Index<'id>, j: Index<'id>) where Array: GetUncheckedMut,` [src]

Swap elements at i and j (they may be equal).

`pub fn rotate1_up<R>(&mut self, r: R) where Array: Contiguous + GetUncheckedMut, R: IntoCheckedRange<'id>,` [src]

Rotate elements in the range r by one step to the right (towards higher indices)

`pub fn rotate1_down<R>(&mut self, r: R) where Array: Contiguous + GetUncheckedMut, R: IntoCheckedRange<'id>,` [src]

Rotate elements in the range r by one step to the left (towards lower indices)

`pub fn index_twice<P, Q>( &mut self, r: Range<'id, P>, s: Range<'id, Q> ) -> Result<(&mut [T], &mut [T]), IndexingError> where Array: ContiguousMut,` [src]

Index by two nonoverlapping ranges, where r is before s.

`pub fn zip_mut_raw<P, Q, F>(&mut self, r: Range<'id, P>, s: Range<'id, Q>, f: F) where F: FnMut(mut T, mut T), Array: GetUncheckedMut,` [src]

Zip by raw pointer (will be indentical if ranges have same starting point)

`impl<'id, Array, T> Container<'id, Array, OnlyIndex> where Array: Pushable<Item = T>,` [src]

Methods specific to only index mode

`pub fn push(&mut self, element: T) -> Index<'id>`[src]

Add one element to the underlying storage, and return its index.

All outstanding indices remain valid, only the length of the container is now larger.

`pub fn insert<Q>(&mut self, index: Index<'id, Q>, element: T)`[src]

Insert one element in the underlying storage at index.

All outstanding indices remain valid (in bounds), but elements have shifted.

`impl<'id, Array, T, Mode> Container<'id, Array, Mode> where Array: Trustworthy<Item = T> + FixedLength,` [src]

`pub fn make_twin<Array2>( &self, arr: Array2 ) -> Result<Container<'id, Array2, OnlyIndex>, IndexingError> where Array2: Trustworthy + FixedLength,` [src]

Create a twin Container, that admits the same branded indices as self

Checks the compatibilty (length) of both arrays and returns the twin container if it is admissible.

The twin container is OnlyIndex-marked, because only indices/index ranges transfer between twins, and branded raw pointers of course not.

Trait Implementations

`impl<'id, Array, Mode> Clone for Container<'id, Array, Mode> where Array: Clone + FixedLength,` [src]

A container can be cloned if the inner array can (typically a shared slice).

But containers of vectors can not be cloned:

use indexing::scope;
scope(vec![0; 10], |v| {
    let _u = v.clone();
});

`fn clone(&self) -> Self`[src]