Struct malloc_array::HeapArray

pub struct HeapArray<T> {
    pub drop_check: bool,
    // some fields omitted
}

Array created by libc malloc() and dropped by libc free().

Fields

drop_check: bool

Call drop() on sub-elements when dropping the array. This is not needed for types that implement Copy.

Implementations

impl<T> HeapArray<T>

pub fn len_bytes(&self) -> usize

Size of memory of this instance in bytes.

pub fn len(&self) -> usize

Number of elements in this instance.

pub fn initialise<'a>(&'a mut self) -> InitIter<'a, T>

Create an iterator for safely setting potentially uninitialised values within the instance.

pub unsafe fn set_memory(&mut self, value: u8)

Set each byte to a value.

pub fn new(size: usize) -> Self

Creates a new HeapArray<T> from zeroed memory.

pub fn new_uninit(size: usize) -> Self

Creates a new HeapArray<T> from uninitialised memory.

pub fn resize(self, size: usize) -> Self

Consumes the instance, returning a new instance after calling realloc() on the underlying memory.

pub fn new_repeat(initial: T, size: usize) -> Self where
    T: Copy, 

Creates a new HeapArray<T> from an initial element and a size.

pub fn new_range<U>(initial: U, size: usize) -> Self where
    T: Copy,
    U: AsRef<[T]>, 

Creates a new HeapArray<T> from a range of elements and a size, repeating if needed.

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

As an immutable slice of T.

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

As a mutable slice of T.

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

As immutable raw pointer.

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

As mutable raw pointer.

pub fn memory(&self) -> &[u8]

An immutable slice of the memory.

pub unsafe fn memory_mut(&mut self) -> &mut [u8]

A mutable slice of the memory.

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

Consumes the instance. Returns a raw pointer and the number of elements.

pub unsafe fn from_raw_parts(ptr: *mut T, size: usize) -> Self

Create a HeapArray<T> from a raw pointer and a number of elements.

pub fn free(self)

Consumes the instance. Frees the memory without dropping the items.

pub fn into_slice(self, slice: &mut [T])

Consumes the instance, moving all elements into a slice.

pub fn from_boxed_slice(bx: Box<[T]>) -> Self

Coerce or clone memory from a boxed slice.

pub fn into_boxed_slice(self) -> Box<[T]>

Coerce or clone memory into a boxed slice.

pub unsafe fn reinterpret<U>(self) -> HeapArray<U>

Reinterpret the memory of this instance into an insteance of a different type

Panics

If U cannot fit into T.

pub fn reinterpret_ref<U>(&self) -> &[U]

Reinterpret the memory of this instance into an immutable slice of a different type.

Panics

If U cannot fit into T.

pub unsafe fn reinterpret_mut<U>(&mut self) -> &mut [U]

Reinterpret the memory of this instance into a mutable slice of a different type.

Panics

If U cannot fit into T.

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

Immutable slice iterator for this instance

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

Mutable slice iterator for this instance

pub fn replace_and_forget(&mut self, index: usize, value: T)

Replace the element at index with value, and forget the old one. Useful with new_uninit().

pub unsafe fn clone_mem(&self) -> Self

Clone the memory to a new instance.

pub fn leak(self) -> &'static mut [T]

Leak the memory to a static slice reference.

pub unsafe fn memory_from_bytes<U: AsRef<[u8]>>(&mut self, from: U) -> usize

Copy memory in from a slice of bytes.

pub unsafe fn memory_from_raw_bytes(
    &mut self,
    from: *const u8,
    size: usize
) -> usize

Copy memory in from a pointer to bytes.

pub unsafe fn memory_from_slice<U: AsRef<[T]>>(&mut self, from: U) -> usize

Copy memory in from a raw pointer.

pub unsafe fn memory_from_raw(&mut self, from: *const T, size: usize) -> usize

Copy memory in from a raw pointer.

pub unsafe fn from_raw_copied(from: *const T, size: usize) -> Self

Create a new instance with memory copied from a raw pointer.

pub unsafe fn from_slice_copied<U: AsRef<[T]>>(from: U) -> Self where
    T: Copy, 

Create a new instance with memory copied from a slice.

pub unsafe fn from_raw_bytes(from: *const u8, size: usize) -> Self

Create a new instance with memory bytes copied from a raw pointer.

pub unsafe fn from_bytes<U: AsRef<[u8]>>(from: U) -> Self

Create a new instance with memory bytes copied from a slice.

Trait Implementations

impl<T> AsMut<[T]> for HeapArray<T>

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

Performs the conversion.

impl<T> AsRef<[T]> for HeapArray<T>

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

Performs the conversion.

impl<T> Borrow<[T]> for HeapArray<T>

fn borrow(&self) -> &[T]

Immutably borrows from an owned value.

impl<T> BorrowMut<[T]> for HeapArray<T>

fn borrow_mut(&mut self) -> &mut [T]

Mutably borrows from an owned value.

impl<T> Clone for HeapArray<T> where
    T: Clone, 

fn clone(&self) -> Self where
    T: Clone, 

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T> Debug for HeapArray<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<T> Deref for HeapArray<T>

type Target = [T]

The resulting type after dereferencing.

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

Dereferences the value.

impl<T> DerefMut for HeapArray<T>

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

Mutably dereferences the value.

impl<T> Drop for HeapArray<T>

fn drop(&mut self)

Executes the destructor for this type.

impl<T> Eq for HeapArray<T> where
    T: Eq, 

impl<T> From<Box<[T]>> for HeapArray<T>

fn from(sl: Box<[T]>) -> Self

Performs the conversion.

impl<T> From<HeapArray<T>> for Vec<T>

fn from(ha: HeapArray<T>) -> Self

Performs the conversion.

impl<T> From<HeapArray<T>> for Box<[T]>

fn from(ha: HeapArray<T>) -> Self

Performs the conversion.

impl<T> From<Vec<T>> for HeapArray<T>

fn from(vec: Vec<T>) -> Self

Performs the conversion.

impl<T> Hash for HeapArray<T> where
    T: Hash, 

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

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

impl<T, I> Index<I> for HeapArray<T> where
    I: SliceIndex<[T]>, 

type Output = <I as SliceIndex<[T]>>::Output

The returned type after indexing.

fn index(&self, index: I) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<T, I> IndexMut<I> for HeapArray<T> where
    I: SliceIndex<[T]>, 

fn index_mut(&mut self, index: I) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<T> IntoIterator for HeapArray<T>

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T, U> PartialEq<U> for HeapArray<T> where
    T: PartialEq,
    U: AsRef<[T]>, 

fn eq(&self, other: &U) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<T> Send for HeapArray<T> where
    T: Send, 

impl<T> Sync for HeapArray<T> where
    T: Sync,