Struct VecChain

pub struct VecChain<T> { /* private fields */ }

Implementations

impl<T> VecChain<T>

pub fn new() -> Self

Creates a new vector chain without allocating any capacity

It will not allocate until it needs to, either by pushing an element, calling the reserve function to explicitly request allocation, or something else.

Examples

// a chain thingie! yay!...
let chain = VecChain::new();

pub unsafe fn from_raw_parts( ptr: *mut T, length: usize, capacity: usize, ) -> Self

Safety

You must uphold all safety requirements that Vec::from_raw_parts has.

pub fn with_capacity(capacity: usize) -> Self

Creates a new vec chain, and preallocate some memory

The amount of memory allocated will be at least enough to hold capacity elements without reallocating. No allocation will happen if the provided capacity is zero, or if T is a ZST.

There is NO GUARANTEE that this function will allocate an exact amount of memory, so do not rely on this for soundness. If knowing the actual allocated capacity is important, always do so using the capacity function.

If the element type (ie. T) is a ZST, the vec chain will never allocate, and will always have a capacity of usize::MAX bytes.

Panics

Panics if the new capacity exceeds isize::MAX bytes (not elements, bytes). This is the same behaviour of Vec::with_capacity.

Examples

let chain = VecChain::with_capacity(10)
   // chaining methods to get the len and capacity of the vec chain
   .len(&mut len)
   .capacity(&mut initial_capacity);

// The vector chain contains zero elements, and at least room for 10 more
assert_eq!(len, 0);
assert!(initial_capacity >= 10);

// These are all done without reallocating
let chain = (0..10)
   .fold(chain, |chain, i| chain.push(i))
   .len(&mut len)
   .capacity(&mut capacity);

assert_eq!(len, 10);
assert_eq!(capacity, initial_capacity);

// Now however, pushing another element can make the vector reallocate
let chain = chain
   .push(11)
   .len(&mut len)
   .capacity(&mut capacity);

assert_eq!(len, 11);
assert!(capacity >= 11);

// ZSTs never allocate and always have a capacity of `usize::MAX`
let chain1 = VecChain::<()>::new()
   .capacity(&mut capacity1);
let chain2 = VecChain::<()>::with_capacity(10)
   .capacity(&mut capacity2);

assert_eq!(capacity1, usize::MAX);
assert_eq!(capacity2, usize::MAX);

impl<T> VecChain<T>

pub fn append<I>(self, other: &mut I) -> Self

where I: AsChainInner<Vec<T>>,

Takes and moves all elements from another Vec or VecChain into self, leaving it empty.

Examples

TODO

pub fn binary_search<O>(self, x: &T, out: O) -> Self

where T: Ord, O: OutputStorage<Result<usize, usize>>,

pub fn binary_search_by<O, F>( self, f: F, out: &mut Result<usize, usize>, ) -> Self

where F: FnMut(&T) -> Ordering, O: OutputStorage<Result<usize, usize>>,

pub fn binary_search_by_key<B, O, F>(self, b: &B, f: F, out: O) -> Self

where B: Ord, F: FnMut(&T) -> B, O: OutputStorage<Result<usize, usize>>,

pub fn capacity<O>(self, out: O) -> Self

where O: OutputStorage<usize>,

pub fn clear(self) -> Self

pub fn clone_from_slice(self, src: &[T]) -> Self

where T: Clone,

pub fn copy_from_slice(self, src: &[T]) -> Self

where T: Copy,

pub fn contains<O>(self, x: &T, out: O) -> Self

where T: PartialEq, O: OutputStorage<bool>,

pub fn dedup(self) -> Self

where T: PartialOrd,

pub fn dedup_by<F>(self, same_bucket: F) -> Self

where F: FnMut(&mut T, &mut T) -> bool,

pub fn dedup_by_key<K, F>(self, key: F) -> Self

where F: FnMut(&mut T) -> K, K: PartialEq,

pub fn ends_with<O>(self, needle: &[T], out: O) -> Self

where T: PartialEq, O: OutputStorage<bool>,

pub fn fill(self, value: T) -> Self

where T: Clone,

pub fn fill_with<F>(self, f: F) -> Self

where F: FnMut() -> T,

pub fn insert(self, index: usize, element: T) -> Self

pub fn len<O>(self, out: O) -> Self

where O: OutputStorage<usize>,

pub fn push(self, value: T) -> Self

pub fn remove<O>(self, index: usize, out: O) -> Self

where O: OutputStorage<T>,

pub fn reserve(self, additional: usize) -> Self

pub fn reserve_exact(self, additional: usize) -> Self

pub unsafe fn set_len(self, new_len: usize) -> Self

Safety

new_len must be less than or equal to capacity, and the first new_len elements must be initialised/

Trait Implementations

impl<T> AsChainInner<Vec<T>> for VecChain<T>

fn as_inner(&self) -> &Vec<T>

fn as_inner_mut(&mut self) -> &mut Vec<T>

impl<T> AsMut<Vec<T>> for VecChain<T>

fn as_mut(&mut self) -> &mut Vec<T>

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

impl<T> AsRef<Vec<T>> for VecChain<T>

fn as_ref(&self) -> &Vec<T>

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

impl<T> Chain for VecChain<T>

type Inner = Vec<T>

fn into_inner(self) -> Self::Inner

fn from_inner(inner: Self::Inner) -> Self

fn as_inner(&self) -> &Self::Inner

fn as_inner_mut(&mut self) -> &mut Self::Inner

fn with_inner<F, Void>(self, f: F) -> Self

where F: FnOnce(&mut Self::Inner) -> Void,

Takes a closure that is called, passing in a reference to the inner value

impl<T> Clone for VecChain<T>

where Vec<T>: Clone,

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Debug for VecChain<T>

where Vec<T>: Debug,

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

Formats the value using the given formatter.

impl<T> Default for VecChain<T>

where Vec<T>: Default,

fn default() -> Self

Returns the “default value” for a type.

impl<T> Display for VecChain<T>

where Vec<T>: Display,

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

Formats the value using the given formatter.

impl<T> From<&Vec<T>> for VecChain<T>

where Vec<T>: Clone,

fn from(inner: &Vec<T>) -> Self

Converts to this type from the input type.

impl<T> From<&VecChain<T>> for Vec<T>

where Vec<T>: Clone,

fn from(chain: &VecChain<T>) -> Self

Converts to this type from the input type.

impl<T> From<&mut Vec<T>> for VecChain<T>

where Vec<T>: Clone,

fn from(inner: &mut Vec<T>) -> Self

Converts to this type from the input type.

impl<T> From<&mut VecChain<T>> for Vec<T>

where Vec<T>: Clone,

fn from(chain: &mut VecChain<T>) -> Self

Converts to this type from the input type.

impl<T> From<Vec<T>> for VecChain<T>

fn from(inner: Vec<T>) -> Self

Converts to this type from the input type.

impl<T> From<VecChain<T>> for Vec<T>

fn from(chain: VecChain<T>) -> Self

Converts to this type from the input type.

impl<T> PartialEq<Vec<T>> for VecChain<T>

where Vec<T>: PartialEq<Vec<T>>,

fn eq(&self, other: &Vec<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Vec<T>) -> bool

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

impl<T> PartialEq<VecChain<T>> for Vec<T>

where Vec<T>: PartialEq<Vec<T>>,

fn eq(&self, other: &VecChain<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &VecChain<T>) -> bool

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

impl<T> PartialEq for VecChain<T>

where Vec<T>: PartialEq<Vec<T>>,

fn eq(&self, other: &VecChain<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &VecChain<T>) -> bool

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

impl<T> PartialOrd<Vec<T>> for VecChain<T>

where Vec<T>: PartialOrd<Vec<T>>,

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

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

fn lt(&self, other: &Vec<T>) -> bool

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

fn le(&self, other: &Vec<T>) -> bool

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

fn gt(&self, other: &Vec<T>) -> bool

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

fn ge(&self, other: &Vec<T>) -> bool

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

impl<T> PartialOrd<VecChain<T>> for Vec<T>

where Vec<T>: PartialOrd<Vec<T>>,

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

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

fn lt(&self, other: &VecChain<T>) -> bool

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

fn le(&self, other: &VecChain<T>) -> bool

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

fn gt(&self, other: &VecChain<T>) -> bool

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

fn ge(&self, other: &VecChain<T>) -> bool

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

impl<T> PartialOrd for VecChain<T>

where Vec<T>: PartialOrd<Vec<T>>,

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

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

fn lt(&self, other: &VecChain<T>) -> bool

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

fn le(&self, other: &VecChain<T>) -> bool

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

fn gt(&self, other: &VecChain<T>) -> bool

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

fn ge(&self, other: &VecChain<T>) -> bool

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

impl<T> Copy for VecChain<T>

where Vec<T>: Copy,