Struct thinbox::ThinBox

pub struct ThinBox<T: ?Sized> { /* fields omitted */ }

A consistently-sized pointer type for heap allocation.

See the crate documentation for an example using ThinBox.

Implementations

impl<T: ?Sized> ThinBox<T>

pub fn unsize<U: Unsize<T>>(value: U) -> Self

Creates a new ThinBox by unsizing a value and placing it on the heap.

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

Recovers ThinBox ownership of a boxed pointee.

Along with into_raw, this function provides one of the core operations which makes ThinBox useful for interoperation with foreign functions.

Safety

• raw must be result of Box::<U>::into_raw as *mut () or ThinBox::<U>::into_raw where U safe to transmute into T.
• The alignment requirements of T must not be more strict than those of U.
• It must be generally safe to dereference raw, keeping in mind that raw does not actually point to () and does not necessarily even point to a U.

The first requirement implies that:

• U: Sized and/or U is T.
• raw is neither null nor dangling.

Furthermore, support for Box::<U>::into_raw is not guaranteed to be preserved across major versions of thinbox.

pub fn into_raw(thin: Self) -> *mut ()

Converts the ThinBox to a single-pointer-sized representation.

Along with from_raw, this function provides one of the core operations which makes ThinBox useful for interoperation with foreign functions.

Notes

It is not safe to dereference this representation. The type of the pointee depends not only on T but also on whether or not T is Sized.

pub fn as_ptr(thin: &Self) -> *mut T

Obtains a raw pointer to the boxed value.

The pointee remains owned by the ThinBox. If you wish to relinquish ownership, use into_raw or leak.

Notes

This method returns a raw mutable pointer, which is dangerous to use. However ThinBox is guaranteed to never store an internal reference to its owned value so dereferencing this pointer does not necessarily cause undefined behavior.

pub fn leak<'a>(thin: Self) -> &'a mut T

Leaks the contained value in a manner similar to Box::leak.

Unlike Box::leak, if T is unsized it is not valid to pass the returned reference to Box::from_raw or ThinBox::from_raw.

To restore a ThinBox from the reference produced by this function use unleak.

pub unsafe fn unleak(leaked: &mut T) -> Self

Restores a ThinBox from a reference created by leak.

Safety

• If T is Sized, this method behaves as-if from_raw was invoked on leaked.
• If T is unsized, leaked must have been produced by calling ThinBox::<T>::leak. Any difference in the ThinBox type signatures involved will result in undefined behavior in all but the most contrived of cases.

pub unsafe fn transmute_into<U>(thin: Self, dest: *mut U)

Moves the owned value into dest by transmuting it into the Sized type U.

Notes

• The value pointed to by dest, if any, is not dropped.
• The owned value of the ThinBox does not need to be properly aligned as a U.

Safety

Immediate undefined behavior occurs if U is larger in size than the owned value or if dest is not valid for writes. Otherwise any undefined behavior is deferred to later operations which dereference dest and thereby observe the result of the transmutation.

impl<T> ThinBox<T>

pub fn new(value: T) -> Self

Creates a new ThinBox by moving a Sized value to the heap.

Notes

Doing this passes up your opportunity to coerce the value to an unsized type, thereby defeating most of the usefulness of ThinBox. Instead, you should consider using Box unless you are constrained by some other code which requires instances of ThinBox.

pub fn from_box(boxed: Box<T>) -> Self

Converts a Sized Box into a ThinBox.

Notes

This operation is zero-cost. 💸

pub fn into_box(thin: Self) -> Box<T>

Converts a Sized ThinBox into a Box.

Notes

This operation is zero-cost. 💸

pub fn into_inner(thin: Self) -> T

Moves the owned value out of a Sized ThinBox.

Trait Implementations

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

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

Performs the conversion.

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

pub fn as_ref(&self) -> &T

Performs the conversion.

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

pub fn borrow(&self) -> &T

Immutably borrows from an owned value.

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

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

Mutably borrows from an owned value.

impl<T: Clone> Clone for ThinBox<T>

pub fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

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

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

Formats the value using the given formatter.

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

type Target = T

The resulting type after dereferencing.

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

Dereferences the value.

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

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

Mutably dereferences the value.

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

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

Formats the value using the given formatter.

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

pub fn drop(&mut self)

Executes the destructor for this type.

impl<T> From<T> for ThinBox<T>

pub fn from(value: T) -> Self

Performs the conversion.

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

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

Feeds this value into the given Hasher.

pub 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> Pointer for ThinBox<T>

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

Formats the value using the given formatter.

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

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

impl<T: UnwindSafe + ?Sized> UnwindSafe for ThinBox<T>