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

Get original vector

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.origin_vec(), &&mut vec![0, 1, 2, 3, 4]);

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

Get mutable original vector

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.origin_vec_mut(), &mut &mut vec![0, 1, 2, 3, 4]);

vec1.origin_vec_mut()[3] += 2;
assert_eq!(vec1, [2, 5, 4]);

pub fn into_origin_vec(self) -> V

Consume OffsetVec into packed original vector

Examples

use offset_vec::Offset;

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

assert_eq!(vec1, [2, 3, 4]);
assert_eq!(vec1.into_origin_vec(), vec![0, 1, 2, 3, 4]);

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

Extracts a slice containing the offset vector.

Equivalent to &s[..].

Examples

use offset_vec::Offset;

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

assert_eq!(vec1.as_slice(), &[2, 3, 4]);
assert_eq!(&vec1[..], &[2, 3, 4]);

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

Extracts a mutable slice containing the offset vector.

Equivalent to &mut s[..].

Examples

use offset_vec::Offset;

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

assert_eq!(vec1.as_mut_slice(), &mut [2, 3, 4]);
assert_eq!(&mut vec1[..], &mut [2, 3, 4]);

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

where &'a V::Slice: IntoIterator,

Immutable iterator

Examples

use offset_vec::Offset;

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

let x: Vec<_> = vec1.iter().collect();
assert_eq!(x, [&2, &3, &4]);

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

where &'a mut V::Slice: IntoIterator,

Mutable iterator

Examples

use offset_vec::Offset;

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

let mut x: Vec<_> = vec1.iter_mut().collect();
assert_eq!(x, [&mut 2, &mut 3, &mut 4]);
*x[1] += 2;

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

pub fn is_empty(&self) -> bool

self.len() == 0

pub fn len(&self) -> usize

Get offset vector length

Examples

use offset_vec::Offset;

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

assert_eq!(vec1.len(), 3);
assert_eq!(vec1.origin_vec().len(), 5);

pub fn capacity(&self) -> usize

Get offset vector capacity

Examples

use offset_vec::Offset;

let mut vec = Vec::with_capacity(5);
vec.extend([0, 1, 2, 3, 4]);
let mut vec1 = vec.offset(2);

assert_eq!(3, vec1.capacity());
assert_eq!(5, vec1.origin_vec().capacity());

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

Get offset

Examples

use offset_vec::Offset;

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

assert_eq!(vec1.origin_offset(), 2);

let vec2 = vec1.offset(1);
assert_eq!(vec2.origin_offset(), 3);

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

Push a value

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]);
vec1.push(5);
assert_eq!(vec1, [2, 3, 4, 5]);
assert_eq!(vec, [0, 1, 2, 3, 4, 5]);

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

Pop a value

Examples

use offset_vec::Offset;

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

assert_eq!(vec1, [2, 3]);
assert_eq!(vec1.pop(), Some(3));
assert_eq!(vec1, [2]);
assert_eq!(vec1.pop(), Some(2));
assert_eq!(vec1, []);
assert_eq!(vec1.pop(), None);
assert_eq!(vec1, []);

assert_eq!(vec1.origin_vec(), &&mut [0, 1]);
assert_eq!(vec, [0, 1]);

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

Remove a value at index, shifting all elements after it to the left.

Examples

use offset_vec::Offset;

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

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

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

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

Insert a value before index, shifting all elements after it to the right.

Examples

use offset_vec::Offset;

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

assert_eq!(vec1, [2, 4, 5]);
vec1.insert(1, 3);
assert_eq!(vec1, [2, 3, 4, 5]);
vec1.insert(4, 6);
assert_eq!(vec1, [2, 3, 4, 5, 6]);

assert_eq!(vec, [0, 1, 2, 3, 4, 5, 6]);

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

Truncate to length

Examples

use offset_vec::Offset;

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

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

vec1.truncate(2);

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

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

Append and clear other collection

Examples

use offset_vec::Offset;

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

assert_eq!(vec1, [2, 3]);
vec1.append(&mut other);

assert_eq!(other, []);
assert_eq!(vec1, [2, 3, 4, 5]);
assert_eq!(vec, [0, 1, 2, 3, 4, 5]);

pub fn clear(&mut self)

Clear all elements (offset)

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]);

vec1.clear();

assert_eq!(vec1, []);
assert_eq!(vec, [0, 1]);

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

Drain range elements

Examples

use offset_vec::Offset;

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

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

let drain = vec1.drain(2..4).collect::<Vec<_>>();

assert_eq!(drain, [4, 5]);
assert_eq!(vec1, [2, 3, 6]);
assert_eq!(vec, [0, 1, 2, 3, 6]);

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

Splits the collection into two at the given index.

Examples

use offset_vec::Offset;

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

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

let other = vec1.split_off(3);

assert_eq!(other, [5, 6]);
assert_eq!(vec1, [2, 3, 4]);
assert_eq!(vec, [0, 1, 2, 3, 4]);

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<T, V> FromIterator<T> for OffsetVec<V>

where V: FromIterator<T> + VecLike,

fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self

Creates a value from an iterator.

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<'a, V: VecLike + IntoIterator> IntoIterator for &'a OffsetVec<V>

where &'a V::Slice: IntoIterator,

type Item = <&'a <V as VecLike>::Slice as IntoIterator>::Item

The type of the elements being iterated over.

type IntoIter = <&'a <V as VecLike>::Slice 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<'a, V: VecLike + IntoIterator> IntoIterator for &'a mut OffsetVec<V>

where &'a mut V::Slice: IntoIterator,

type Item = <&'a mut <V as VecLike>::Slice as IntoIterator>::Item

The type of the elements being iterated over.

type IntoIter = <&'a mut <V as VecLike>::Slice 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: 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,