[−][src]Struct two_sided_vec::TwoSidedVec
A simple 'two sided' vector, that can grow both forwards and backwards.
The front and the back can be viewed as seperate and independent vectors,
with negative indexing accessing the back and positive indexing accessing the front.
This allows you to append to the back without modifying positive indexes.
Unless you actually need pushing to the back to appear to shift the front forward,
like VecDeque
does, this negative index system will probably be better for your situation.
Internally this allows a much simpler and faster implementation, since there's only a single pointer to the middle that grows up and down. Internally, we have to reallocate the buffer if we run out of capacity in either the negative or positive difes grow separately and Although bounds checks are slightly slower since they involve two comparisons, the access itself should be just as fast.
Implementations
impl<T> TwoSidedVec<T>
[src]
pub fn new() -> Self
[src]
pub fn with_capacity(back: usize, front: usize) -> Self
[src]
pub fn front(&self) -> &[T]
[src]
Take a slice of the front of this queue
pub fn back(&self) -> &[T]
[src]
Take a slice of the back of this queue
pub fn front_mut(&mut self) -> &mut [T]
[src]
Take a mutable slice of the front of this queue
pub fn back_mut(&mut self) -> &mut [T]
[src]
Take a mutable slice of the back of this queue
pub fn split(&self) -> (&[T], &[T])
[src]
Take seperate slices of the back and the front of the vector respectively.
pub fn split_mut(&mut self) -> (&mut [T], &mut [T])
[src]
Take seperate mutable slices of the back and front of the vector respectively.
pub fn push_front(&mut self, value: T)
[src]
pub fn pop_front(&mut self) -> Option<T>
[src]
pub fn pop_back(&mut self) -> Option<T>
[src]
pub fn push_back(&mut self, value: T)
[src]
Push the specified value into the front of this queue,
without modifying its end
or touching the front of the queue.
This effectively preserves all positive indexes, which may or may not be useful for your situation.
pub fn reserve_back(&mut self, amount: usize)
[src]
pub fn reserve_front(&mut self, amount: usize)
[src]
pub fn capacity_back(&self) -> usize
[src]
pub fn capacity_front(&self) -> usize
[src]
pub fn len(&self) -> usize
[src]
Return the length of the entire vector, which is the sum of the lengths of the front and back parts.
The length isn't where the vector ends,
since it could have elements in the back with negative indexes.
Use vec.start()
and vec.end()
if you want to know the start and end indexes.
The total length is exactly equivalent to vec.len_back() + vec.len_front()
pub fn is_empty(&self) -> bool
[src]
pub fn len_back(&self) -> usize
[src]
Return the length of the back of the vector.
pub fn len_front(&self) -> usize
[src]
Return the length of the front of the vector
pub fn start(&self) -> isize
[src]
Give the (inclusive) start of the queue's elements. which may be negative if the queue's back isn't empty
This is exactly equivelant to -vec.back().len()
.
pub fn end(&self) -> isize
[src]
Give the (exclusive) end of the queue's elements, which may be less than the length if the queue's back contains some elements.
This is exactly equivalent to vec.front().len()
pub fn range(&self) -> Range<isize>
[src]
Return the [start, end)
range of the element indices,
equivalent to a tuple of (queue.start(), queue.end())
.
pub fn iter_entire(&self) -> Iter<'_, T>
[src]
Iterate over the entire vector, including both the back and front.
pub fn get<I: TwoSidedIndex<T>>(&self, index: I) -> Option<&I::Output>
[src]
pub fn get_mut<I: TwoSidedIndex<T>>(
&mut self,
index: I
) -> Option<&mut I::Output>
[src]
&mut self,
index: I
) -> Option<&mut I::Output>
pub unsafe fn get_unchecked<I: TwoSidedIndex<T>>(&self, index: I) -> &I::Output
[src]
Get a reference to value at the specified index
Safety
Undefined behavior if the index is out of bounds
pub unsafe fn get_unchecked_mut<I: TwoSidedIndex<T>>(
&mut self,
index: I
) -> &mut I::Output
[src]
&mut self,
index: I
) -> &mut I::Output
Get a mutable reference to value at the specified index
Safety
Undefined behavior if the index is out of bounds
pub fn start_ptr(&self) -> *mut T
[src]
Give a raw pointer to the start of the elements
pub fn middle_ptr(&self) -> *mut T
[src]
Give a raw pointer to the middle of the elements
pub fn end_ptr(&self) -> *mut T
[src]
pub fn split_at(&self, index: isize) -> (&[T], &[T])
[src]
pub fn clear(&mut self)
[src]
pub fn enumerate_back(&self) -> SignedEnumerate<Iter<'_, T>>ⓘNotable traits for SignedEnumerate<I>
impl<T, I: Iterator<Item = T>> Iterator for SignedEnumerate<I> type Item = (isize, T);
[src]
Notable traits for SignedEnumerate<I>
impl<T, I: Iterator<Item = T>> Iterator for SignedEnumerate<I> type Item = (isize, T);
Enumerate the indices and values of the elements in the back of the vector.
The primary advantage over regular enumeration is that it gives proper negative indices since the elements are in the back.
pub fn enumerate_front(&self) -> SignedEnumerate<Iter<'_, T>>ⓘNotable traits for SignedEnumerate<I>
impl<T, I: Iterator<Item = T>> Iterator for SignedEnumerate<I> type Item = (isize, T);
[src]
Notable traits for SignedEnumerate<I>
impl<T, I: Iterator<Item = T>> Iterator for SignedEnumerate<I> type Item = (isize, T);
Enumerate the indices and values of the elements in the front of the vector.
The only possible advantage over regular enumeration is that it
gives positive isize
indices for consistency with enumeration over the back.
pub fn enumerate(&self) -> SignedEnumerate<Iter<'_, T>>ⓘNotable traits for SignedEnumerate<I>
impl<T, I: Iterator<Item = T>> Iterator for SignedEnumerate<I> type Item = (isize, T);
[src]
Notable traits for SignedEnumerate<I>
impl<T, I: Iterator<Item = T>> Iterator for SignedEnumerate<I> type Item = (isize, T);
Enumerate the indices and values of each element in the front and back.
The primary advantage over regular enumeration is that it gives proper negative indices for elements that are in the back.
pub fn enumerate_mut(&mut self) -> SignedEnumerate<IterMut<'_, T>>ⓘNotable traits for SignedEnumerate<I>
impl<T, I: Iterator<Item = T>> Iterator for SignedEnumerate<I> type Item = (isize, T);
[src]
Notable traits for SignedEnumerate<I>
impl<T, I: Iterator<Item = T>> Iterator for SignedEnumerate<I> type Item = (isize, T);
Mutably enumerate the indices and values of each element in the front and back.
The primary advantage over regular enumeration is that it gives proper negative indices for elements that are in the back.
pub fn truncate_back(&mut self, len: usize)
[src]
pub fn truncate_front(&mut self, len: usize)
[src]
pub fn retain<F: FnMut(isize, &mut T) -> bool>(&mut self, mut pred: F)
[src]
pub fn retain_back<F: FnMut(isize, &mut T) -> bool>(&mut self, mut pred: F)
[src]
pub fn retain_front<F: FnMut(isize, &mut T) -> bool>(&mut self, mut pred: F)
[src]
pub fn drain_filter_back<F: FnMut(isize, &mut T) -> bool>(
&mut self,
pred: F
) -> DrainFilterBack<'_, T, F>ⓘNotable traits for DrainFilterBack<'a, T, F>
impl<'a, T: 'a, F: FnMut(isize, &mut T) -> bool> Iterator for DrainFilterBack<'a, T, F> type Item = T;
[src]
&mut self,
pred: F
) -> DrainFilterBack<'_, T, F>ⓘ
Notable traits for DrainFilterBack<'a, T, F>
impl<'a, T: 'a, F: FnMut(isize, &mut T) -> bool> Iterator for DrainFilterBack<'a, T, F> type Item = T;
pub fn drain_filter_front<F: FnMut(isize, &mut T) -> bool>(
&mut self,
pred: F
) -> DrainFilterFront<'_, T, F>ⓘNotable traits for DrainFilterFront<'a, T, F>
impl<'a, T: 'a, F: FnMut(isize, &mut T) -> bool> Iterator for DrainFilterFront<'a, T, F> type Item = T;
[src]
&mut self,
pred: F
) -> DrainFilterFront<'_, T, F>ⓘ
Notable traits for DrainFilterFront<'a, T, F>
impl<'a, T: 'a, F: FnMut(isize, &mut T) -> bool> Iterator for DrainFilterFront<'a, T, F> type Item = T;
Trait Implementations
impl<T: Clone> Clone for TwoSidedVec<T>
[src]
pub fn clone(&self) -> Self
[src]
pub fn clone_from(&mut self, source: &Self)
1.0.0[src]
impl<T: Debug> Debug for TwoSidedVec<T>
[src]
impl<T> Default for TwoSidedVec<T>
[src]
impl<T> Drop for TwoSidedVec<T>
[src]
impl<T: Eq> Eq for TwoSidedVec<T>
[src]
impl<T> From<Vec<T, Global>> for TwoSidedVec<T>
[src]
impl<T: Hash> Hash for TwoSidedVec<T>
[src]
pub fn hash<H: Hasher>(&self, state: &mut H)
[src]
pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
impl<T, I: TwoSidedIndex<T>> Index<I> for TwoSidedVec<T>
[src]
type Output = I::Output
The returned type after indexing.
pub fn index(&self, index: I) -> &I::Output
[src]
impl<T, I: TwoSidedIndex<T>> IndexMut<I> for TwoSidedVec<T>
[src]
impl<T: PartialEq<U>, U> PartialEq<TwoSidedVec<U>> for TwoSidedVec<T>
[src]
pub fn eq(&self, other: &TwoSidedVec<U>) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
impl<'a, T: Copy + 'a> TwoSidedExtend<&'a T> for TwoSidedVec<T>
[src]
pub fn extend_back<I: IntoIterator<Item = &'a T>>(&mut self, iter: I)
[src]
pub fn extend_front<I: IntoIterator<Item = &'a T>>(&mut self, iter: I)
[src]
impl<T> TwoSidedExtend<T> for TwoSidedVec<T>
[src]
pub fn extend_back<I: IntoIterator<Item = T>>(&mut self, iter: I)
[src]
pub fn extend_front<I: IntoIterator<Item = T>>(&mut self, iter: I)
[src]
Auto Trait Implementations
impl<T> RefUnwindSafe for TwoSidedVec<T> where
T: RefUnwindSafe,
[src]
T: RefUnwindSafe,
impl<T> !Send for TwoSidedVec<T>
[src]
impl<T> !Sync for TwoSidedVec<T>
[src]
impl<T> Unpin for TwoSidedVec<T> where
T: Unpin,
[src]
T: Unpin,
impl<T> UnwindSafe for TwoSidedVec<T> where
T: RefUnwindSafe + UnwindSafe,
[src]
T: RefUnwindSafe + UnwindSafe,
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
pub fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
pub fn to_owned(&self) -> T
[src]
pub fn clone_into(&self, target: &mut T)
[src]
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,