# [−][src]Struct two_sided_vec::TwoSidedVec

`pub struct TwoSidedVec<T> { /* fields omitted */ }`

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 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_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 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 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 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]

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

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]

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]

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]

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.

## Trait Implementations

### `impl<T, I: TwoSidedIndex<T>> Index<I> for TwoSidedVec<T>`[src]

#### `type Output = I::Output`

The returned type after indexing.

## Blanket Implementations

### `impl<T> ToOwned for T where    T: Clone, `[src]

#### `type Owned = T`

The resulting type after obtaining ownership.

### `impl<T, U> TryFrom<U> for T where    U: Into<T>, `[src]

#### `type Error = Infallible`

The type returned in the event of a conversion error.

### `impl<T, U> TryInto<U> for T where    U: TryFrom<T>, `[src]

#### `type Error = <U as TryFrom<T>>::Error`

The type returned in the event of a conversion error.