Struct parallel_vec::ParallelSlice

#[repr(C)]
pub struct ParallelSlice<'a, Param: ParallelParam> { /* private fields */ }

A immutable dynamically-sized view into a contiguous heterogeneous sequence. Contiguous here means that elements are laid out so that every element is the same distance from its neighbors.

Unlike a struct of slices, this type only stores one length instead of duplicating the values across multiple slice fields.

Implementations

impl<'a, Param: ParallelParam> ParallelSlice<'a, Param>

pub unsafe fn from_raw_parts(data: Param::Storage, len: usize) -> Self

Forms a slice from a pointer and a length.

The len argument is the number of elements, not the number of bytes.

Safety

Behavior is undefined if any of the following conditions are violated:

• data must be valid for both reads and writes for len * mem::size_of::<T>() many bytes, and it must be properly aligned. This means in particular:

  • The entire memory range of this slice must be contained within a single allocated object! Slices can never span across multiple allocated objects.
  • data must be non-null and aligned even for zero-length slices. One reason for this is that enum layout optimizations may rely on references (including slices of any length) being aligned and non-null to distinguish them from other data. You can obtain a pointer that is usable as data for zero-length slices using ParallelParam::dangling().

• data must point to len consecutive properly initialized values of type Param.

• The memory referenced by the returned slice must not be accessed through any other pointer (not derived from the return value) for the duration of lifetime 'a. Both read and write accesses are forbidden.

• The total size len * mem::size_of::<T>() of the slice must be no larger than isize::MAX.

pub fn len(&self) -> usize

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

pub fn is_empty(&self) -> bool

Returns true if the vector contains no elements.

pub fn get<'b: 'a, I: ParallelSliceIndex<Self>>(
    &'b self,
    index: I
) -> Option<I::Output>

Returns a immutable reference to the element at index, if available, or None if it is out of bounds.

pub fn first(&self) -> Option<Param::Ref>

Returns the first element of the slice, or None if it is empty.

pub fn last(&self) -> Option<Param::Ref>

Returns the last element of the slice, or None if it is empty.

pub fn index<I>(&self, index: I) -> I::Output where
    I: ParallelSliceIndex<Self>, 

Gets a immutable reference to the elements at index.

Panics

This function will panic if index is >= self.len.

pub unsafe fn get_unchecked(&self, index: usize) -> Param::Ref

Returns references to elements, without doing bounds checking.

For a safe alternative see get.

Safety

Calling this method with an out-of-bounds index is undefined behavior even if the resulting reference is not used.

pub fn as_slices(&self) -> Param::Slices

Gets the individual slices for every sub-slice.

pub fn iter(&self) -> Iter<'a, Param>

Returns an iterator over the ParallelSlice.

pub fn iters(&self) -> Param::Iters

Returns an iterator over the ParallelSlice.

Trait Implementations

impl<'s, 'r, Param> Hash for ParallelSlice<'s, Param> where
    Param: ParallelParam + 's,
    Param::Ref: Hash,
    'r: 's, 

fn hash<H>(&self, hasher: &mut H) where
    H: Hasher, 

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.