Struct malloced::Malloced

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

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 into_pin(this: Self) -> Pin<Malloced<T>>

Converts a Malloced<T> into a Pin<Malloced<T>>

This conversion does not allocate on the heap and happens in place.

This is also available via From.

pub fn leak<'a>(this: Self) -> &'a mut Twhere 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.

pub fn into_any(this: Self) -> Malloced<dyn Any>where T: Sized + Any,

Erases the static type T.

pub fn into_any_send(this: Self) -> Malloced<dyn Any + Send + Sync>where T: Sized + Any + Send + Sync,

Erases the static type T.

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<CStr>

pub unsafe fn from_ptr(ptr: *mut c_char) -> Self

Wraps a raw malloced C string with a safe owned C string wrapper.

Safety

See CStr::from_ptr safety docs.

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.

impl Malloced<dyn Any + Send + Sync>

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

Converts this type into a mutable reference of the (usually inferred) input type.

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

fn as_ref(&self) -> &T

Converts this type into a shared reference of the (usually inferred) input type.

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<T: ?Sized> From<Malloced<T>> for Pin<Malloced<T>>

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

Converts to this type from the input type.

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

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

Converts to this type from the input type.

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, Self: Sized,

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.

fn write_length_prefix(&mut self, len: usize)

🔬This is a nightly-only experimental API. (hasher_prefixfree_extras)

Writes a length prefix into this hasher, as part of being prefix-free.

fn write_str(&mut self, s: &str)

🔬This is a nightly-only experimental API. (hasher_prefixfree_extras)

Writes a single str into this hasher.

impl<T> IntoIterator for Malloced<[T]>

type Item = T

The type of the elements being iterated over.

type IntoIter = SliceIter<T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

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) -> Selfwhere Self: Sized,

Compares and returns the maximum of two values.

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

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Selfwhere Self: Sized + PartialOrd<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 !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

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>