Struct Mem

pub struct Mem;

🌐 Memory-related operations.

See also: ExtMem, Ptr, Slice.

Implementations

impl Mem

Safe methods.

pub const fn align_of<T>() -> usize

Returns the minimum alignment of the type in bytes.

See core::mem::align_of.

pub const fn align_of_val<T: ?Sized>(val: &T) -> usize

Returns the alignment of the pointed-to value in bytes.

See core::mem::align_of_val.

pub const fn copy<T: Copy>(x: &T) -> T

Bitwise-copies a value.

It is useful when you want to pass a function pointer to a combinator, rather than defining a new closure.

Example

let result_from_ffi_fn: Result<(), &i32> = Err(&1);
let result_copied: Result<(), i32> = result_from_ffi_fn.map_err(Mem::copy);

pub const fn discriminant<T>(v: &T) -> Discriminant<T>

Returns a value uniquely identifying the enum variant in v.

pub fn drop<T>(_x: T)

Disposes of a value.

See core::mem::drop.

pub fn forget<T>(t: T)

Takes ownership and “forgets” about t without running its destructor.

See core::mem::forget.

pub const fn needs_drop<T: ?Sized>() -> bool

Returns true if dropping values of type T matters.

See core::mem::needs_drop.

pub const fn replace<T>(dest: &mut T, src: T) -> T

Moves src into dest, returning the previous dest value.

See core::mem::replace.

pub const fn size_of<T>() -> usize

Returns the size of a type in bytes.

See core::mem::size_of.

pub const fn size_of_val<T: ?Sized>(val: &T) -> usize

Returns the size of the pointed-to value in bytes. See core::mem::size_of_val.

pub const fn swap<T>(x: &mut T, y: &mut T)

Swaps the values at two locations, without deinitializing either one.

See core::mem::swap.

pub fn take<T: Default>(dest: &mut T) -> T

Replaces dest with T::default(), returning the previous dest value.

See core::mem::take.

impl Mem

Extra methods

pub const fn bytes_from_bits(bit_size: usize) -> usize

Returns the rounded up size in bytes from a size in bits.

This is equivalent to (bit_size + 7) / 8 but handles potential overflow.

impl Mem

Unsafe methods

Features

They depend on enabling any unsafe* feature, and not enabling safe_mem.

pub const unsafe fn transmute_copy<Src, Dst>(src: &Src) -> Dst

Available on unsafe·· only.

Reads src as having type &Dst without moving the contained value.

Safety

See core::mem::transmute_copy.

pub const unsafe fn zeroed<T>() -> T

Available on unsafe·· only.

Returns the value of type T represented by the all-zero byte-pattern.

Safety

See core::mem::zeroed.

impl Mem

Unsafe methods gated by unsafe_slice

pub fn as_bytes<'t, T: Sync + Unpin + ?Sized + 't>(v: &T) -> &'t [u8]

Available on crate feature unsafe_slice only.

View any T: Sync + Unpin + ?Sized as &[u8].

This is a safer interface to core::slice::from_raw_parts.

Example

#[repr(C)]
struct Data(u32);

let data = Data(1234);
let bytes = Mem::as_bytes(&data);

if cfg!(target_endian = "little") {
    assert!(bytes == &[210, 4, 0, 0]);
} else {
    assert!(bytes == &[0, 0, 4, 210]);
}

Vendored

This is adapted work from rawbytes.

pub fn as_bytes_mut<'t, T: Sync + Unpin + ?Sized + 't>( v: &mut T, ) -> &'t mut [u8]

Available on crate feature unsafe_slice only.

View any T: Sync + Unpin + ?Sized as &mut [u8].

This is a safer interface to core::slice::from_raw_parts_mut.

Examples

#[repr(C)]
struct Data(u32);

let mut data = Data(1234);
let bytes = Mem::as_bytes_mut(&mut data);

if cfg!(target_endian = "little") {
    bytes[1] = 0;
    assert!(bytes == &[210, 0, 0, 0] && data.0 == 210);
} else {
    bytes[1] = 0;
    assert!(bytes == &[0, 0, 0, 210] && data.0 == 210);
}

Vendored

This is adapted work from rawbytes.

pub const fn as_bytes_sized<T: Sync + Unpin>(v: &T) -> &[u8]

Available on crate feature unsafe_slice only.

View any T: Sync + Unpin + Sized as &[u8] compile-time friendly.

This is a safer interface to core::slice::from_raw_parts, for Sized types.

Examples

const DATA: u32 = 1234;
const BYTES: &[u8] = Mem::as_bytes_sized(&DATA);

if cfg!(target_endian = "little") {
    assert_eq!(BYTES, &[210, 4, 0, 0]);
} else {
    assert_eq!(BYTES, &[0, 0, 4, 210]);
}