Struct Aligned 

#[repr(C)]
pub struct Aligned<T: ?Sized, const ALIGNMENT: usize>
where
    Alignment<ALIGNMENT>: SupportedAlignment,
{
    pub align: AlignedZst<ALIGNMENT>,
    pub inner: T,
}

A wrapper type with the specified alignment.

This type implements most relevant traits if the wrapped type does, including Default, Ord, Copy, Send, Sync, Unpin, etc.

With the bytemuck optional feature enabled, this type implements the bytemuck::AnyBitPattern trait if the wrapped type does. (It cannot in general implement Pod, because there may be padding.)

With the freeze optional feature enabled, this type implements the unstable core::marker::Freeze trait if the wrapped type does.

Layout

The wrapped field inner is at offset 0, and the size and alignment of Self are minimal to meet the wrapped field’s size and alignment, and to meet the requested alignment, under Rust’s normal size % align == 0 rule.

This is not repr(transparent).

Fields

align: AlignedZst<ALIGNMENT>

inner: T

Implementations

impl<T, const ALIGNMENT: usize> Aligned<T, ALIGNMENT>

where Alignment<ALIGNMENT>: SupportedAlignment,

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

Creates a new Aligned wrapper containing the given value.

pub fn into_inner(self) -> T

Consumes this Aligned wrapper, returning the wrapped value.

Trait Implementations

impl<T: ?Sized, const ALIGNMENT: usize> AsMut<T> for Aligned<T, ALIGNMENT>

where Alignment<ALIGNMENT>: SupportedAlignment,

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

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

impl<T: ?Sized, const ALIGNMENT: usize> AsRef<T> for Aligned<T, ALIGNMENT>

where Alignment<ALIGNMENT>: SupportedAlignment,

fn as_ref(&self) -> &T

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

impl<T: ?Sized, const ALIGNMENT: usize> Borrow<T> for Aligned<T, ALIGNMENT>

where Alignment<ALIGNMENT>: SupportedAlignment,

fn borrow(&self) -> &T

Immutably borrows from an owned value.

impl<T: ?Sized, const ALIGNMENT: usize> BorrowMut<T> for Aligned<T, ALIGNMENT>

where Alignment<ALIGNMENT>: SupportedAlignment,

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

Mutably borrows from an owned value.

impl<T: Clone + ?Sized, const ALIGNMENT: usize> Clone for Aligned<T, ALIGNMENT>

where Alignment<ALIGNMENT>: SupportedAlignment,

fn clone(&self) -> Aligned<T, ALIGNMENT>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Default + ?Sized, const ALIGNMENT: usize> Default for Aligned<T, ALIGNMENT>

where Alignment<ALIGNMENT>: SupportedAlignment,

fn default() -> Aligned<T, ALIGNMENT>

Returns the “default value” for a type.

impl<T: ?Sized + Hash, const ALIGNMENT: usize> Hash for Aligned<T, ALIGNMENT>

where Alignment<ALIGNMENT>: SupportedAlignment,

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: Ord + ?Sized, const ALIGNMENT: usize> Ord for Aligned<T, ALIGNMENT>

where Alignment<ALIGNMENT>: SupportedAlignment,

fn cmp(&self, other: &Aligned<T, ALIGNMENT>) -> Ordering

This method returns an Ordering between self and other.

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

where Self: Sized,

Compares and returns the maximum of two values.

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

where Self: Sized,

Compares and returns the minimum of two values.

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

where Self: Sized,

Restrict a value to a certain interval.

impl<T: PartialEq + ?Sized, const ALIGNMENT: usize> PartialEq for Aligned<T, ALIGNMENT>

where Alignment<ALIGNMENT>: SupportedAlignment,

fn eq(&self, other: &Aligned<T, ALIGNMENT>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: PartialOrd + ?Sized, const ALIGNMENT: usize> PartialOrd for Aligned<T, ALIGNMENT>

where Alignment<ALIGNMENT>: SupportedAlignment,

fn partial_cmp(&self, other: &Aligned<T, ALIGNMENT>) -> Option<Ordering>

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

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

Tests less than (for self and other) and is used by the < operator.

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

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

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

Tests greater than (for self and other) and is used by the > operator.

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

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

impl<T, const ALIGNMENT: usize> Zeroable for Aligned<T, ALIGNMENT>

where T: Zeroable, Alignment<ALIGNMENT>: SupportedAlignment,

Available on crate feature bytemuck only.

fn zeroed() -> Self

Calls zeroed.

impl<T, const ALIGNMENT: usize> AnyBitPattern for Aligned<T, ALIGNMENT>

where T: AnyBitPattern, Alignment<ALIGNMENT>: SupportedAlignment,

Available on crate feature bytemuck only.

impl<T: Copy + ?Sized, const ALIGNMENT: usize> Copy for Aligned<T, ALIGNMENT>

where Alignment<ALIGNMENT>: SupportedAlignment,

impl<T: Eq + ?Sized, const ALIGNMENT: usize> Eq for Aligned<T, ALIGNMENT>

where Alignment<ALIGNMENT>: SupportedAlignment,

impl<T: ?Sized, const ALIGNMENT: usize> StructuralPartialEq for Aligned<T, ALIGNMENT>

where Alignment<ALIGNMENT>: SupportedAlignment,