Struct OffsetVec

pub struct OffsetVec<V: VecLike> { /* private fields */ }

Packer for Vec and String etc

For all methods index add a offset

Create from Offset::offset or create

Examples

use offset_vec::Offset;

let mut vec = vec![0, 1, 2, 3, 4];
let mut vec1 = vec.offset_mut(2);

assert_eq!(vec1, [2, 3, 4]);
assert_eq!(vec1[1], 3);

vec1[1] += 2;
assert_eq!(vec, [0, 1, 2, 5, 4]);

Implementations

impl<V: VecLike> OffsetVec<V>

pub fn origin_vec(&self) -> &V

pub fn origin_vec_mut(&mut self) -> &mut V

pub fn into_origin_vec(self) -> V

pub fn as_slice(&self) -> &V::Slice

pub fn as_mut_slice(&mut self) -> &mut V::Slice

pub fn iter<'a>(&'a self) -> <&'a V::Slice as IntoIterator>::IntoIter

where &'a V::Slice: IntoIterator,

pub fn iter_mut<'a>(&'a mut self) -> <&'a V::Slice as IntoIterator>::IntoIter

where &'a V::Slice: IntoIterator,

pub fn is_empty(&self) -> bool

pub fn len(&self) -> usize

pub fn capacity(&self) -> usize

pub fn reserve(&mut self, additional: usize)

pub fn reserve_exact(&mut self, additional: usize)

pub fn shrink_to_fit(&mut self)

pub fn shrink_to(&mut self, min_capacity: usize)

pub fn origin_offset(&self) -> usize

pub fn push(&mut self, value: V::Elem)

pub fn pop(&mut self) -> Option<V::Elem>

pub fn remove(&mut self, index: usize) -> V::Elem

pub fn insert(&mut self, index: usize, elem: V::Elem)

pub fn truncate(&mut self, len: usize)

pub fn append(&mut self, other: &mut V::Collection)

pub fn clear(&mut self)

pub fn drain<R: RangeBounds<usize>>(&mut self, range: R) -> V::Drain<'_>

pub fn split_off(&mut self, at: usize) -> V::Collection

pub fn resize(&mut self, new_len: usize, value: V::Elem)

where V::Elem: Clone,

pub fn resize_with<F>(&mut self, new_len: usize, f: F)

where F: FnMut() -> V::Elem,

pub fn retain<F>(&mut self, f: F)

where F: FnMut(V::ElemRef<'_>) -> bool,

impl<V: VecLikeSolid> OffsetVec<V>

pub fn retain_mut<F: FnMut(&mut V::Elem) -> bool>(&mut self, f: F)

pub fn swap_remove(&mut self, index: usize) -> V::Elem

pub fn pop_if<F>(&mut self, predicate: F) -> Option<V::Elem>

where F: FnOnce(&mut V::Elem) -> bool,

impl<V: VecLike<Slice = str>> OffsetVec<V>

pub fn as_str(&self) -> &str

pub fn as_mut_str(&mut self) -> &mut str

pub fn push_str<'a>(&mut self, s: &'a str)

where V::Collection: Extend<&'a str>,

Trait Implementations

impl<V: VecLike> AsMut<<V as VecLike>::Slice> for OffsetVec<V>

fn as_mut(&mut self) -> &mut V::Slice

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

impl<V: VecLike> AsRef<<V as VecLike>::Slice> for OffsetVec<V>

fn as_ref(&self) -> &V::Slice

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

impl<T, V: VecLike<Slice = [T]>> Borrow<[T]> for OffsetVec<V>

fn borrow(&self) -> &V::Slice

Immutably borrows from an owned value.

impl<V: VecLike<Slice = str>> Borrow<str> for OffsetVec<V>

fn borrow(&self) -> &V::Slice

Immutably borrows from an owned value.

impl<T, V: VecLike<Slice = [T]>> BorrowMut<[T]> for OffsetVec<V>

fn borrow_mut(&mut self) -> &mut V::Slice

Mutably borrows from an owned value.

impl<V: VecLike<Slice = str>> BorrowMut<str> for OffsetVec<V>

fn borrow_mut(&mut self) -> &mut V::Slice

Mutably borrows from an owned value.

impl<V: Clone + VecLike> Clone for OffsetVec<V>

fn clone(&self) -> OffsetVec<V>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<V: Debug + VecLike> Debug for OffsetVec<V>

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

Formats the value using the given formatter.

impl<V: Default + VecLike> Default for OffsetVec<V>

fn default() -> OffsetVec<V>

Returns the “default value” for a type.

impl<V: VecLike> Deref for OffsetVec<V>

type Target = <V as VecLike>::Slice

The resulting type after dereferencing.

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

Dereferences the value.

impl<V: VecLike> DerefMut for OffsetVec<V>

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

Mutably dereferences the value.

impl<T, V: VecLike> Extend<T> for OffsetVec<V>

where V::Collection: Extend<T>,

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

Extends a collection with the contents of an iterator.

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<V: VecLike> From<V> for OffsetVec<V>

fn from(value: V) -> Self

Converts to this type from the input type.

impl<V: VecLike> Hash for OffsetVec<V>

where V::Slice: Hash,

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<V, I> Index<I> for OffsetVec<V>

where V: VecLike, I: SliceIndex<V::Slice>, V::Slice: Index<I>,

type Output = <<V as VecLike>::Slice as Index<I>>::Output

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<V, I> IndexMut<I> for OffsetVec<V>

where V: VecLike, I: SliceIndex<V::Slice>, V::Slice: IndexMut<I>,

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

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

impl<V: VecLike + IntoIterator> IntoIterator for OffsetVec<V>

type Item = <V as IntoIterator>::Item

The type of the elements being iterated over.

type IntoIter = <V as IntoIterator>::IntoIter

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<V: Offset + VecLike> Offset for OffsetVec<V>

type Output = <V as Offset>::Output

type OutputMut = <V as Offset>::OutputMut

fn offset(self, i: usize) -> OffsetVec<Self::Output>

fn offset_mut(&mut self, i: usize) -> OffsetVec<&mut Self::OutputMut>

impl<V: VecLike> OffsetCheckRef for OffsetVec<V>

fn offset_check_ref(&self)

impl<V: VecLike> Ord for OffsetVec<V>

where V::Slice: Ord,

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<T: PartialEq, V: VecLike<Elem = T, Slice = [T]>> PartialEq<&[T]> for OffsetVec<V>

fn eq(&self, other: &&[V::Elem]) -> 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, V: VecLike<Elem = T, Slice = [T]>, const N: usize> PartialEq<&[T; N]> for OffsetVec<V>

fn eq(&self, other: &&[V::Elem; N]) -> 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<V: VecLike<Slice = str>> PartialEq<&str> for OffsetVec<V>

fn eq(&self, other: &&str) -> 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, V: VecLike<Elem = T, Slice = [T]>> PartialEq<[T]> for OffsetVec<V>

fn eq(&self, other: &[V::Elem]) -> 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, V: VecLike<Elem = T, Slice = [T]>, const N: usize> PartialEq<[T; N]> for OffsetVec<V>

fn eq(&self, other: &[V::Elem; N]) -> 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<V: VecLike> PartialEq<V> for OffsetVec<V>

where V::Slice: PartialEq,

fn eq(&self, other: &V) -> 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<V: VecLike<Slice = str>> PartialEq<str> for OffsetVec<V>

fn eq(&self, other: &str) -> 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<V: VecLike> PartialEq for OffsetVec<V>

where V::Slice: PartialEq,

fn eq(&self, other: &Self) -> 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<V: VecLike> PartialOrd for OffsetVec<V>

where V::Slice: PartialOrd,

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<V: VecLike> Eq for OffsetVec<V>

where V::Slice: Eq,