Trait parallel_vec::param::ParallelVecParam

pub unsafe trait ParallelVecParam: Sized + Sealed {
    type Storage: Copy;
    type Ptr: Copy;
    type Offsets;
    type Ref;
    type RefMut;
    type Vecs;
    type Slices;
    type SlicesMut;
    type Iters;
    type ItersMut;
    fn dangling() -> Self::Storage;
    fn as_ptr(storage: Self::Storage) -> Self::Ptr;
    unsafe fn alloc(capacity: usize) -> Self::Storage;
    unsafe fn dealloc(storage: &mut Self::Storage, capacity: usize);
    fn layout_for_capacity(capacity: usize) -> MemoryLayout<Self>;
    fn get_vec_len(vecs: &Self::Vecs) -> Option<usize>;
    unsafe fn get_vec_ptrs(vecs: &mut Self::Vecs) -> Self::Ptr;
    unsafe fn add(base: Self::Ptr, offset: usize) -> Self::Ptr;
    unsafe fn copy_to(src: Self::Ptr, dst: Self::Ptr, size: usize);
    unsafe fn copy_to_nonoverlapping(
        src: Self::Ptr, 
        dst: Self::Ptr, 
        size: usize
    );
    unsafe fn as_slices<'a>(ptr: Self::Ptr, len: usize) -> Self::Slices;
    unsafe fn as_slices_mut<'a>(ptr: Self::Ptr, len: usize) -> Self::SlicesMut;
    fn iters<'a>(slices: Self::Slices) -> Self::Iters;
    fn iters_mut<'a>(slices: Self::SlicesMut) -> Self::ItersMut;
    fn reverse(ptr: Self::SlicesMut);
    unsafe fn as_ref<'a>(ptr: Self::Ptr) -> Self::Ref;
    unsafe fn as_mut<'a>(ptr: Self::Ptr) -> Self::RefMut;
    unsafe fn read(ptr: Self::Ptr) -> Self;
    unsafe fn write(ptr: Self::Ptr, value: Self);
    unsafe fn swap(a: Self::Ptr, other: Self::Ptr);
    unsafe fn drop(ptr: Self::Ptr);
}

This trait contains the basic operations for creating variadic parallel vector implementations.

This trait is sealed and cannot be implemented outside of parallel_vec.

This trait has blanket implementations of all tuples of up to size 12 of all types that are 'static.

Safety

None of the associated functions can panic.

Associated Types

type Storage: Copy

A set of NonNull pointers of the parameter. This is the main backing storage pointers for ParallelVec.

type Ptr: Copy

A set of pointers of the parameter.

type Offsets

A set of memory offsets of the parameter.

type Ref

A set of immutable references of the parameter.

type RefMut

A set of mutable references of the parameter.

type Vecs

A set of Vec<T>s of the parameter.

type Slices

A set of mutable slice references of the parameter.

type SlicesMut

A set of mutable slice references of the parameter.

type Iters

A set of iterators of immutable references of the parameter.

type ItersMut

A set of iterators of mutable references of the parameter.

Required methods

fn dangling() -> Self::Storage

Creates a set of dangling pointers for the given types.

fn as_ptr(storage: Self::Storage) -> Self::Ptr

Converts a set of NonNulls into their associated pointer types.

unsafe fn alloc(capacity: usize) -> Self::Storage

Allocates a buffer for a given capacity.

Safety

Capacity should be non-zero.

unsafe fn dealloc(storage: &mut Self::Storage, capacity: usize)

Deallocates a buffer allocated from alloc.

Safety

storage must have been allocated from alloc alongside the provided capacity.

fn layout_for_capacity(capacity: usize) -> MemoryLayout<Self>

Creates a layout for a ParallelVec for a given capacity

fn get_vec_len(vecs: &Self::Vecs) -> Option<usize>

Gets the legnth for the associated Vecs.

Returns None if not all of the Vecs share the same length.

unsafe fn get_vec_ptrs(vecs: &mut Self::Vecs) -> Self::Ptr

Gets the underlying pointers for the associated Vecs.

Safety

The provided Vecs must be correctly allocated.

unsafe fn add(base: Self::Ptr, offset: usize) -> Self::Ptr

Adds offset to all of the pointers in base.

Safety

base and base + offset must be valid non-null pointers for the associated types.

unsafe fn copy_to(src: Self::Ptr, dst: Self::Ptr, size: usize)

Copies size elements from the continguous memory pointed to by src into dst.

Safety

• src and dst must be a valid, non-null pointer for the associated types.
• size must be approriately set for the allocation that both src and dst point to.

unsafe fn copy_to_nonoverlapping(src: Self::Ptr, dst: Self::Ptr, size: usize)

Copies size elements from the continguous memory pointed to by src into dst.

Safety

• src and dst must be a valid, non-null pointer for the associated types.
• size must be approriately set for the allocation that both src and dst point to.
• src..src + size must not overlap with the memory range of dst..dst + size.

unsafe fn as_slices<'a>(ptr: Self::Ptr, len: usize) -> Self::Slices

Creates a set of immutable slices from ptr and a provided length.

Safety

ptr must be a valid, non-null pointer. len must be approriately set for the allocation that ptr points to.

unsafe fn as_slices_mut<'a>(ptr: Self::Ptr, len: usize) -> Self::SlicesMut

Creates a set of mutable slices from ptr and a provided length.

Safety

ptr must be a valid, non-null pointer. len must be approriately set for the allocation that ptr points to.

fn iters<'a>(slices: Self::Slices) -> Self::Iters

Creates a set of iterators from slices.

fn iters_mut<'a>(slices: Self::SlicesMut) -> Self::ItersMut

Creates a set of iterators of mutable references from slices.

fn reverse(ptr: Self::SlicesMut)

Reverses the order of elements in the slice, in place.

unsafe fn as_ref<'a>(ptr: Self::Ptr) -> Self::Ref

Converts ptr into a set of immutable references.

Safety

ptr must be a valid, non-null pointer.

unsafe fn as_mut<'a>(ptr: Self::Ptr) -> Self::RefMut

Converts ptr into a set of mutable references.

Safety

ptr must be a valid, non-null pointer.

unsafe fn read(ptr: Self::Ptr) -> Self

Reads the values to pointed to by ptr.

Safety

ptr must be a valid, non-null pointer.

unsafe fn write(ptr: Self::Ptr, value: Self)

Writes value to ptr.

Safety

ptr must be a valid, non-null pointer.

unsafe fn swap(a: Self::Ptr, other: Self::Ptr)

Swaps the values pointed to by the provided pointers.

Safety

Both a and b must be valid for all of it’s consitutent member pointers.

unsafe fn drop(ptr: Self::Ptr)

Drops the values pointed to by the pointers.

Safety

The caller must ensure that the values pointed to by the pointers have not already been dropped prior.

Implementations on Foreign Types

impl<T1: 'static, T2: 'static> ParallelVecParam for (T1, T2)

type Storage = (NonNull<T1>, NonNull<T2>)

type Ref = (&'a T1, &'a T2)

type RefMut = (&'a mut T1, &'a mut T2)

type Slices = (&'a [T1], &'a [T2])

type SlicesMut = (&'a mut [T1], &'a mut [T2])

type Vecs = (Vec<T1>, Vec<T2>)

type Ptr = (*mut T1, *mut T2)

type Offsets = (usize, usize)

type Iters = (Iter<'a, T1>, Iter<'a, T2>)

type ItersMut = (IterMut<'a, T1>, IterMut<'a, T2>)

fn dangling() -> Self::Storage

fn as_ptr(storage: Self::Storage) -> Self::Ptr

unsafe fn alloc(capacity: usize) -> Self::Storage

unsafe fn dealloc(storage: &mut Self::Storage, capacity: usize)

fn layout_for_capacity(capacity: usize) -> MemoryLayout<Self>

unsafe fn add(base: Self::Ptr, offset: usize) -> Self::Ptr

unsafe fn copy_to(src: Self::Ptr, dst: Self::Ptr, len: usize)

unsafe fn copy_to_nonoverlapping(src: Self::Ptr, dst: Self::Ptr, len: usize)

unsafe fn as_slices<'a>(ptr: Self::Ptr, len: usize) -> Self::Slices

unsafe fn as_slices_mut<'a>(ptr: Self::Ptr, len: usize) -> Self::SlicesMut

fn iters<'a>(slices: Self::Slices) -> Self::Iters

fn iters_mut<'a>(slices: Self::SlicesMut) -> Self::ItersMut

fn reverse<'a>(slices: Self::SlicesMut)

unsafe fn as_ref<'a>(ptr: Self::Ptr) -> Self::Ref

unsafe fn as_mut<'a>(ptr: Self::Ptr) -> Self::RefMut

unsafe fn read(ptr: Self::Ptr) -> Self

unsafe fn write(ptr: Self::Ptr, value: Self)

unsafe fn swap(a: Self::Ptr, b: Self::Ptr)

unsafe fn drop(ptr: Self::Ptr)

fn get_vec_len(vecs: &Self::Vecs) -> Option<usize>

unsafe fn get_vec_ptrs(vecs: &mut Self::Vecs) -> Self::Ptr

impl<T1: 'static, T2: 'static, T3: 'static> ParallelVecParam for (T1, T2, T3)

type Storage = (NonNull<T1>, NonNull<T2>, NonNull<T3>)

type Ref = (&'a T1, &'a T2, &'a T3)

type RefMut = (&'a mut T1, &'a mut T2, &'a mut T3)

type Slices = (&'a [T1], &'a [T2], &'a [T3])

type SlicesMut = (&'a mut [T1], &'a mut [T2], &'a mut [T3])

type Vecs = (Vec<T1>, Vec<T2>, Vec<T3>)

type Ptr = (*mut T1, *mut T2, *mut T3)

type Offsets = (usize, usize, usize)

type Iters = (Iter<'a, T1>, Iter<'a, T2>, Iter<'a, T3>)

type ItersMut = (IterMut<'a, T1>, IterMut<'a, T2>, IterMut<'a, T3>)

fn dangling() -> Self::Storage

fn as_ptr(storage: Self::Storage) -> Self::Ptr

unsafe fn alloc(capacity: usize) -> Self::Storage

unsafe fn dealloc(storage: &mut Self::Storage, capacity: usize)

fn layout_for_capacity(capacity: usize) -> MemoryLayout<Self>

unsafe fn add(base: Self::Ptr, offset: usize) -> Self::Ptr

unsafe fn copy_to(src: Self::Ptr, dst: Self::Ptr, len: usize)

unsafe fn copy_to_nonoverlapping(src: Self::Ptr, dst: Self::Ptr, len: usize)

unsafe fn as_slices<'a>(ptr: Self::Ptr, len: usize) -> Self::Slices

unsafe fn as_slices_mut<'a>(ptr: Self::Ptr, len: usize) -> Self::SlicesMut

fn iters<'a>(slices: Self::Slices) -> Self::Iters

fn iters_mut<'a>(slices: Self::SlicesMut) -> Self::ItersMut

fn reverse<'a>(slices: Self::SlicesMut)

unsafe fn as_ref<'a>(ptr: Self::Ptr) -> Self::Ref

unsafe fn as_mut<'a>(ptr: Self::Ptr) -> Self::RefMut

unsafe fn read(ptr: Self::Ptr) -> Self

unsafe fn write(ptr: Self::Ptr, value: Self)

unsafe fn swap(a: Self::Ptr, b: Self::Ptr)

unsafe fn drop(ptr: Self::Ptr)

fn get_vec_len(vecs: &Self::Vecs) -> Option<usize>

unsafe fn get_vec_ptrs(vecs: &mut Self::Vecs) -> Self::Ptr

impl<T1: 'static, T2: 'static, T3: 'static, T4: 'static> ParallelVecParam for (T1, T2, T3, T4)

type Storage = (NonNull<T1>, NonNull<T2>, NonNull<T3>, NonNull<T4>)

type Ref = (&'a T1, &'a T2, &'a T3, &'a T4)

type RefMut = (&'a mut T1, &'a mut T2, &'a mut T3, &'a mut T4)

type Slices = (&'a [T1], &'a [T2], &'a [T3], &'a [T4])

type SlicesMut = (&'a mut [T1], &'a mut [T2], &'a mut [T3], &'a mut [T4])

type Vecs = (Vec<T1>, Vec<T2>, Vec<T3>, Vec<T4>)

type Ptr = (*mut T1, *mut T2, *mut T3, *mut T4)

type Offsets = (usize, usize, usize, usize)

type Iters = (Iter<'a, T1>, Iter<'a, T2>, Iter<'a, T3>, Iter<'a, T4>)

type ItersMut = (IterMut<'a, T1>, IterMut<'a, T2>, IterMut<'a, T3>, IterMut<'a, T4>)

fn dangling() -> Self::Storage

fn as_ptr(storage: Self::Storage) -> Self::Ptr

unsafe fn alloc(capacity: usize) -> Self::Storage

unsafe fn dealloc(storage: &mut Self::Storage, capacity: usize)

fn layout_for_capacity(capacity: usize) -> MemoryLayout<Self>

unsafe fn add(base: Self::Ptr, offset: usize) -> Self::Ptr

unsafe fn copy_to(src: Self::Ptr, dst: Self::Ptr, len: usize)

unsafe fn copy_to_nonoverlapping(src: Self::Ptr, dst: Self::Ptr, len: usize)

unsafe fn as_slices<'a>(ptr: Self::Ptr, len: usize) -> Self::Slices

unsafe fn as_slices_mut<'a>(ptr: Self::Ptr, len: usize) -> Self::SlicesMut

fn iters<'a>(slices: Self::Slices) -> Self::Iters

fn iters_mut<'a>(slices: Self::SlicesMut) -> Self::ItersMut

fn reverse<'a>(slices: Self::SlicesMut)

unsafe fn as_ref<'a>(ptr: Self::Ptr) -> Self::Ref

unsafe fn as_mut<'a>(ptr: Self::Ptr) -> Self::RefMut

unsafe fn read(ptr: Self::Ptr) -> Self

unsafe fn write(ptr: Self::Ptr, value: Self)

unsafe fn swap(a: Self::Ptr, b: Self::Ptr)

unsafe fn drop(ptr: Self::Ptr)

fn get_vec_len(vecs: &Self::Vecs) -> Option<usize>

unsafe fn get_vec_ptrs(vecs: &mut Self::Vecs) -> Self::Ptr

impl<T1: 'static, T2: 'static, T3: 'static, T4: 'static, T5: 'static> ParallelVecParam for (T1, T2, T3, T4, T5)

type Storage = (NonNull<T1>, NonNull<T2>, NonNull<T3>, NonNull<T4>, NonNull<T5>)

type Ref = (&'a T1, &'a T2, &'a T3, &'a T4, &'a T5)

type RefMut = (&'a mut T1, &'a mut T2, &'a mut T3, &'a mut T4, &'a mut T5)

type Slices = (&'a [T1], &'a [T2], &'a [T3], &'a [T4], &'a [T5])

type SlicesMut = (&'a mut [T1], &'a mut [T2], &'a mut [T3], &'a mut [T4], &'a mut [T5])

type Vecs = (Vec<T1>, Vec<T2>, Vec<T3>, Vec<T4>, Vec<T5>)

type Ptr = (*mut T1, *mut T2, *mut T3, *mut T4, *mut T5)

type Offsets = (usize, usize, usize, usize, usize)

type Iters = (Iter<'a, T1>, Iter<'a, T2>, Iter<'a, T3>, Iter<'a, T4>, Iter<'a, T5>)

type ItersMut = (IterMut<'a, T1>, IterMut<'a, T2>, IterMut<'a, T3>, IterMut<'a, T4>, IterMut<'a, T5>)

fn dangling() -> Self::Storage

fn as_ptr(storage: Self::Storage) -> Self::Ptr

unsafe fn alloc(capacity: usize) -> Self::Storage

unsafe fn dealloc(storage: &mut Self::Storage, capacity: usize)

fn layout_for_capacity(capacity: usize) -> MemoryLayout<Self>

unsafe fn add(base: Self::Ptr, offset: usize) -> Self::Ptr

unsafe fn copy_to(src: Self::Ptr, dst: Self::Ptr, len: usize)

unsafe fn copy_to_nonoverlapping(src: Self::Ptr, dst: Self::Ptr, len: usize)

unsafe fn as_slices<'a>(ptr: Self::Ptr, len: usize) -> Self::Slices

unsafe fn as_slices_mut<'a>(ptr: Self::Ptr, len: usize) -> Self::SlicesMut

fn iters<'a>(slices: Self::Slices) -> Self::Iters

fn iters_mut<'a>(slices: Self::SlicesMut) -> Self::ItersMut

fn reverse<'a>(slices: Self::SlicesMut)

unsafe fn as_ref<'a>(ptr: Self::Ptr) -> Self::Ref

unsafe fn as_mut<'a>(ptr: Self::Ptr) -> Self::RefMut

unsafe fn read(ptr: Self::Ptr) -> Self

unsafe fn write(ptr: Self::Ptr, value: Self)

unsafe fn swap(a: Self::Ptr, b: Self::Ptr)

unsafe fn drop(ptr: Self::Ptr)

fn get_vec_len(vecs: &Self::Vecs) -> Option<usize>

unsafe fn get_vec_ptrs(vecs: &mut Self::Vecs) -> Self::Ptr

impl<T1: 'static, T2: 'static, T3: 'static, T4: 'static, T5: 'static, T6: 'static> ParallelVecParam for (T1, T2, T3, T4, T5, T6)

type Storage = (NonNull<T1>, NonNull<T2>, NonNull<T3>, NonNull<T4>, NonNull<T5>, NonNull<T6>)

type Ref = (&'a T1, &'a T2, &'a T3, &'a T4, &'a T5, &'a T6)

type RefMut = (&'a mut T1, &'a mut T2, &'a mut T3, &'a mut T4, &'a mut T5, &'a mut T6)

type Slices = (&'a [T1], &'a [T2], &'a [T3], &'a [T4], &'a [T5], &'a [T6])

type SlicesMut = (&'a mut [T1], &'a mut [T2], &'a mut [T3], &'a mut [T4], &'a mut [T5], &'a mut [T6])

type Vecs = (Vec<T1>, Vec<T2>, Vec<T3>, Vec<T4>, Vec<T5>, Vec<T6>)

type Ptr = (*mut T1, *mut T2, *mut T3, *mut T4, *mut T5, *mut T6)

type Offsets = (usize, usize, usize, usize, usize, usize)

type Iters = (Iter<'a, T1>, Iter<'a, T2>, Iter<'a, T3>, Iter<'a, T4>, Iter<'a, T5>, Iter<'a, T6>)

type ItersMut = (IterMut<'a, T1>, IterMut<'a, T2>, IterMut<'a, T3>, IterMut<'a, T4>, IterMut<'a, T5>, IterMut<'a, T6>)

fn dangling() -> Self::Storage

fn as_ptr(storage: Self::Storage) -> Self::Ptr

unsafe fn alloc(capacity: usize) -> Self::Storage

unsafe fn dealloc(storage: &mut Self::Storage, capacity: usize)

fn layout_for_capacity(capacity: usize) -> MemoryLayout<Self>

unsafe fn add(base: Self::Ptr, offset: usize) -> Self::Ptr

unsafe fn copy_to(src: Self::Ptr, dst: Self::Ptr, len: usize)

unsafe fn copy_to_nonoverlapping(src: Self::Ptr, dst: Self::Ptr, len: usize)

unsafe fn as_slices<'a>(ptr: Self::Ptr, len: usize) -> Self::Slices

unsafe fn as_slices_mut<'a>(ptr: Self::Ptr, len: usize) -> Self::SlicesMut

fn iters<'a>(slices: Self::Slices) -> Self::Iters

fn iters_mut<'a>(slices: Self::SlicesMut) -> Self::ItersMut

fn reverse<'a>(slices: Self::SlicesMut)

unsafe fn as_ref<'a>(ptr: Self::Ptr) -> Self::Ref

unsafe fn as_mut<'a>(ptr: Self::Ptr) -> Self::RefMut

unsafe fn read(ptr: Self::Ptr) -> Self

unsafe fn write(ptr: Self::Ptr, value: Self)

unsafe fn swap(a: Self::Ptr, b: Self::Ptr)

unsafe fn drop(ptr: Self::Ptr)

fn get_vec_len(vecs: &Self::Vecs) -> Option<usize>

unsafe fn get_vec_ptrs(vecs: &mut Self::Vecs) -> Self::Ptr

impl<T1: 'static, T2: 'static, T3: 'static, T4: 'static, T5: 'static, T6: 'static, T7: 'static> ParallelVecParam for (T1, T2, T3, T4, T5, T6, T7)

type Storage = (NonNull<T1>, NonNull<T2>, NonNull<T3>, NonNull<T4>, NonNull<T5>, NonNull<T6>, NonNull<T7>)

type Ref = (&'a T1, &'a T2, &'a T3, &'a T4, &'a T5, &'a T6, &'a T7)

type RefMut = (&'a mut T1, &'a mut T2, &'a mut T3, &'a mut T4, &'a mut T5, &'a mut T6, &'a mut T7)

type Slices = (&'a [T1], &'a [T2], &'a [T3], &'a [T4], &'a [T5], &'a [T6], &'a [T7])

type SlicesMut = (&'a mut [T1], &'a mut [T2], &'a mut [T3], &'a mut [T4], &'a mut [T5], &'a mut [T6], &'a mut [T7])

type Vecs = (Vec<T1>, Vec<T2>, Vec<T3>, Vec<T4>, Vec<T5>, Vec<T6>, Vec<T7>)

type Ptr = (*mut T1, *mut T2, *mut T3, *mut T4, *mut T5, *mut T6, *mut T7)

type Offsets = (usize, usize, usize, usize, usize, usize, usize)

type Iters = (Iter<'a, T1>, Iter<'a, T2>, Iter<'a, T3>, Iter<'a, T4>, Iter<'a, T5>, Iter<'a, T6>, Iter<'a, T7>)

type ItersMut = (IterMut<'a, T1>, IterMut<'a, T2>, IterMut<'a, T3>, IterMut<'a, T4>, IterMut<'a, T5>, IterMut<'a, T6>, IterMut<'a, T7>)

fn dangling() -> Self::Storage

fn as_ptr(storage: Self::Storage) -> Self::Ptr

unsafe fn alloc(capacity: usize) -> Self::Storage

unsafe fn dealloc(storage: &mut Self::Storage, capacity: usize)

fn layout_for_capacity(capacity: usize) -> MemoryLayout<Self>

unsafe fn add(base: Self::Ptr, offset: usize) -> Self::Ptr

unsafe fn copy_to(src: Self::Ptr, dst: Self::Ptr, len: usize)

unsafe fn copy_to_nonoverlapping(src: Self::Ptr, dst: Self::Ptr, len: usize)

unsafe fn as_slices<'a>(ptr: Self::Ptr, len: usize) -> Self::Slices

unsafe fn as_slices_mut<'a>(ptr: Self::Ptr, len: usize) -> Self::SlicesMut

fn iters<'a>(slices: Self::Slices) -> Self::Iters

fn iters_mut<'a>(slices: Self::SlicesMut) -> Self::ItersMut

fn reverse<'a>(slices: Self::SlicesMut)

unsafe fn as_ref<'a>(ptr: Self::Ptr) -> Self::Ref

unsafe fn as_mut<'a>(ptr: Self::Ptr) -> Self::RefMut

unsafe fn read(ptr: Self::Ptr) -> Self

unsafe fn write(ptr: Self::Ptr, value: Self)

unsafe fn swap(a: Self::Ptr, b: Self::Ptr)

unsafe fn drop(ptr: Self::Ptr)

fn get_vec_len(vecs: &Self::Vecs) -> Option<usize>

unsafe fn get_vec_ptrs(vecs: &mut Self::Vecs) -> Self::Ptr

impl<T1: 'static, T2: 'static, T3: 'static, T4: 'static, T5: 'static, T6: 'static, T7: 'static, T8: 'static> ParallelVecParam for (T1, T2, T3, T4, T5, T6, T7, T8)

type Storage = (NonNull<T1>, NonNull<T2>, NonNull<T3>, NonNull<T4>, NonNull<T5>, NonNull<T6>, NonNull<T7>, NonNull<T8>)

type Ref = (&'a T1, &'a T2, &'a T3, &'a T4, &'a T5, &'a T6, &'a T7, &'a T8)

type RefMut = (&'a mut T1, &'a mut T2, &'a mut T3, &'a mut T4, &'a mut T5, &'a mut T6, &'a mut T7, &'a mut T8)

type Slices = (&'a [T1], &'a [T2], &'a [T3], &'a [T4], &'a [T5], &'a [T6], &'a [T7], &'a [T8])

type SlicesMut = (&'a mut [T1], &'a mut [T2], &'a mut [T3], &'a mut [T4], &'a mut [T5], &'a mut [T6], &'a mut [T7], &'a mut [T8])

type Vecs = (Vec<T1>, Vec<T2>, Vec<T3>, Vec<T4>, Vec<T5>, Vec<T6>, Vec<T7>, Vec<T8>)

type Ptr = (*mut T1, *mut T2, *mut T3, *mut T4, *mut T5, *mut T6, *mut T7, *mut T8)

type Offsets = (usize, usize, usize, usize, usize, usize, usize, usize)

type Iters = (Iter<'a, T1>, Iter<'a, T2>, Iter<'a, T3>, Iter<'a, T4>, Iter<'a, T5>, Iter<'a, T6>, Iter<'a, T7>, Iter<'a, T8>)

type ItersMut = (IterMut<'a, T1>, IterMut<'a, T2>, IterMut<'a, T3>, IterMut<'a, T4>, IterMut<'a, T5>, IterMut<'a, T6>, IterMut<'a, T7>, IterMut<'a, T8>)

fn dangling() -> Self::Storage

fn as_ptr(storage: Self::Storage) -> Self::Ptr

unsafe fn alloc(capacity: usize) -> Self::Storage

unsafe fn dealloc(storage: &mut Self::Storage, capacity: usize)

fn layout_for_capacity(capacity: usize) -> MemoryLayout<Self>

unsafe fn add(base: Self::Ptr, offset: usize) -> Self::Ptr

unsafe fn copy_to(src: Self::Ptr, dst: Self::Ptr, len: usize)

unsafe fn copy_to_nonoverlapping(src: Self::Ptr, dst: Self::Ptr, len: usize)

unsafe fn as_slices<'a>(ptr: Self::Ptr, len: usize) -> Self::Slices

unsafe fn as_slices_mut<'a>(ptr: Self::Ptr, len: usize) -> Self::SlicesMut

fn iters<'a>(slices: Self::Slices) -> Self::Iters

fn iters_mut<'a>(slices: Self::SlicesMut) -> Self::ItersMut

fn reverse<'a>(slices: Self::SlicesMut)

unsafe fn as_ref<'a>(ptr: Self::Ptr) -> Self::Ref

unsafe fn as_mut<'a>(ptr: Self::Ptr) -> Self::RefMut

unsafe fn read(ptr: Self::Ptr) -> Self

unsafe fn write(ptr: Self::Ptr, value: Self)

unsafe fn swap(a: Self::Ptr, b: Self::Ptr)

unsafe fn drop(ptr: Self::Ptr)

fn get_vec_len(vecs: &Self::Vecs) -> Option<usize>

unsafe fn get_vec_ptrs(vecs: &mut Self::Vecs) -> Self::Ptr

impl<T1: 'static, T2: 'static, T3: 'static, V3: 'static, T5: 'static, T6: 'static, T7: 'static, T8: 'static, T9: 'static> ParallelVecParam for (T1, T2, T3, V3, T5, T6, T7, T8, T9)

type Storage = (NonNull<T1>, NonNull<T2>, NonNull<T3>, NonNull<V3>, NonNull<T5>, NonNull<T6>, NonNull<T7>, NonNull<T8>, NonNull<T9>)

type Ref = (&'a T1, &'a T2, &'a T3, &'a V3, &'a T5, &'a T6, &'a T7, &'a T8, &'a T9)

type RefMut = (&'a mut T1, &'a mut T2, &'a mut T3, &'a mut V3, &'a mut T5, &'a mut T6, &'a mut T7, &'a mut T8, &'a mut T9)

type Slices = (&'a [T1], &'a [T2], &'a [T3], &'a [V3], &'a [T5], &'a [T6], &'a [T7], &'a [T8], &'a [T9])

type SlicesMut = (&'a mut [T1], &'a mut [T2], &'a mut [T3], &'a mut [V3], &'a mut [T5], &'a mut [T6], &'a mut [T7], &'a mut [T8], &'a mut [T9])

type Vecs = (Vec<T1>, Vec<T2>, Vec<T3>, Vec<V3>, Vec<T5>, Vec<T6>, Vec<T7>, Vec<T8>, Vec<T9>)

type Ptr = (*mut T1, *mut T2, *mut T3, *mut V3, *mut T5, *mut T6, *mut T7, *mut T8, *mut T9)

type Offsets = (usize, usize, usize, usize, usize, usize, usize, usize, usize)

type Iters = (Iter<'a, T1>, Iter<'a, T2>, Iter<'a, T3>, Iter<'a, V3>, Iter<'a, T5>, Iter<'a, T6>, Iter<'a, T7>, Iter<'a, T8>, Iter<'a, T9>)

type ItersMut = (IterMut<'a, T1>, IterMut<'a, T2>, IterMut<'a, T3>, IterMut<'a, V3>, IterMut<'a, T5>, IterMut<'a, T6>, IterMut<'a, T7>, IterMut<'a, T8>, IterMut<'a, T9>)

fn dangling() -> Self::Storage

fn as_ptr(storage: Self::Storage) -> Self::Ptr

unsafe fn alloc(capacity: usize) -> Self::Storage

unsafe fn dealloc(storage: &mut Self::Storage, capacity: usize)

fn layout_for_capacity(capacity: usize) -> MemoryLayout<Self>

unsafe fn add(base: Self::Ptr, offset: usize) -> Self::Ptr

unsafe fn copy_to(src: Self::Ptr, dst: Self::Ptr, len: usize)

unsafe fn copy_to_nonoverlapping(src: Self::Ptr, dst: Self::Ptr, len: usize)

unsafe fn as_slices<'a>(ptr: Self::Ptr, len: usize) -> Self::Slices

unsafe fn as_slices_mut<'a>(ptr: Self::Ptr, len: usize) -> Self::SlicesMut

fn iters<'a>(slices: Self::Slices) -> Self::Iters

fn iters_mut<'a>(slices: Self::SlicesMut) -> Self::ItersMut

fn reverse<'a>(slices: Self::SlicesMut)

unsafe fn as_ref<'a>(ptr: Self::Ptr) -> Self::Ref

unsafe fn as_mut<'a>(ptr: Self::Ptr) -> Self::RefMut

unsafe fn read(ptr: Self::Ptr) -> Self

unsafe fn write(ptr: Self::Ptr, value: Self)

unsafe fn swap(a: Self::Ptr, b: Self::Ptr)

unsafe fn drop(ptr: Self::Ptr)

fn get_vec_len(vecs: &Self::Vecs) -> Option<usize>

unsafe fn get_vec_ptrs(vecs: &mut Self::Vecs) -> Self::Ptr

impl<T1: 'static, T2: 'static, T3: 'static, V3: 'static, T5: 'static, T6: 'static, T7: 'static, T8: 'static, T9: 'static, T10: 'static> ParallelVecParam for (T1, T2, T3, V3, T5, T6, T7, T8, T9, T10)

type Storage = (NonNull<T1>, NonNull<T2>, NonNull<T3>, NonNull<V3>, NonNull<T5>, NonNull<T6>, NonNull<T7>, NonNull<T8>, NonNull<T9>, NonNull<T10>)

type Ref = (&'a T1, &'a T2, &'a T3, &'a V3, &'a T5, &'a T6, &'a T7, &'a T8, &'a T9, &'a T10)

type RefMut = (&'a mut T1, &'a mut T2, &'a mut T3, &'a mut V3, &'a mut T5, &'a mut T6, &'a mut T7, &'a mut T8, &'a mut T9, &'a mut T10)

type Slices = (&'a [T1], &'a [T2], &'a [T3], &'a [V3], &'a [T5], &'a [T6], &'a [T7], &'a [T8], &'a [T9], &'a [T10])

type SlicesMut = (&'a mut [T1], &'a mut [T2], &'a mut [T3], &'a mut [V3], &'a mut [T5], &'a mut [T6], &'a mut [T7], &'a mut [T8], &'a mut [T9], &'a mut [T10])

type Vecs = (Vec<T1>, Vec<T2>, Vec<T3>, Vec<V3>, Vec<T5>, Vec<T6>, Vec<T7>, Vec<T8>, Vec<T9>, Vec<T10>)

type Ptr = (*mut T1, *mut T2, *mut T3, *mut V3, *mut T5, *mut T6, *mut T7, *mut T8, *mut T9, *mut T10)

type Offsets = (usize, usize, usize, usize, usize, usize, usize, usize, usize, usize)

type Iters = (Iter<'a, T1>, Iter<'a, T2>, Iter<'a, T3>, Iter<'a, V3>, Iter<'a, T5>, Iter<'a, T6>, Iter<'a, T7>, Iter<'a, T8>, Iter<'a, T9>, Iter<'a, T10>)

type ItersMut = (IterMut<'a, T1>, IterMut<'a, T2>, IterMut<'a, T3>, IterMut<'a, V3>, IterMut<'a, T5>, IterMut<'a, T6>, IterMut<'a, T7>, IterMut<'a, T8>, IterMut<'a, T9>, IterMut<'a, T10>)

fn dangling() -> Self::Storage

fn as_ptr(storage: Self::Storage) -> Self::Ptr

unsafe fn alloc(capacity: usize) -> Self::Storage

unsafe fn dealloc(storage: &mut Self::Storage, capacity: usize)

fn layout_for_capacity(capacity: usize) -> MemoryLayout<Self>

unsafe fn add(base: Self::Ptr, offset: usize) -> Self::Ptr

unsafe fn copy_to(src: Self::Ptr, dst: Self::Ptr, len: usize)

unsafe fn copy_to_nonoverlapping(src: Self::Ptr, dst: Self::Ptr, len: usize)

unsafe fn as_slices<'a>(ptr: Self::Ptr, len: usize) -> Self::Slices

unsafe fn as_slices_mut<'a>(ptr: Self::Ptr, len: usize) -> Self::SlicesMut

fn iters<'a>(slices: Self::Slices) -> Self::Iters

fn iters_mut<'a>(slices: Self::SlicesMut) -> Self::ItersMut

fn reverse<'a>(slices: Self::SlicesMut)

unsafe fn as_ref<'a>(ptr: Self::Ptr) -> Self::Ref

unsafe fn as_mut<'a>(ptr: Self::Ptr) -> Self::RefMut

unsafe fn read(ptr: Self::Ptr) -> Self

unsafe fn write(ptr: Self::Ptr, value: Self)

unsafe fn swap(a: Self::Ptr, b: Self::Ptr)

unsafe fn drop(ptr: Self::Ptr)

fn get_vec_len(vecs: &Self::Vecs) -> Option<usize>

unsafe fn get_vec_ptrs(vecs: &mut Self::Vecs) -> Self::Ptr

impl<T1: 'static, T2: 'static, T3: 'static, V3: 'static, T5: 'static, T6: 'static, T7: 'static, T8: 'static, T9: 'static, T10: 'static, T11: 'static> ParallelVecParam for (T1, T2, T3, V3, T5, T6, T7, T8, T9, T10, T11)

type Storage = (NonNull<T1>, NonNull<T2>, NonNull<T3>, NonNull<V3>, NonNull<T5>, NonNull<T6>, NonNull<T7>, NonNull<T8>, NonNull<T9>, NonNull<T10>, NonNull<T11>)

type Ref = (&'a T1, &'a T2, &'a T3, &'a V3, &'a T5, &'a T6, &'a T7, &'a T8, &'a T9, &'a T10, &'a T11)

type RefMut = (&'a mut T1, &'a mut T2, &'a mut T3, &'a mut V3, &'a mut T5, &'a mut T6, &'a mut T7, &'a mut T8, &'a mut T9, &'a mut T10, &'a mut T11)

type Slices = (&'a [T1], &'a [T2], &'a [T3], &'a [V3], &'a [T5], &'a [T6], &'a [T7], &'a [T8], &'a [T9], &'a [T10], &'a [T11])

type SlicesMut = (&'a mut [T1], &'a mut [T2], &'a mut [T3], &'a mut [V3], &'a mut [T5], &'a mut [T6], &'a mut [T7], &'a mut [T8], &'a mut [T9], &'a mut [T10], &'a mut [T11])

type Vecs = (Vec<T1>, Vec<T2>, Vec<T3>, Vec<V3>, Vec<T5>, Vec<T6>, Vec<T7>, Vec<T8>, Vec<T9>, Vec<T10>, Vec<T11>)

type Ptr = (*mut T1, *mut T2, *mut T3, *mut V3, *mut T5, *mut T6, *mut T7, *mut T8, *mut T9, *mut T10, *mut T11)

type Offsets = (usize, usize, usize, usize, usize, usize, usize, usize, usize, usize, usize)

type Iters = (Iter<'a, T1>, Iter<'a, T2>, Iter<'a, T3>, Iter<'a, V3>, Iter<'a, T5>, Iter<'a, T6>, Iter<'a, T7>, Iter<'a, T8>, Iter<'a, T9>, Iter<'a, T10>, Iter<'a, T11>)

type ItersMut = (IterMut<'a, T1>, IterMut<'a, T2>, IterMut<'a, T3>, IterMut<'a, V3>, IterMut<'a, T5>, IterMut<'a, T6>, IterMut<'a, T7>, IterMut<'a, T8>, IterMut<'a, T9>, IterMut<'a, T10>, IterMut<'a, T11>)

fn dangling() -> Self::Storage

fn as_ptr(storage: Self::Storage) -> Self::Ptr

unsafe fn alloc(capacity: usize) -> Self::Storage

unsafe fn dealloc(storage: &mut Self::Storage, capacity: usize)

fn layout_for_capacity(capacity: usize) -> MemoryLayout<Self>

unsafe fn add(base: Self::Ptr, offset: usize) -> Self::Ptr

unsafe fn copy_to(src: Self::Ptr, dst: Self::Ptr, len: usize)

unsafe fn copy_to_nonoverlapping(src: Self::Ptr, dst: Self::Ptr, len: usize)

unsafe fn as_slices<'a>(ptr: Self::Ptr, len: usize) -> Self::Slices

unsafe fn as_slices_mut<'a>(ptr: Self::Ptr, len: usize) -> Self::SlicesMut

fn iters<'a>(slices: Self::Slices) -> Self::Iters

fn iters_mut<'a>(slices: Self::SlicesMut) -> Self::ItersMut

fn reverse<'a>(slices: Self::SlicesMut)

unsafe fn as_ref<'a>(ptr: Self::Ptr) -> Self::Ref

unsafe fn as_mut<'a>(ptr: Self::Ptr) -> Self::RefMut

unsafe fn read(ptr: Self::Ptr) -> Self

unsafe fn write(ptr: Self::Ptr, value: Self)

unsafe fn swap(a: Self::Ptr, b: Self::Ptr)

unsafe fn drop(ptr: Self::Ptr)

fn get_vec_len(vecs: &Self::Vecs) -> Option<usize>

unsafe fn get_vec_ptrs(vecs: &mut Self::Vecs) -> Self::Ptr

impl<T1: 'static, T2: 'static, T3: 'static, V3: 'static, T5: 'static, T6: 'static, T7: 'static, T8: 'static, T9: 'static, T10: 'static, T11: 'static, T12: 'static> ParallelVecParam for (T1, T2, T3, V3, T5, T6, T7, T8, T9, T10, T11, T12)

type Storage = (NonNull<T1>, NonNull<T2>, NonNull<T3>, NonNull<V3>, NonNull<T5>, NonNull<T6>, NonNull<T7>, NonNull<T8>, NonNull<T9>, NonNull<T10>, NonNull<T11>, NonNull<T12>)

type Ref = (&'a T1, &'a T2, &'a T3, &'a V3, &'a T5, &'a T6, &'a T7, &'a T8, &'a T9, &'a T10, &'a T11, &'a T12)

type RefMut = (&'a mut T1, &'a mut T2, &'a mut T3, &'a mut V3, &'a mut T5, &'a mut T6, &'a mut T7, &'a mut T8, &'a mut T9, &'a mut T10, &'a mut T11, &'a mut T12)

type Slices = (&'a [T1], &'a [T2], &'a [T3], &'a [V3], &'a [T5], &'a [T6], &'a [T7], &'a [T8], &'a [T9], &'a [T10], &'a [T11], &'a [T12])

type SlicesMut = (&'a mut [T1], &'a mut [T2], &'a mut [T3], &'a mut [V3], &'a mut [T5], &'a mut [T6], &'a mut [T7], &'a mut [T8], &'a mut [T9], &'a mut [T10], &'a mut [T11], &'a mut [T12])

type Vecs = (Vec<T1>, Vec<T2>, Vec<T3>, Vec<V3>, Vec<T5>, Vec<T6>, Vec<T7>, Vec<T8>, Vec<T9>, Vec<T10>, Vec<T11>, Vec<T12>)

type Ptr = (*mut T1, *mut T2, *mut T3, *mut V3, *mut T5, *mut T6, *mut T7, *mut T8, *mut T9, *mut T10, *mut T11, *mut T12)

type Offsets = (usize, usize, usize, usize, usize, usize, usize, usize, usize, usize, usize, usize)

type Iters = (Iter<'a, T1>, Iter<'a, T2>, Iter<'a, T3>, Iter<'a, V3>, Iter<'a, T5>, Iter<'a, T6>, Iter<'a, T7>, Iter<'a, T8>, Iter<'a, T9>, Iter<'a, T10>, Iter<'a, T11>, Iter<'a, T12>)

type ItersMut = (IterMut<'a, T1>, IterMut<'a, T2>, IterMut<'a, T3>, IterMut<'a, V3>, IterMut<'a, T5>, IterMut<'a, T6>, IterMut<'a, T7>, IterMut<'a, T8>, IterMut<'a, T9>, IterMut<'a, T10>, IterMut<'a, T11>, IterMut<'a, T12>)

fn dangling() -> Self::Storage

fn as_ptr(storage: Self::Storage) -> Self::Ptr

unsafe fn alloc(capacity: usize) -> Self::Storage

unsafe fn dealloc(storage: &mut Self::Storage, capacity: usize)

fn layout_for_capacity(capacity: usize) -> MemoryLayout<Self>

unsafe fn add(base: Self::Ptr, offset: usize) -> Self::Ptr

unsafe fn copy_to(src: Self::Ptr, dst: Self::Ptr, len: usize)

unsafe fn copy_to_nonoverlapping(src: Self::Ptr, dst: Self::Ptr, len: usize)

unsafe fn as_slices<'a>(ptr: Self::Ptr, len: usize) -> Self::Slices

unsafe fn as_slices_mut<'a>(ptr: Self::Ptr, len: usize) -> Self::SlicesMut

fn iters<'a>(slices: Self::Slices) -> Self::Iters

fn iters_mut<'a>(slices: Self::SlicesMut) -> Self::ItersMut

fn reverse<'a>(slices: Self::SlicesMut)

unsafe fn as_ref<'a>(ptr: Self::Ptr) -> Self::Ref

unsafe fn as_mut<'a>(ptr: Self::Ptr) -> Self::RefMut

unsafe fn read(ptr: Self::Ptr) -> Self

unsafe fn write(ptr: Self::Ptr, value: Self)

unsafe fn swap(a: Self::Ptr, b: Self::Ptr)

unsafe fn drop(ptr: Self::Ptr)

fn get_vec_len(vecs: &Self::Vecs) -> Option<usize>

unsafe fn get_vec_ptrs(vecs: &mut Self::Vecs) -> Self::Ptr

Implementors