Struct AlignedBuffer 

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

Implementations

impl<T> AlignedBuffer<T>

pub fn new(capacity: usize) -> Result<Self>

pub fn with_alignment(capacity: usize, alignment: usize) -> Result<Self>

pub fn from_slice(data: &[T]) -> Result<Self>

where T: Copy,

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn capacity(&self) -> usize

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

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

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

pub fn push(&mut self, value: T) -> Result<()>

pub fn extend_from_slice(&mut self, data: &[T]) -> Result<()>

where T: Copy,

pub fn clear(&mut self)

pub fn resize(&mut self, new_len: usize, value: T) -> Result<()>

where T: Copy,

pub fn alignment(&self) -> usize

pub fn is_simd_aligned(&self) -> bool

pub fn to_vec_cloned(&self) -> Vec<T>

where T: Copy,

pub fn to_vec(self) -> Vec<T>

where T: Copy,

pub unsafe fn into_raw_parts(self) -> (*mut T, usize, usize, Layout)

Methods from Deref<Target = [T]>

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn first(&self) -> Option<&T>

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

pub fn split_first(&self) -> Option<(&T, &[T])>

pub fn split_first_mut(&mut self) -> Option<(&mut T, &mut [T])>

pub fn split_last(&self) -> Option<(&T, &[T])>

pub fn split_last_mut(&mut self) -> Option<(&mut T, &mut [T])>

pub fn last(&self) -> Option<&T>

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

pub fn first_chunk<const N: usize>(&self) -> Option<&[T; N]>

pub fn first_chunk_mut<const N: usize>(&mut self) -> Option<&mut [T; N]>

pub fn split_first_chunk<const N: usize>(&self) -> Option<(&[T; N], &[T])>

pub fn split_first_chunk_mut<const N: usize>( &mut self, ) -> Option<(&mut [T; N], &mut [T])>

pub fn split_last_chunk<const N: usize>(&self) -> Option<(&[T], &[T; N])>

pub fn split_last_chunk_mut<const N: usize>( &mut self, ) -> Option<(&mut [T], &mut [T; N])>

pub fn last_chunk<const N: usize>(&self) -> Option<&[T; N]>

pub fn last_chunk_mut<const N: usize>(&mut self) -> Option<&mut [T; N]>

pub fn get<I>(&self, index: I) -> Option<&<I as SliceIndex<[T]>>::Output>

where I: SliceIndex<[T]>,

pub fn get_mut<I>( &mut self, index: I, ) -> Option<&mut <I as SliceIndex<[T]>>::Output>

where I: SliceIndex<[T]>,

pub unsafe fn get_unchecked<I>( &self, index: I, ) -> &<I as SliceIndex<[T]>>::Output

where I: SliceIndex<[T]>,

pub unsafe fn get_unchecked_mut<I>( &mut self, index: I, ) -> &mut <I as SliceIndex<[T]>>::Output

where I: SliceIndex<[T]>,

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

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

pub fn as_ptr_range(&self) -> Range<*const T>

pub fn as_mut_ptr_range(&mut self) -> Range<*mut T>

pub fn as_array<const N: usize>(&self) -> Option<&[T; N]>

pub fn as_mut_array<const N: usize>(&mut self) -> Option<&mut [T; N]>

pub fn swap(&mut self, a: usize, b: usize)

pub unsafe fn swap_unchecked(&mut self, a: usize, b: usize)

🔬This is a nightly-only experimental API. (slice_swap_unchecked)

pub fn reverse(&mut self)

pub fn iter(&self) -> Iter<'_, T>

pub fn iter_mut(&mut self) -> IterMut<'_, T>

pub fn windows(&self, size: usize) -> Windows<'_, T>

pub fn chunks(&self, chunk_size: usize) -> Chunks<'_, T>

pub fn chunks_mut(&mut self, chunk_size: usize) -> ChunksMut<'_, T>

pub fn chunks_exact(&self, chunk_size: usize) -> ChunksExact<'_, T>

pub fn chunks_exact_mut(&mut self, chunk_size: usize) -> ChunksExactMut<'_, T>

pub unsafe fn as_chunks_unchecked<const N: usize>(&self) -> &[[T; N]]

pub fn as_chunks<const N: usize>(&self) -> (&[[T; N]], &[T])

pub fn as_rchunks<const N: usize>(&self) -> (&[T], &[[T; N]])

pub unsafe fn as_chunks_unchecked_mut<const N: usize>( &mut self, ) -> &mut [[T; N]]

pub fn as_chunks_mut<const N: usize>(&mut self) -> (&mut [[T; N]], &mut [T])

pub fn as_rchunks_mut<const N: usize>(&mut self) -> (&mut [T], &mut [[T; N]])

pub fn array_windows<const N: usize>(&self) -> ArrayWindows<'_, T, N>

pub fn rchunks(&self, chunk_size: usize) -> RChunks<'_, T>

pub fn rchunks_mut(&mut self, chunk_size: usize) -> RChunksMut<'_, T>

pub fn rchunks_exact(&self, chunk_size: usize) -> RChunksExact<'_, T>

pub fn rchunks_exact_mut(&mut self, chunk_size: usize) -> RChunksExactMut<'_, T>

pub fn chunk_by<F>(&self, pred: F) -> ChunkBy<'_, T, F>

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

pub fn chunk_by_mut<F>(&mut self, pred: F) -> ChunkByMut<'_, T, F>

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

pub fn split_at(&self, mid: usize) -> (&[T], &[T])

pub fn split_at_mut(&mut self, mid: usize) -> (&mut [T], &mut [T])

pub unsafe fn split_at_unchecked(&self, mid: usize) -> (&[T], &[T])

pub unsafe fn split_at_mut_unchecked( &mut self, mid: usize, ) -> (&mut [T], &mut [T])

pub fn split_at_checked(&self, mid: usize) -> Option<(&[T], &[T])>

pub fn split_at_mut_checked( &mut self, mid: usize, ) -> Option<(&mut [T], &mut [T])>

pub fn split<F>(&self, pred: F) -> Split<'_, T, F>

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

pub fn split_mut<F>(&mut self, pred: F) -> SplitMut<'_, T, F>

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

pub fn split_inclusive<F>(&self, pred: F) -> SplitInclusive<'_, T, F>

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

pub fn split_inclusive_mut<F>(&mut self, pred: F) -> SplitInclusiveMut<'_, T, F>

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

pub fn rsplit<F>(&self, pred: F) -> RSplit<'_, T, F>

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

pub fn rsplit_mut<F>(&mut self, pred: F) -> RSplitMut<'_, T, F>

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

pub fn splitn<F>(&self, n: usize, pred: F) -> SplitN<'_, T, F>

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

pub fn splitn_mut<F>(&mut self, n: usize, pred: F) -> SplitNMut<'_, T, F>

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

pub fn rsplitn<F>(&self, n: usize, pred: F) -> RSplitN<'_, T, F>

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

pub fn rsplitn_mut<F>(&mut self, n: usize, pred: F) -> RSplitNMut<'_, T, F>

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

pub fn split_once<F>(&self, pred: F) -> Option<(&[T], &[T])>

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

🔬This is a nightly-only experimental API. (slice_split_once)

pub fn rsplit_once<F>(&self, pred: F) -> Option<(&[T], &[T])>

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

🔬This is a nightly-only experimental API. (slice_split_once)

pub fn contains(&self, x: &T) -> bool

where T: PartialEq,

pub fn starts_with(&self, needle: &[T]) -> bool

where T: PartialEq,

pub fn ends_with(&self, needle: &[T]) -> bool

where T: PartialEq,

pub fn strip_prefix<P>(&self, prefix: &P) -> Option<&[T]>

where P: SlicePattern<Item = T> + ?Sized, T: PartialEq,

pub fn strip_suffix<P>(&self, suffix: &P) -> Option<&[T]>

where P: SlicePattern<Item = T> + ?Sized, T: PartialEq,

pub fn strip_circumfix<S, P>(&self, prefix: &P, suffix: &S) -> Option<&[T]>

where T: PartialEq, S: SlicePattern<Item = T> + ?Sized, P: SlicePattern<Item = T> + ?Sized,

🔬This is a nightly-only experimental API. (strip_circumfix)

pub fn trim_prefix<P>(&self, prefix: &P) -> &[T]

where P: SlicePattern<Item = T> + ?Sized, T: PartialEq,

🔬This is a nightly-only experimental API. (trim_prefix_suffix)

pub fn trim_suffix<P>(&self, suffix: &P) -> &[T]

where P: SlicePattern<Item = T> + ?Sized, T: PartialEq,

🔬This is a nightly-only experimental API. (trim_prefix_suffix)

pub fn binary_search(&self, x: &T) -> Result<usize, usize>

where T: Ord,

pub fn binary_search_by<'a, F>(&'a self, f: F) -> Result<usize, usize>

where F: FnMut(&'a T) -> Ordering,

pub fn binary_search_by_key<'a, B, F>( &'a self, b: &B, f: F, ) -> Result<usize, usize>

where F: FnMut(&'a T) -> B, B: Ord,

pub fn sort_unstable(&mut self)

where T: Ord,

pub fn sort_unstable_by<F>(&mut self, compare: F)

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

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

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

pub fn partial_sort_unstable<R>(&mut self, range: R)

where T: Ord, R: RangeBounds<usize>,

🔬This is a nightly-only experimental API. (slice_partial_sort_unstable)

pub fn partial_sort_unstable_by<F, R>(&mut self, range: R, compare: F)

where F: FnMut(&T, &T) -> Ordering, R: RangeBounds<usize>,

🔬This is a nightly-only experimental API. (slice_partial_sort_unstable)

pub fn partial_sort_unstable_by_key<K, F, R>(&mut self, range: R, f: F)

where F: FnMut(&T) -> K, K: Ord, R: RangeBounds<usize>,

🔬This is a nightly-only experimental API. (slice_partial_sort_unstable)

pub fn select_nth_unstable( &mut self, index: usize, ) -> (&mut [T], &mut T, &mut [T])

where T: Ord,

pub fn select_nth_unstable_by<F>( &mut self, index: usize, compare: F, ) -> (&mut [T], &mut T, &mut [T])

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

pub fn select_nth_unstable_by_key<K, F>( &mut self, index: usize, f: F, ) -> (&mut [T], &mut T, &mut [T])

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

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

where T: PartialEq,

🔬This is a nightly-only experimental API. (slice_partition_dedup)

pub fn partition_dedup_by<F>(&mut self, same_bucket: F) -> (&mut [T], &mut [T])

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

🔬This is a nightly-only experimental API. (slice_partition_dedup)

pub fn partition_dedup_by_key<K, F>(&mut self, key: F) -> (&mut [T], &mut [T])

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

🔬This is a nightly-only experimental API. (slice_partition_dedup)

pub fn rotate_left(&mut self, mid: usize)

pub fn rotate_right(&mut self, k: usize)

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

where T: Clone,

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

where F: FnMut() -> T,

pub fn clone_from_slice(&mut self, src: &[T])

where T: Clone,

pub fn copy_from_slice(&mut self, src: &[T])

where T: Copy,

pub fn copy_within<R>(&mut self, src: R, dest: usize)

where R: RangeBounds<usize>, T: Copy,

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

pub unsafe fn align_to<U>(&self) -> (&[T], &[U], &[T])

pub unsafe fn align_to_mut<U>(&mut self) -> (&mut [T], &mut [U], &mut [T])

pub fn as_simd<const LANES: usize>(&self) -> (&[T], &[Simd<T, LANES>], &[T])

where Simd<T, LANES>: AsRef<[T; LANES]>, T: SimdElement, LaneCount<LANES>: SupportedLaneCount,

🔬This is a nightly-only experimental API. (portable_simd)

pub fn as_simd_mut<const LANES: usize>( &mut self, ) -> (&mut [T], &mut [Simd<T, LANES>], &mut [T])

where Simd<T, LANES>: AsMut<[T; LANES]>, T: SimdElement, LaneCount<LANES>: SupportedLaneCount,

🔬This is a nightly-only experimental API. (portable_simd)

pub fn is_sorted(&self) -> bool

where T: PartialOrd,

pub fn is_sorted_by<'a, F>(&'a self, compare: F) -> bool

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

pub fn is_sorted_by_key<'a, F, K>(&'a self, f: F) -> bool

where F: FnMut(&'a T) -> K, K: PartialOrd,

pub fn partition_point<P>(&self, pred: P) -> usize

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

pub fn split_off<'a, R>(self: &mut &'a [T], range: R) -> Option<&'a [T]>

where R: OneSidedRange<usize>,

pub fn split_off_mut<'a, R>( self: &mut &'a mut [T], range: R, ) -> Option<&'a mut [T]>

where R: OneSidedRange<usize>,

pub fn split_off_first<'a>(self: &mut &'a [T]) -> Option<&'a T>

pub fn split_off_first_mut<'a>(self: &mut &'a mut [T]) -> Option<&'a mut T>

pub fn split_off_last<'a>(self: &mut &'a [T]) -> Option<&'a T>

pub fn split_off_last_mut<'a>(self: &mut &'a mut [T]) -> Option<&'a mut T>

pub unsafe fn get_disjoint_unchecked_mut<I, const N: usize>( &mut self, indices: [I; N], ) -> [&mut <I as SliceIndex<[T]>>::Output; N]

where I: GetDisjointMutIndex + SliceIndex<[T]>,

pub fn get_disjoint_mut<I, const N: usize>( &mut self, indices: [I; N], ) -> Result<[&mut <I as SliceIndex<[T]>>::Output; N], GetDisjointMutError>

where I: GetDisjointMutIndex + SliceIndex<[T]>,

pub fn element_offset(&self, element: &T) -> Option<usize>

pub fn subslice_range(&self, subslice: &[T]) -> Option<Range<usize>>

🔬This is a nightly-only experimental API. (substr_range)

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

🔬This is a nightly-only experimental API. (str_as_str)

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

🔬This is a nightly-only experimental API. (str_as_str)

pub fn sort(&mut self)

where T: Ord,

pub fn sort_by<F>(&mut self, compare: F)

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

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

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

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

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

pub fn to_vec(&self) -> Vec<T>

where T: Clone,

pub fn to_vec_in<A>(&self, alloc: A) -> Vec<T, A>

where A: Allocator, T: Clone,

🔬This is a nightly-only experimental API. (allocator_api)

pub fn repeat(&self, n: usize) -> Vec<T>

where T: Copy,

pub fn concat<Item>(&self) -> <[T] as Concat<Item>>::Output

where [T]: Concat<Item>, Item: ?Sized,

pub fn join<Separator>( &self, sep: Separator, ) -> <[T] as Join<Separator>>::Output

where [T]: Join<Separator>,

pub fn connect<Separator>( &self, sep: Separator, ) -> <[T] as Join<Separator>>::Output

where [T]: Join<Separator>,

👎Deprecated since 1.3.0: renamed to join

Trait Implementations

impl<T> Deref for AlignedBuffer<T>

type Target = [T]

fn deref(&self) -> &Self::Target

impl<T> DerefMut for AlignedBuffer<T>

fn deref_mut(&mut self) -> &mut Self::Target

impl<T> Drop for AlignedBuffer<T>

fn drop(&mut self)