Struct elain::Align

#[repr(transparent)]pub struct Align<const N: usize>(_)
 where
    Self: Alignment;

A zero-sized-type aligned to N. Compound types containing a field Align<N> with have an alignment of at least N.

use elain::Align;
use core::mem::{align_of, align_of_val};

assert_eq!(align_of::<Align<1>>(), 1);
assert_eq!(align_of::<Align<2>>(), 2);
assert_eq!(align_of::<Align<4>>(), 4);

const FOO_ALIGN: usize = 8;

#[repr(C)]
struct Foo {
    _align: Align<FOO_ALIGN>,
}

let foo: Foo = Foo { _align: Align::NEW };

assert_eq!(align_of_val(&foo), 8);

Implementations

impl<const N: usize> Align<N> where
    Self: Alignment, 

pub const NEW: Self

An instance of Align<N>.

use elain::Align;
use core::mem::{align_of, align_of_val};

#[repr(C)]
struct Foo {
    _align: Align<8>,
}

let foo: Foo = Foo { _align: Align::NEW };

assert_eq!(align_of_val(&foo), 8);

Trait Implementations

impl Alignment for Align<1>

impl Alignment for Align<2>

impl Alignment for Align<1024>

impl Alignment for Align<2048>

impl Alignment for Align<4096>

impl Alignment for Align<8192>

impl Alignment for Align<16384>

impl Alignment for Align<32768>

impl Alignment for Align<65536>

impl Alignment for Align<131072>

impl Alignment for Align<262144>

impl Alignment for Align<524288>

impl Alignment for Align<4>

impl Alignment for Align<1048576>

impl Alignment for Align<2097152>

impl Alignment for Align<4194304>

impl Alignment for Align<8388608>

impl Alignment for Align<16777216>

impl Alignment for Align<33554432>

impl Alignment for Align<67108864>

impl Alignment for Align<134217728>

impl Alignment for Align<268435456>

impl Alignment for Align<8>

impl Alignment for Align<16>

impl Alignment for Align<32>

impl Alignment for Align<64>

impl Alignment for Align<128>

impl Alignment for Align<256>

impl Alignment for Align<512>

impl<const N: usize> Clone for Align<N> where
    Self: Alignment, 

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<const N: usize> Copy for Align<N> where
    Self: Alignment, 

impl<const N: usize> Debug for Align<N> where
    Self: Alignment, 

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

Formats the value using the given formatter.

impl<const N: usize> Default for Align<N> where
    Self: Alignment, 

fn default() -> Self

Returns the “default value” for a type.

impl<const N: usize> Eq for Align<N> where
    Self: Alignment, 

impl<const N: usize> Hash for Align<N> where
    Self: Alignment, 

fn hash<H: Hasher>(&self, _: &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<const N: usize> Ord for Align<N> where
    Self: Alignment, 

fn cmp(&self, _: &Self) -> Ordering

This method returns an Ordering between self and other.

#[must_use]pub fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use]pub fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self

Restrict a value to a certain interval.

impl<const N: usize> PartialEq<Align<N>> for Align<N> where
    Self: Alignment, 

fn eq(&self, other: &Align<N>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Align<N>) -> bool

This method tests for !=.

impl<const N: usize> PartialOrd<Align<N>> for Align<N> where
    Self: Alignment, 

fn partial_cmp(&self, _: &Self) -> Option<Ordering>

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

#[must_use]pub fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

#[must_use]pub fn le(&self, other: &Rhs) -> bool

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

#[must_use]pub fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

#[must_use]pub fn ge(&self, other: &Rhs) -> bool

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

impl<const N: usize> StructuralEq for Align<N> where
    Self: Alignment, 

impl<const N: usize> StructuralPartialEq for Align<N> where
    Self: Alignment,