Enum AlignmentEnum

#[repr(usize)]
pub(in ::mem::alignment) enum AlignmentEnum

Variants

_Align1Shl0 = { _ }
_Align1Shl1 = { _ }
_Align1Shl2 = { _ }
_Align1Shl3 = { _ }
_Align1Shl4 = { _ }
_Align1Shl5 = { _ }
_Align1Shl6 = { _ }
_Align1Shl7 = { _ }
_Align1Shl8 = { _ }
_Align1Shl9 = { _ }
_Align1Shl10 = { _ }
_Align1Shl11 = { _ }
_Align1Shl12 = { _ }
_Align1Shl13 = { _ }
_Align1Shl14 = { _ }
_Align1Shl15 = { _ }
_Align1Shl16 = { _ }
_Align1Shl17 = { _ }
_Align1Shl18 = { _ }
_Align1Shl19 = { _ }
_Align1Shl20 = { _ }
_Align1Shl21 = { _ }
_Align1Shl22 = { _ }
_Align1Shl23 = { _ }
_Align1Shl24 = { _ }
_Align1Shl25 = { _ }
_Align1Shl26 = { _ }
_Align1Shl27 = { _ }
_Align1Shl28 = { _ }
_Align1Shl29 = { _ }
_Align1Shl30 = { _ }
_Align1Shl31 = { _ }
_Align1Shl32 = { _ }
_Align1Shl33 = { _ }
_Align1Shl34 = { _ }
_Align1Shl35 = { _ }
_Align1Shl36 = { _ }
_Align1Shl37 = { _ }
_Align1Shl38 = { _ }
_Align1Shl39 = { _ }
_Align1Shl40 = { _ }
_Align1Shl41 = { _ }
_Align1Shl42 = { _ }
_Align1Shl43 = { _ }
_Align1Shl44 = { _ }
_Align1Shl45 = { _ }
_Align1Shl46 = { _ }
_Align1Shl47 = { _ }
_Align1Shl48 = { _ }
_Align1Shl49 = { _ }
_Align1Shl50 = { _ }
_Align1Shl51 = { _ }
_Align1Shl52 = { _ }
_Align1Shl53 = { _ }
_Align1Shl54 = { _ }
_Align1Shl55 = { _ }
_Align1Shl56 = { _ }
_Align1Shl57 = { _ }
_Align1Shl58 = { _ }
_Align1Shl59 = { _ }
_Align1Shl60 = { _ }
_Align1Shl61 = { _ }
_Align1Shl62 = { _ }
_Align1Shl63 = { _ }

Trait Implementations

impl Clone for AlignmentEnum

fn clone(&self) -> AlignmentEnum

impl Copy for AlignmentEnum

impl Eq for AlignmentEnum

fn assert_fields_are_eq(&self)

impl PartialEq for AlignmentEnum

fn eq(&self, other: &AlignmentEnum) -> bool

impl StructuralPartialEq for AlignmentEnum

impl TrivialClone for AlignmentEnum

Auto Trait Implementations

impl Freeze for AlignmentEnum

impl RefUnwindSafe for AlignmentEnum

impl Send for AlignmentEnum

impl Sync for AlignmentEnum

impl Unpin for AlignmentEnum

impl UnsafeUnpin for AlignmentEnum

impl UnwindSafe for AlignmentEnum

Blanket Implementations

impl<T> Any for AlignmentEnum where T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<T> Borrow<T> for AlignmentEnum where T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for AlignmentEnum where T: ?Sized,

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

impl<T> CloneToUninit for AlignmentEnum where T: Clone,

unsafe fn clone_to_uninit(&self, dest: *mut u8)

impl<T> From<T> for AlignmentEnum

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> SizeHint for AlignmentEnum where T: ?Sized,

fn lower_bound(&self) -> usize
fn upper_bound(&self) -> Option<usize>

impl<T> SizedTypeProperties for AlignmentEnum

impl<T, U> Into<U> for AlignmentEnum where U: From<T>,

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

impl<T, U> TryFrom<U> for AlignmentEnum where U: Into<T>,

type Error = Infallible;
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

impl<T, U> TryInto<U> for AlignmentEnum where U: TryFrom<T>,

type Error = <U as TryFrom<T>>::Error;
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>