Struct Aligned 

pub struct Aligned<T, Alignment: IsAlignment> {
    pub value: T,
    /* private fields */
}

Force minimum alignment of a type.

Invariants

The wrapped Self::value is guaranteed, for specifically unsafe code, to have a minimum alignment of Alignment::VALUE bytes. The wrapped value is also guaranteed to have a zero offset from the start of the alignment block. This makes it sound to construct a reference the wrapped value for a different type with an alignment of maximum Alignment::VALUE bytes, given the other unsafe rules are followed.

Additionally the layout of this struct is #[repr(C)] with a single field value of type T and a private zero sized type with an alignment of Alignment::VALUE bytes.

Examples

use std::mem::*;
use dungeon_cell::align::Aligned;
use dungeon_cell::layout::Alignment;

// 1 byte aligned buffer
let x: [u8; 4] = 1234567890u32.to_ne_bytes();
assert_eq!(size_of_val(&x), 4);
assert_eq!(align_of_val(&x), 1);

// 4 byte aligned buffer
let y = Aligned::<_, Alignment<4>>::new(x);
assert_eq!(size_of_val(&y), 4);
assert_eq!(align_of_val(&y), 4);

// this cast back to a u32 is sound because Aligned
// makes the value field aligned to 4 bytes
let z = &y.value as *const [u8; 4] as *const u32;
let z = unsafe { &*z };
assert_eq!(z, &1234567890);

Fields

value: T

Stored value.

This field is guaranteed to be aligned to Alignment::VALUE bytes.

Implementations

impl<T, Alignment: IsAlignment> Aligned<T, Alignment>

pub const fn new(value: T) -> Self

Construct a new aligned value.

Examples

use dungeon_cell::align::Aligned;
use dungeon_cell::layout::Alignment;

let a = Aligned::<_, Alignment<16>>::new(4);

assert_eq!(a.value, 4);

pub const fn into_inner(this: Self) -> T

Convert to the inner T.

The returned value does not keep it’s alignment and has the alignment of type T.

Examples

use dungeon_cell::align::Aligned;
use dungeon_cell::layout::Alignment;

let aligned = Aligned::<_, Alignment<16>>::new(4);
let num = Aligned::into_inner(aligned);

assert_eq!(num, 4);

Trait Implementations

impl<T: Clone, Alignment: IsAlignment> Clone for Aligned<T, Alignment>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T, Alignment: IsAlignment> Deref for Aligned<T, Alignment>

type Target = T

The resulting type after dereferencing.

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

Dereferences the value.

impl<T, Alignment: IsAlignment> DerefMut for Aligned<T, Alignment>

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

Mutably dereferences the value.

impl<T: Copy, Alignment: IsAlignment> Copy for Aligned<T, Alignment>