Struct malloced::Malloced

#[repr(transparent)]
pub struct Malloced<T: ?Sized> { /* fields omitted */ }

A pointer type for malloc-ed heap allocation.

Memory layout

So long as T: Sized, a Malloced<T> is guaranteed to be represented as a single pointer and is also ABI-compatible with C pointers (i.e. the C type T*). This means that if you have extern “C” Rust functions that will be called from C, you can define those Rust functions using Malloced<T> types, and use T* as corresponding type on the C side.

Regardless if T: Sized, a Malloced<T> is guaranteed to be ABI-compatible with NonNull<T>.

Implementations

impl<T: ?Sized> Malloced<T>

pub unsafe fn from_raw(ptr: *mut T) -> Self

Constructs an instance from a raw malloc-ed pointer.

Safety

The data referenced by ptr must be valid and must have been allocated by malloc so that it can be free-d on Drop.

pub fn into_raw(this: Self) -> *mut T

Consumes the instance, returning a wrapped raw pointer.

The pointer will be properly aligned and non-null.

pub fn leak<'a>(this: Self) -> &'a mut T where
    T: 'a, 

Consumes and leaks the instance, returning a mutable reference, &'a mut T.

Note that the type T must outlive the chosen lifetime 'a. If the type has only static references, or none at all, then this may be chosen to be 'static.

This function is mainly useful for data that lives for the remainder of the program’s life. Dropping the returned reference will cause a memory leak. If this is not acceptable, the reference should first be wrapped with the Malloced::from_raw function producing a Malloced. This Malloced can then be dropped which will properly destroy T and free the allocated memory.

Note: this is an associated function, which means that you have to call it as Malloced::leak(this) instead of this.leak(). This is so that there is no conflict with a method on the inner type.

pub fn as_ptr(this: &Self) -> *const T

Returns an immutable raw pointer to the data.

pub fn as_mut_ptr(this: &mut Self) -> *mut T

Returns a mutable raw pointer to the data.

impl<T> Malloced<[T]>

pub unsafe fn slice_from_raw_parts(data: *mut T, len: usize) -> Self

Constructs an instance for a slice from a pointer and a length.

Safety

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

• data must have been allocated by malloc so that it can be free-d on Drop.

• 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 NonNull::dangling().

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

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

See slice::from_raw_parts_mut for details.

impl Malloced<dyn Any>

pub fn downcast<T: Any>(self) -> Result<Malloced<T>, Self>

Attempt to downcast the instance to a concrete type.

impl Malloced<dyn Any + Send>

pub fn downcast<T: Any>(self) -> Result<Malloced<T>, Self>

Attempt to downcast the instance to a concrete type.

Trait Implementations

impl<T: ?Sized> AsMut<T> for Malloced<T>

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

Performs the conversion.

impl<T: ?Sized> AsRef<T> for Malloced<T>

fn as_ref(&self) -> &T

Performs the conversion.

impl<T: ?Sized> Borrow<T> for Malloced<T>

fn borrow(&self) -> &T

Immutably borrows from an owned value.

impl<T: ?Sized> BorrowMut<T> for Malloced<T>

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

Mutably borrows from an owned value.

impl<T: ?Sized + Debug> Debug for Malloced<T>

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

Formats the value using the given formatter.

impl<T: ?Sized> Deref for Malloced<T>

type Target = T

The resulting type after dereferencing.

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

Dereferences the value.

impl<T: ?Sized> DerefMut for Malloced<T>

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

Mutably dereferences the value.

impl<T: ?Sized + Display> Display for Malloced<T>

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

Formats the value using the given formatter.

impl<T: ?Sized> Drop for Malloced<T>

fn drop(&mut self)

Executes the destructor for this type.

impl From<Malloced<str>> for Malloced<[u8]>

fn from(m: Malloced<str>) -> Self

Performs the conversion.

impl<T: ?Sized + Hash> Hash for Malloced<T>

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: ?Sized + Hasher> Hasher for Malloced<T>

fn finish(&self) -> u64

Returns the hash value for the values written so far.

fn write(&mut self, bytes: &[u8])

Writes some data into this Hasher.

fn write_u8(&mut self, i: u8)

Writes a single u8 into this hasher.

fn write_u16(&mut self, i: u16)

Writes a single u16 into this hasher.

fn write_u32(&mut self, i: u32)

Writes a single u32 into this hasher.

fn write_u64(&mut self, i: u64)

Writes a single u64 into this hasher.

fn write_u128(&mut self, i: u128)

Writes a single u128 into this hasher.

fn write_usize(&mut self, i: usize)

Writes a single usize into this hasher.

fn write_i8(&mut self, i: i8)

Writes a single i8 into this hasher.

fn write_i16(&mut self, i: i16)

Writes a single i16 into this hasher.

fn write_i32(&mut self, i: i32)

Writes a single i32 into this hasher.

fn write_i64(&mut self, i: i64)

Writes a single i64 into this hasher.

fn write_i128(&mut self, i: i128)

Writes a single i128 into this hasher.

fn write_isize(&mut self, i: isize)

Writes a single isize into this hasher.

impl<T: ?Sized + Ord> Ord for Malloced<T>

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

Restrict a value to a certain interval.

impl<T: ?Sized + PartialEq> PartialEq<Malloced<T>> for Malloced<T>

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

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

fn ne(&self, other: &Self) -> bool

This method tests for !=.

impl<T: ?Sized + PartialOrd> PartialOrd<Malloced<T>> for Malloced<T>

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Self) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Self) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn ge(&self, other: &Self) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

fn gt(&self, other: &Self) -> bool

This method tests greater than (for self and other) and is used by the > operator.

impl<T: ?Sized> Pointer for Malloced<T>

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

Formats the value using the given formatter.

impl<T: ?Sized + Eq> Eq for Malloced<T>

impl<T: ?Sized + Send> Send for Malloced<T>

impl<T: ?Sized + Sync> Sync for Malloced<T>