Type Alias ByteVec

type ByteVec<'a> = Vec<'a, u8>;

Aliased Type

struct ByteVec<'a> { /* private fields */ }

Implementations

impl<'bump, T> Vec<'bump, T>

where T: 'bump + Clone,

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

Resizes the Vec in-place so that len is equal to new_len.

If new_len is greater than len, the Vec is extended by the difference, with each additional slot filled with value. If new_len is less than len, the Vec is simply truncated.

This method requires Clone to be able clone the passed value. If you need more flexibility (or want to rely on Default instead of Clone), use resize_with.

Examples

use bumpalo::{Bump, collections::Vec};

let b = Bump::new();

let mut vec = bumpalo::vec![in &b; "hello"];
vec.resize(3, "world");
assert_eq!(vec, ["hello", "world", "world"]);

let mut vec = bumpalo::vec![in &b; 1, 2, 3, 4];
vec.resize(2, 0);
assert_eq!(vec, [1, 2]);

pub fn extend_from_slice(&mut self, other: &[T])

Clones and appends all elements in a slice to the Vec.

Iterates over the slice other, clones each element, and then appends it to this Vec. The other vector is traversed in-order.

Note that this function is same as extend except that it is specialized to work with slices instead. If and when Rust gets specialization this function will likely be deprecated (but still available).

Examples

use bumpalo::{Bump, collections::Vec};

let b = Bump::new();

let mut vec = bumpalo::vec![in &b; 1];
vec.extend_from_slice(&[2, 3, 4]);
assert_eq!(vec, [1, 2, 3, 4]);

impl<'bump, T> Vec<'bump, T>

where T: 'bump + PartialEq,

pub fn dedup(&mut self)

Removes consecutive repeated elements in the vector according to the PartialEq trait implementation.

If the vector is sorted, this removes all duplicates.

Examples

use bumpalo::{Bump, collections::Vec};

let b = Bump::new();

let mut vec = bumpalo::vec![in &b; 1, 2, 2, 3, 2];

vec.dedup();

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

impl<'bump, T> Vec<'bump, T>

where T: 'bump + Copy,

pub fn extend_from_slice_copy(&mut self, other: &[T])

Copies all elements in the slice other and appends them to the Vec.

Note that this function is same as extend_from_slice except that it is optimized for slices of types that implement the Copy trait. If and when Rust gets specialization this function will likely be deprecated (but still available).

To copy and append the data from multiple source slices at once, see [extend_from_slices_copy].

Examples

use bumpalo::{Bump, collections::Vec};

let b = Bump::new();

let mut vec = bumpalo::vec![in &b; 1];
vec.extend_from_slice_copy(&[2, 3, 4]);
assert_eq!(vec, [1, 2, 3, 4]);

use bumpalo::{Bump, collections::Vec};

let b = Bump::new();

let mut vec = bumpalo::vec![in &b; 'H' as u8];
vec.extend_from_slice_copy("ello, world!".as_bytes());
assert_eq!(vec, "Hello, world!".as_bytes());

pub fn extend_from_slices_copy(&mut self, slices: &[&[T]])

For each slice in slices, copies all elements in the slice and appends them to the Vec.

This method is equivalent to calling extend_from_slice_copy in a loop, but is able to precompute the total amount of space to reserve in advance. This reduces the potential maximum number of reallocations needed from one-per-slice to just one.

Examples

use bumpalo::{Bump, collections::Vec};

let b = Bump::new();

let mut vec = bumpalo::vec![in &b; 1];
vec.extend_from_slices_copy(&[&[2, 3], &[], &[4]]);
assert_eq!(vec, [1, 2, 3, 4]);

use bumpalo::{Bump, collections::Vec};

let b = Bump::new();

let mut vec = bumpalo::vec![in &b; 'H' as u8];
vec.extend_from_slices_copy(&["ello,".as_bytes(), &[], " world!".as_bytes()]);
assert_eq!(vec, "Hello, world!".as_bytes());

impl<'bump, T> Vec<'bump, T>

where T: 'bump,

pub fn new_in(bump: &'bump Bump) -> Vec<'bump, T>

Constructs a new, empty Vec<'bump, T>.

The vector will not allocate until elements are pushed onto it.

Examples

use bumpalo::{Bump, collections::Vec};

let b = Bump::new();
let mut vec: Vec<i32> = Vec::new_in(&b);

pub fn with_capacity_in(capacity: usize, bump: &'bump Bump) -> Vec<'bump, T>

Constructs a new, empty Vec<'bump, T> with the specified capacity.

The vector will be able to hold exactly capacity elements without reallocating. If capacity is 0, the vector will not allocate.

It is important to note that although the returned vector has the capacity specified, the vector will have a zero length. For an explanation of the difference between length and capacity, see Capacity and reallocation.

Examples

use bumpalo::{Bump, collections::Vec};

let b = Bump::new();

let mut vec = Vec::with_capacity_in(10, &b);

// The vector contains no items, even though it has capacity for more
assert_eq!(vec.len(), 0);

// These are all done without reallocating...
for i in 0..10 {
    vec.push(i);
}

// ...but this may make the vector reallocate
vec.push(11);

pub fn from_iter_in<I>(iter: I, bump: &'bump Bump) -> Vec<'bump, T>

where I: IntoIterator<Item = T>,

Construct a new Vec from the given iterator’s items.

Examples

use bumpalo::{Bump, collections::Vec};
use std::iter;

let b = Bump::new();
let v = Vec::from_iter_in(iter::repeat(7).take(3), &b);
assert_eq!(v, [7, 7, 7]);

pub unsafe fn from_raw_parts_in( ptr: *mut T, length: usize, capacity: usize, bump: &'bump Bump, ) -> Vec<'bump, T>

Creates a Vec<'bump, T> directly from the raw components of another vector.

Safety

This is highly unsafe, due to the number of invariants that aren’t checked:

• ptr needs to have been previously allocated via String/Vec<'bump, T> (at least, it’s highly likely to be incorrect if it wasn’t).
• ptr’s T needs to have the same size and alignment as it was allocated with.
• length needs to be less than or equal to capacity.
• capacity needs to be the capacity that the pointer was allocated with.

Violating these may cause problems like corrupting the allocator’s internal data structures. For example it is not safe to build a Vec<u8> from a pointer to a C char array and a size_t.

The ownership of ptr is effectively transferred to the Vec<'bump, T> which may then deallocate, reallocate or change the contents of memory pointed to by the pointer at will. Ensure that nothing else uses the pointer after calling this function.

Examples

use bumpalo::{Bump, collections::Vec};

use std::ptr;
use std::mem;

let b = Bump::new();

let mut v = bumpalo::vec![in &b; 1, 2, 3];

// Pull out the various important pieces of information about `v`
let p = v.as_mut_ptr();
let len = v.len();
let cap = v.capacity();

unsafe {
    // Cast `v` into the void: no destructor run, so we are in
    // complete control of the allocation to which `p` points.
    mem::forget(v);

    // Overwrite memory with 4, 5, 6
    for i in 0..len as isize {
        ptr::write(p.offset(i), 4 + i);
    }

    // Put everything back together into a Vec
    let rebuilt = Vec::from_raw_parts_in(p, len, cap, &b);
    assert_eq!(rebuilt, [4, 5, 6]);
}

pub fn bump(&self) -> &'bump Bump

Returns a shared reference to the allocator backing this Vec.

Examples

use bumpalo::{Bump, collections::Vec};

// uses the same allocator as the provided `Vec`
fn add_strings<'bump>(vec: &mut Vec<'bump, &'bump str>) {
    for string in ["foo", "bar", "baz"] {
        vec.push(vec.bump().alloc_str(string));
    }
}

pub fn capacity(&self) -> usize

Returns the number of elements the vector can hold without reallocating.

Examples

use bumpalo::{Bump, collections::Vec};

let b = Bump::new();
let vec: Vec<i32> = Vec::with_capacity_in(10, &b);
assert_eq!(vec.capacity(), 10);

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

Reserves capacity for at least additional more elements to be inserted in the given Vec<'bump, T>. The collection may reserve more space to avoid frequent reallocations. After calling reserve, capacity will be greater than or equal to self.len() + additional. Does nothing if capacity is already sufficient.

Panics

Panics if the new capacity overflows usize.

Examples

use bumpalo::{Bump, collections::Vec};

let b = Bump::new();
let mut vec = bumpalo::vec![in &b; 1];
vec.reserve(10);
assert!(vec.capacity() >= 11);

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

Reserves the minimum capacity for exactly additional more elements to be inserted in the given Vec<'bump, T>. After calling reserve_exact, capacity will be greater than or equal to self.len() + additional. Does nothing if the capacity is already sufficient.

Note that the allocator may give the collection more space than it requests. Therefore capacity can not be relied upon to be precisely minimal. Prefer reserve if future insertions are expected.

Panics

Panics if the new capacity overflows usize.

Examples

use bumpalo::{Bump, collections::Vec};

let b = Bump::new();
let mut vec = bumpalo::vec![in &b; 1];
vec.reserve_exact(10);
assert!(vec.capacity() >= 11);

pub fn try_reserve( &mut self, additional: usize, ) -> Result<(), CollectionAllocErr>

Attempts to reserve capacity for at least additional more elements to be inserted in the given Vec<'bump, T>. The collection may reserve more space to avoid frequent reallocations. After calling try_reserve, capacity will be greater than or equal to self.len() + additional. Does nothing if capacity is already sufficient.

Panics

Panics if the new capacity overflows usize.

Examples

use bumpalo::{Bump, collections::Vec};

let b = Bump::new();
let mut vec = bumpalo::vec![in &b; 1];
vec.try_reserve(10).unwrap();
assert!(vec.capacity() >= 11);

pub fn try_reserve_exact( &mut self, additional: usize, ) -> Result<(), CollectionAllocErr>

Attempts to reserve the minimum capacity for exactly additional more elements to be inserted in the given Vec<'bump, T>. After calling try_reserve_exact, capacity will be greater than or equal to self.len() + additional. Does nothing if the capacity is already sufficient.

Note that the allocator may give the collection more space than it requests. Therefore capacity can not be relied upon to be precisely minimal. Prefer try_reserve if future insertions are expected.

Panics

Panics if the new capacity overflows usize.

Examples

use bumpalo::{Bump, collections::Vec};

let b = Bump::new();
let mut vec = bumpalo::vec![in &b; 1];
vec.try_reserve_exact(10).unwrap();
assert!(vec.capacity() >= 11);

pub fn shrink_to_fit(&mut self)

Shrinks the capacity of the vector as much as possible.

It will drop down as close as possible to the length but the allocator may still inform the vector that there is space for a few more elements.

Examples

use bumpalo::{Bump, collections::Vec};

let b = Bump::new();

let mut vec = Vec::with_capacity_in(10, &b);
vec.extend([1, 2, 3].iter().cloned());
assert_eq!(vec.capacity(), 10);
vec.shrink_to_fit();
assert!(vec.capacity() >= 3);

pub fn into_bump_slice(self) -> &'bump [T]

Converts the vector into &'bump [T].

Examples

use bumpalo::{Bump, collections::Vec};

let b = Bump::new();
let v = bumpalo::vec![in &b; 1, 2, 3];

let slice = v.into_bump_slice();
assert_eq!(slice, [1, 2, 3]);

pub fn into_bump_slice_mut(self) -> &'bump mut [T]

Converts the vector into &'bump mut [T].

Examples

use bumpalo::{Bump, collections::Vec};

let b = Bump::new();
let v = bumpalo::vec![in &b; 1, 2, 3];

let mut slice = v.into_bump_slice_mut();

slice[0] = 3;
slice[2] = 1;

assert_eq!(slice, [3, 2, 1]);

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

Shortens the vector, keeping the first len elements and dropping the rest.

If len is greater than the vector’s current length, this has no effect.

The drain method can emulate truncate, but causes the excess elements to be returned instead of dropped.

Note that this method has no effect on the allocated capacity of the vector.

Examples

Truncating a five element vector to two elements:

use bumpalo::{Bump, collections::Vec};

let b = Bump::new();

let mut vec = bumpalo::vec![in &b; 1, 2, 3, 4, 5];
vec.truncate(2);
assert_eq!(vec, [1, 2]);

No truncation occurs when len is greater than the vector’s current length:

use bumpalo::{Bump, collections::Vec};

let b = Bump::new();

let mut vec = bumpalo::vec![in &b; 1, 2, 3];
vec.truncate(8);
assert_eq!(vec, [1, 2, 3]);

Truncating when len == 0 is equivalent to calling the clear method.

use bumpalo::{Bump, collections::Vec};

let b = Bump::new();

let mut vec = bumpalo::vec![in &b; 1, 2, 3];
vec.truncate(0);
assert_eq!(vec, []);

pub fn as_slice(&self) -> &[T]

Extracts a slice containing the entire vector.

Equivalent to &s[..].

Examples

use bumpalo::{Bump, collections::Vec};
use std::io::{self, Write};

let b = Bump::new();

let buffer = bumpalo::vec![in &b; 1, 2, 3, 5, 8];
io::sink().write(buffer.as_slice()).unwrap();

pub fn as_mut_slice(&mut self) -> &mut [T]

Extracts a mutable slice of the entire vector.

Equivalent to &mut s[..].

Examples

use bumpalo::{Bump, collections::Vec};
use std::io::{self, Read};

let b = Bump::new();
let mut buffer = bumpalo::vec![in &b; 0; 3];
io::repeat(0b101).read_exact(buffer.as_mut_slice()).unwrap();

pub fn as_ptr(&self) -> *const T

Returns a raw pointer to the vector’s buffer, or a dangling raw pointer valid for zero sized reads if the vector didn’t allocate.

The caller must ensure that the vector outlives the pointer this function returns, or else it will end up pointing to garbage. Modifying the vector may cause its buffer to be reallocated, which would also make any pointers to it invalid.

The caller must also ensure that the memory the pointer (non-transitively) points to is never written to (except inside an UnsafeCell) using this pointer or any pointer derived from it. If you need to mutate the contents of the slice, use as_mut_ptr.

Examples

use bumpalo::{Bump, collections::Vec};

let bump = Bump::new();

let x = bumpalo::vec![in ≎ 1, 2, 4];
let x_ptr = x.as_ptr();

unsafe {
    for i in 0..x.len() {
        assert_eq!(*x_ptr.add(i), 1 << i);
    }
}

pub fn as_mut_ptr(&mut self) -> *mut T

Returns an unsafe mutable pointer to the vector’s buffer, or a dangling raw pointer valid for zero sized reads if the vector didn’t allocate.

The caller must ensure that the vector outlives the pointer this function returns, or else it will end up pointing to garbage. Modifying the vector may cause its buffer to be reallocated, which would also make any pointers to it invalid.

Examples

use bumpalo::{Bump, collections::Vec};

let bump = Bump::new();

// Allocate vector big enough for 4 elements.
let size = 4;
let mut x: Vec<i32> = Vec::with_capacity_in(size, &bump);
let x_ptr = x.as_mut_ptr();

// Initialize elements via raw pointer writes, then set length.
unsafe {
    for i in 0..size {
        x_ptr.add(i).write(i as i32);
    }
    x.set_len(size);
}
assert_eq!(&*x, &[0, 1, 2, 3]);

pub unsafe fn set_len(&mut self, new_len: usize)

Sets the length of a vector.

This will explicitly set the size of the vector, without actually modifying its buffers, so it is up to the caller to ensure that the vector is actually the specified size.

Safety

• new_len must be less than or equal to capacity().
• The elements at old_len..new_len must be initialized.

Examples

use bumpalo::{Bump, collections::Vec};

use std::ptr;

let b = Bump::new();

let mut vec = bumpalo::vec![in &b; 'r', 'u', 's', 't'];

unsafe {
    ptr::drop_in_place(&mut vec[3]);
    vec.set_len(3);
}
assert_eq!(vec, ['r', 'u', 's']);

In this example, there is a memory leak since the memory locations owned by the inner vectors were not freed prior to the set_len call:

use bumpalo::{Bump, collections::Vec};

let b = Bump::new();

let mut vec = bumpalo::vec![in &b;
                            bumpalo::vec![in &b; 1, 0, 0],
                            bumpalo::vec![in &b; 0, 1, 0],
                            bumpalo::vec![in &b; 0, 0, 1]];
unsafe {
    vec.set_len(0);
}

In this example, the vector gets expanded from zero to four items but we directly initialize uninitialized memory:

use bumpalo::{Bump, collections::Vec};

let len = 4;
let b = Bump::new();

let mut vec: Vec<u8> = Vec::with_capacity_in(len, &b);

for i in 0..len {
    // SAFETY: we initialize memory via `pointer::write`
    unsafe { vec.as_mut_ptr().add(i).write(b'a') }
}

unsafe {
    vec.set_len(len);
}

assert_eq!(b"aaaa", &*vec);

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

Removes an element from the vector and returns it.

The removed element is replaced by the last element of the vector.

This does not preserve ordering, but is O(1).

Panics

Panics if index is out of bounds.

Examples

use bumpalo::{Bump, collections::Vec};

let b = Bump::new();

let mut v = bumpalo::vec![in &b; "foo", "bar", "baz", "qux"];

assert_eq!(v.swap_remove(1), "bar");
assert_eq!(v, ["foo", "qux", "baz"]);

assert_eq!(v.swap_remove(0), "foo");
assert_eq!(v, ["baz", "qux"]);

pub fn insert(&mut self, index: usize, element: T)

Inserts an element at position index within the vector, shifting all elements after it to the right.

Panics

Panics if index > len.

Examples

use bumpalo::{Bump, collections::Vec};

let b = Bump::new();

let mut vec = bumpalo::vec![in &b; 1, 2, 3];
vec.insert(1, 4);
assert_eq!(vec, [1, 4, 2, 3]);
vec.insert(4, 5);
assert_eq!(vec, [1, 4, 2, 3, 5]);

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

Removes and returns the element at position index within the vector, shifting all elements after it to the left.

Panics

Panics if index is out of bounds.

Examples

use bumpalo::{Bump, collections::Vec};

let b = Bump::new();

let mut v = bumpalo::vec![in &b; 1, 2, 3];
assert_eq!(v.remove(1), 2);
assert_eq!(v, [1, 3]);

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

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

Retains only the elements specified by the predicate.

In other words, remove all elements e such that f(&e) returns false. This method operates in place and preserves the order of the retained elements.

Examples

use bumpalo::{Bump, collections::Vec};

let b = Bump::new();

let mut vec = bumpalo::vec![in &b; 1, 2, 3, 4];
vec.retain(|&x| x % 2 == 0);
assert_eq!(vec, [2, 4]);

pub fn drain_filter<'a, F>( &'a mut self, filter: F, ) -> DrainFilter<'a, 'bump, T, F>

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

Creates an iterator that removes the elements in the vector for which the predicate returns true and yields the removed items.

Examples

use bumpalo::Bump;
use bumpalo::collections::{CollectIn, Vec};

let b = Bump::new();

let mut numbers = bumpalo::vec![in &b; 1, 2, 3, 4, 5];

let evens: Vec<_> = numbers.drain_filter(|x| *x % 2 == 0).collect_in(&b);

assert_eq!(numbers, &[1, 3, 5]);
assert_eq!(evens, &[2, 4]);

pub fn dedup_by_key<F, K>(&mut self, key: F)

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

Removes all but the first of consecutive elements in the vector that resolve to the same key.

If the vector is sorted, this removes all duplicates.

Examples

use bumpalo::{Bump, collections::Vec};

let b = Bump::new();

let mut vec = bumpalo::vec![in &b; 10, 20, 21, 30, 20];

vec.dedup_by_key(|i| *i / 10);

assert_eq!(vec, [10, 20, 30, 20]);

pub fn dedup_by<F>(&mut self, same_bucket: F)

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

Removes all but the first of consecutive elements in the vector satisfying a given equality relation.

The same_bucket function is passed references to two elements from the vector and must determine if the elements compare equal. The elements are passed in opposite order from their order in the slice, so if same_bucket(a, b) returns true, a is removed.

If the vector is sorted, this removes all duplicates.

Examples

use bumpalo::{Bump, collections::Vec};

let b = Bump::new();

let mut vec = bumpalo::vec![in &b; "foo", "bar", "Bar", "baz", "bar"];

vec.dedup_by(|a, b| a.eq_ignore_ascii_case(b));

assert_eq!(vec, ["foo", "bar", "baz", "bar"]);

pub fn push(&mut self, value: T)

Appends an element to the back of a vector.

Panics

Panics if the number of elements in the vector overflows a usize.

Examples

use bumpalo::{Bump, collections::Vec};

let b = Bump::new();

let mut vec = bumpalo::vec![in &b; 1, 2];
vec.push(3);
assert_eq!(vec, [1, 2, 3]);

pub fn pop(&mut self) -> Option<T>

Removes the last element from a vector and returns it, or None if it is empty.

Examples

use bumpalo::{Bump, collections::Vec};

let b = Bump::new();

let mut vec = bumpalo::vec![in &b; 1, 2, 3];
assert_eq!(vec.pop(), Some(3));
assert_eq!(vec, [1, 2]);

pub fn append(&mut self, other: &mut Vec<'bump, T>)

Moves all the elements of other into Self, leaving other empty.

Panics

Panics if the number of elements in the vector overflows a usize.

Examples

use bumpalo::{Bump, collections::Vec};

let b = Bump::new();

let mut vec = bumpalo::vec![in &b; 1, 2, 3];
let mut vec2 = bumpalo::vec![in &b; 4, 5, 6];
vec.append(&mut vec2);
assert_eq!(vec, [1, 2, 3, 4, 5, 6]);
assert_eq!(vec2, []);

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

where R: RangeBounds<usize>,

Creates a draining iterator that removes the specified range in the vector and yields the removed items.

Note 1: The element range is removed even if the iterator is only partially consumed or not consumed at all.

Note 2: It is unspecified how many elements are removed from the vector if the Drain value is leaked.

Panics

Panics if the starting point is greater than the end point or if the end point is greater than the length of the vector.

Examples

use bumpalo::Bump;
use bumpalo::collections::{CollectIn, Vec};

let b = Bump::new();

let mut v = bumpalo::vec![in &b; 1, 2, 3];

let u: Vec<_> = v.drain(1..).collect_in(&b);

assert_eq!(v, &[1]);
assert_eq!(u, &[2, 3]);

// A full range clears the vector
v.drain(..);
assert_eq!(v, &[]);

pub fn clear(&mut self)

Clears the vector, removing all values.

Note that this method has no effect on the allocated capacity of the vector.

Examples

use bumpalo::{Bump, collections::Vec};

let b = Bump::new();

let mut v = bumpalo::vec![in &b; 1, 2, 3];

v.clear();

assert!(v.is_empty());

pub fn len(&self) -> usize

Returns the number of elements in the vector, also referred to as its ‘length’.

Examples

use bumpalo::{Bump, collections::Vec};

let b = Bump::new();

let a = bumpalo::vec![in &b; 1, 2, 3];
assert_eq!(a.len(), 3);

pub fn is_empty(&self) -> bool

Returns true if the vector contains no elements.

Examples

use bumpalo::{Bump, collections::Vec};

let b = Bump::new();

let mut v = Vec::new_in(&b);
assert!(v.is_empty());

v.push(1);
assert!(!v.is_empty());

pub fn split_off(&mut self, at: usize) -> Vec<'bump, T>

Splits the collection into two at the given index.

Returns a newly allocated vector. self contains elements [0, at), and the returned vector contains elements [at, len).

Note that the capacity of self does not change.

Panics

Panics if at > len.

Examples

use bumpalo::{Bump, collections::Vec};

let b = Bump::new();

let mut vec = bumpalo::vec![in &b; 1, 2, 3];
let vec2 = vec.split_off(1);
assert_eq!(vec, [1]);
assert_eq!(vec2, [2, 3]);

impl<'bump, T> Vec<'bump, T>

where T: 'bump,

pub fn splice<R, I>( &mut self, range: R, replace_with: I, ) -> Splice<'_, '_, <I as IntoIterator>::IntoIter>

where R: RangeBounds<usize>, I: IntoIterator<Item = T>,

Creates a splicing iterator that replaces the specified range in the vector with the given replace_with iterator and yields the removed items. replace_with does not need to be the same length as range.

Note 1: The element range is removed even if the iterator is not consumed until the end.

Note 2: It is unspecified how many elements are removed from the vector, if the Splice value is leaked.

Note 3: The input iterator replace_with is only consumed when the Splice value is dropped.

Note 4: This is optimal if:

• The tail (elements in the vector after range) is empty,
• or replace_with yields fewer elements than range’s length
• or the lower bound of its size_hint() is exact.

Otherwise, a temporary vector is allocated and the tail is moved twice.

Panics

Panics if the starting point is greater than the end point or if the end point is greater than the length of the vector.

Examples

use bumpalo::{Bump, collections::Vec};

let b = Bump::new();

let mut v = bumpalo::vec![in &b; 1, 2, 3];
let new = [7, 8];
let u: Vec<_> = Vec::from_iter_in(v.splice(..2, new.iter().cloned()), &b);
assert_eq!(v, &[7, 8, 3]);
assert_eq!(u, &[1, 2]);

Trait Implementations

impl<'bump, T> AsMut<[T]> for Vec<'bump, T>

where T: 'bump,

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

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

impl<'bump, T> AsMut<Vec<'bump, T>> for Vec<'bump, T>

where T: 'bump,

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

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

impl<'bump, T> AsRef<[T]> for Vec<'bump, T>

where T: 'bump,

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

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

impl<'bump, T> AsRef<Vec<'bump, T>> for Vec<'bump, T>

where T: 'bump,

fn as_ref(&self) -> &Vec<'bump, T>

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

impl<'bump, T> Borrow<[T]> for Vec<'bump, T>

where T: 'bump,

fn borrow(&self) -> &[T]

Immutably borrows from an owned value.

impl<'bump, T> BorrowMut<[T]> for Vec<'bump, T>

where T: 'bump,

fn borrow_mut(&mut self) -> &mut [T]

Mutably borrows from an owned value.

impl<'bump, T> Clone for Vec<'bump, T>

where T: 'bump + Clone,

fn clone(&self) -> Vec<'bump, T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'bump, T> Debug for Vec<'bump, T>

where T: 'bump + Debug,

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

Formats the value using the given formatter.

impl<'bump, T> Deref for Vec<'bump, T>

where T: 'bump,

type Target = [T]

The resulting type after dereferencing.

fn deref(&self) -> &[T]

Dereferences the value.

impl<'bump, T> DerefMut for Vec<'bump, T>

where T: 'bump,

fn deref_mut(&mut self) -> &mut [T]

Mutably dereferences the value.

impl<'bump, T> Drop for Vec<'bump, T>

fn drop(&mut self)

Executes the destructor for this type.

impl<'a, 'bump, T> Extend<&'a T> for Vec<'bump, T>

where T: 'a + Copy,

Extend implementation that copies elements out of references before pushing them onto the Vec.

This implementation is specialized for slice iterators, where it uses copy_from_slice to append the entire slice at once.

fn extend<I>(&mut self, iter: I)

where I: IntoIterator<Item = &'a T>,

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<'bump, T> Extend<T> for Vec<'bump, T>

where T: 'bump,

fn extend<I>(&mut self, iter: I)

where I: IntoIterator<Item = T>,

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<'bump, T> FromIteratorIn<T> for Vec<'bump, T>

type Alloc = &'bump Bump

The allocator type

fn from_iter_in<I>( iter: I, alloc: <Vec<'bump, T> as FromIteratorIn<T>>::Alloc, ) -> Vec<'bump, T>

where I: IntoIterator<Item = T>,

Similar to FromIterator::from_iter, but with a given allocator.

impl<'bump, T> Hash for Vec<'bump, T>

where T: 'bump + Hash,

fn hash<H>(&self, state: &mut H)

where H: Hasher,

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<'bump, T, I> Index<I> for Vec<'bump, T>

where I: SliceIndex<[T]>,

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

The returned type after indexing.

fn index(&self, index: I) -> &<Vec<'bump, T> as Index<I>>::Output

Performs the indexing (container[index]) operation.

impl<'bump, T, I> IndexMut<I> for Vec<'bump, T>

where I: SliceIndex<[T]>,

fn index_mut(&mut self, index: I) -> &mut <Vec<'bump, T> as Index<I>>::Output

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

impl<'bump, T> IntoIterator for Vec<'bump, T>

where T: 'bump,

fn into_iter(self) -> IntoIter<'bump, T>

Creates a consuming iterator, that is, one that moves each value out of the vector (from start to end). The vector cannot be used after calling this.

Examples

use bumpalo::{Bump, collections::Vec};

let b = Bump::new();

let v = bumpalo::vec![in &b; "a".to_string(), "b".to_string()];
for s in v.into_iter() {
    // s has type String, not &String
    println!("{}", s);
}

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<'bump, T>

Which kind of iterator are we turning this into?

impl<'bump, T> Ord for Vec<'bump, T>

where T: 'bump + Ord,

Implements ordering of vectors, lexicographically.

fn cmp(&self, other: &Vec<'bump, T>) -> 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<'a, 'b, A, B> PartialEq<&'b [B]> for Vec<'a, A>

where A: PartialEq<B>,

fn eq(&self, other: &&'b [B]) -> 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<'a, 'b, A, B, const N: usize> PartialEq<&'b [B; N]> for Vec<'a, A>

where A: PartialEq<B>,

fn eq(&self, other: &&'b [B; 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<'a, 'b, A, B> PartialEq<&'b mut [B]> for Vec<'a, A>

where A: PartialEq<B>,

fn eq(&self, other: &&'b mut [B]) -> 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<'a, 'b, A, B, const N: usize> PartialEq<&'b mut [B; N]> for Vec<'a, A>

where A: PartialEq<B>,

fn eq(&self, other: &&'b mut [B; 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<'a, 'b, A, B, const N: usize> PartialEq<[B; N]> for Vec<'a, A>

where A: PartialEq<B>,

fn eq(&self, other: &[B; 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<'a, 'b, A, B> PartialEq<Vec<'b, B>> for Vec<'a, A>

where A: PartialEq<B>,

fn eq(&self, other: &Vec<'b, B>) -> 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<'bump, T> PartialOrd for Vec<'bump, T>

where T: 'bump + PartialOrd,

Implements comparison of vectors, lexicographically.

fn partial_cmp(&self, other: &Vec<'bump, T>) -> 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<'bump, T> Eq for Vec<'bump, T>

where T: 'bump + Eq,