Struct Alignment 

pub struct Alignment { /* private fields */ }

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

Available on crate features crypto and std only.

A type storing a usize which is a power of two, and thus represents a possible alignment in the Rust abstract machine.

Note that particularly large alignments, while representable in this type, are likely not to be supported by actual allocators and linkers.

Implementations

impl Alignment

pub const MIN: Alignment

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

Available on crate feature rustls only.

The smallest possible alignment, 1.

All addresses are always aligned at least this much.

Examples

#![feature(ptr_alignment_type)]
use std::mem::Alignment;

assert_eq!(Alignment::MIN.as_usize(), 1);

pub const fn of<T>() -> Alignment

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

Available on crate feature rustls only.

Returns the alignment for a type.

This provides the same numerical value as align_of, but in an Alignment instead of a usize.

pub const fn of_val<T>(val: &T) -> Alignment

where T: ?Sized,

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

Available on crate feature rustls only.

Returns the ABI-required minimum alignment of the type of the value that val points to.

Every reference to a value of the type T must be a multiple of this number.

Examples

#![feature(ptr_alignment_type)]
use std::mem::Alignment;

assert_eq!(Alignment::of_val(&5i32).as_usize(), 4);

pub const unsafe fn of_val_raw<T>(val: *const T) -> Alignment

where T: ?Sized,

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

Available on crate feature rustls only.

Returns the ABI-required minimum alignment of the type of the value that val points to.

Every reference to a value of the type T must be a multiple of this number.

Safety

This function is only safe to call if the following conditions hold:

• If T is Sized, this function is always safe to call.
• If the unsized tail of T is:
  • a slice, then the length of the slice tail must be an initialized integer, and the size of the entire value (dynamic tail length + statically sized prefix) must fit in isize. For the special case where the dynamic tail length is 0, this function is safe to call.
  • a trait object, then the vtable part of the pointer must point to a valid vtable acquired by an unsizing coercion, and the size of the entire value (dynamic tail length + statically sized prefix) must fit in isize.
  • an (unstable) extern type, then this function is always safe to call, but may panic or otherwise return the wrong value, as the extern type’s layout is not known. This is the same behavior as Alignment::of_val on a reference to a type with an extern type tail.
  • otherwise, it is conservatively not allowed to call this function.

Examples

#![feature(ptr_alignment_type)]
use std::mem::Alignment;

assert_eq!(unsafe { Alignment::of_val_raw(&5i32) }.as_usize(), 4);

pub const fn new(align: usize) -> Option<Alignment>

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

Available on crate feature rustls only.

Creates an Alignment from a usize, or returns None if it’s not a power of two.

Note that 0 is not a power of two, nor a valid alignment.

pub const unsafe fn new_unchecked(align: usize) -> Alignment

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

Available on crate feature rustls only.

Creates an Alignment from a power-of-two usize.

Safety

align must be a power of two.

Equivalently, it must be 1 << exp for some exp in 0..usize::BITS. It must not be zero.

pub const fn as_usize(self) -> usize

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

Available on crate feature rustls only.

Returns the alignment as a usize.

pub const fn as_nonzero(self) -> NonZero<usize>

👎Deprecated since 1.96.0:

renamed to as_nonzero_usize

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

Available on crate feature rustls only.

Returns the alignment as a NonZero<usize>.

pub const fn as_nonzero_usize(self) -> NonZero<usize>

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

Available on crate feature rustls only.

Returns the alignment as a NonZero<usize>.

pub const fn log2(self) -> u32

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

Available on crate feature rustls only.

Returns the base-2 logarithm of the alignment.

This is always exact, as self represents a power of two.

Examples

#![feature(ptr_alignment_type)]
use std::ptr::Alignment;

assert_eq!(Alignment::of::<u8>().log2(), 0);
assert_eq!(Alignment::new(1024).unwrap().log2(), 10);

pub const fn mask(self) -> usize

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

Available on crate feature rustls only.

Returns a bit mask that can be used to match this alignment.

This is equivalent to !(self.as_usize() - 1).

Examples

#![feature(ptr_mask)]
#![feature(ptr_alignment_type)]
use std::mem::Alignment;
use std::ptr::NonNull;

#[repr(align(1))] struct Align1(u8);
#[repr(align(2))] struct Align2(u16);
#[repr(align(4))] struct Align4(u32);
let one = <NonNull<Align1>>::dangling().as_ptr();
let two = <NonNull<Align2>>::dangling().as_ptr();
let four = <NonNull<Align4>>::dangling().as_ptr();

assert_eq!(four.mask(Alignment::of::<Align1>().mask()), four);
assert_eq!(four.mask(Alignment::of::<Align2>().mask()), four);
assert_eq!(four.mask(Alignment::of::<Align4>().mask()), four);
assert_ne!(one.mask(Alignment::of::<Align4>().mask()), one);

Trait Implementations

impl Clone for Alignment

fn clone(&self) -> Alignment

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Alignment

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

Formats the value using the given formatter.

impl Default for Alignment

Returns Alignment::MIN, which is valid for any type.

fn default() -> Alignment

Returns the “default value” for a type.

impl From<Alignment> for NonZero<usize>

fn from(align: Alignment) -> NonZero<usize>

Converts to this type from the input type.

impl From<Alignment> for usize

fn from(align: Alignment) -> usize

Converts to this type from the input type.

impl Hash for Alignment

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

where H: Hasher,

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 Ord for Alignment

fn cmp(&self, other: &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 PartialEq for Alignment

fn eq(&self, other: &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 PartialOrd for Alignment

fn partial_cmp(&self, other: &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 TryFrom<NonZero<usize>> for Alignment

type Error = TryFromIntError

The type returned in the event of a conversion error.

fn try_from( align: NonZero<usize>, ) -> Result<Alignment, <Alignment as TryFrom<NonZero<usize>>>::Error>

Performs the conversion.

impl TryFrom<usize> for Alignment

type Error = TryFromIntError

The type returned in the event of a conversion error.

fn try_from( align: usize, ) -> Result<Alignment, <Alignment as TryFrom<usize>>::Error>

Performs the conversion.

impl Copy for Alignment

impl Eq for Alignment

impl StructuralPartialEq for Alignment