Struct cl_generic_vec::raw::Heap

#[repr(C)]
pub struct Heap<T, A: Allocator = Global>(_);

This is supported on crate feature alloc only.

A heap storage that can reallocate if necessary,

Usable with the alloc feature

The allocator type paramter is only available on nightly

Implementations

impl<T> Heap<T>

pub fn new() -> Self

Create a new zero-capacity heap vector

pub unsafe fn from_raw_parts(ptr: NonNull<T>, capacity: usize) -> Self

Create a new Heap<T>storage from the given pointer and capacity

Safety

If the capacity is non-zero

• You must have allocated the pointer from the Global allocator
• The pointer must be valid to read-write for the range ptr..ptr.add(capacity)

pub fn into_raw_parts(self) -> (NonNull<T>, usize)

Convert a Heap storage into a pointer and capacity, without deallocating the storage

impl<T, A: Allocator> Heap<T, A>

pub fn with_alloc(allocator: A) -> Self

This is supported on crate feature nightly only.

Create a new zero-capacity heap vector with the given allocator

pub unsafe fn from_raw_parts_in(
    ptr: NonNull<T>,
    capacity: usize,
    allocator: A
) -> Self

This is supported on crate feature nightly only.

Create a new Heap<T>storage from the given pointer and capacity

Safety

If the capacity is non-zero

• You must have allocated the pointer from the given allocator
• The pointer must be valid to read-write for the range ptr..ptr.add(capacity)

pub fn into_raw_parts_with_alloc(self) -> (NonNull<T>, usize, A)

This is supported on crate feature nightly only.

Convert a Heap storage into a pointer and capacity, without deallocating the storage

Trait Implementations

impl<T, A: Allocator> AsMut<[MaybeUninit<T>]> for Heap<T, A>

fn as_mut(&mut self) -> &mut [MaybeUninit<T>]

Performs the conversion.

impl<T, A: Allocator> AsRef<[MaybeUninit<T>]> for Heap<T, A>

fn as_ref(&self) -> &[MaybeUninit<T>]

Performs the conversion.

impl<T, A: Allocator + Default> Default for Heap<T, A>

fn default() -> Self

Returns the “default value” for a type.

impl<T, A: Allocator> Storage for Heap<T, A>

type Item = T

The type of item that this storage can contain

fn reserve(&mut self, new_capacity: usize)

Reserves space for at least new_capacity elements

fn try_reserve(&mut self, new_capacity: usize) -> AllocResult

Tries to reserve space for at least new_capacity elements

impl<T, A: Default + Allocator> StorageWithCapacity for Heap<T, A>

fn with_capacity(cap: usize) -> Self

Creates a new storage with at least the given storage capacity

impl<T, A: Allocator + Send> Send for Heap<T, A>

impl<T, A: Allocator + Sync> Sync for Heap<T, A>