Struct Dim 

pub struct Dim<L, T, M, Th, I, N, J, A>(/* private fields */)
where
    L: Integer,
    T: Integer,
    M: Integer,
    Th: Integer,
    I: Integer,
    N: Integer,
    J: Integer,
    A: Integer;

A physical dimension encoded as eight typenum integer exponents.

This is a zero-sized type: no runtime cost.

Trait Implementations

impl<L, T, M, Th, I, N, J, A> Clone for Dim<L, T, M, Th, I, N, J, A>

where L: Clone + Integer, T: Clone + Integer, M: Clone + Integer, Th: Clone + Integer, I: Clone + Integer, N: Clone + Integer, J: Clone + Integer, A: Clone + Integer,

fn clone(&self) -> Dim<L, T, M, Th, I, N, J, A>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<L, T, M, Th, I, N, J, A> Debug for Dim<L, T, M, Th, I, N, J, A>

where L: Debug + Integer, T: Debug + Integer, M: Debug + Integer, Th: Debug + Integer, I: Debug + Integer, N: Debug + Integer, J: Debug + Integer, A: Debug + Integer,

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

Formats the value using the given formatter.

impl<L1, T1, M1, Th1, I1, N1, J1, A1, L2, T2, M2, Th2, I2, N2, J2, A2> DimDiv<Dim<L2, T2, M2, Th2, I2, N2, J2, A2>> for Dim<L1, T1, M1, Th1, I1, N1, J1, A1>

where L1: Integer + Sub<L2> + 'static, T1: Integer + Sub<T2> + 'static, M1: Integer + Sub<M2> + 'static, Th1: Integer + Sub<Th2> + 'static, I1: Integer + Sub<I2> + 'static, N1: Integer + Sub<N2> + 'static, J1: Integer + Sub<J2> + 'static, A1: Integer + Sub<A2> + 'static, L2: Integer + 'static, T2: Integer + 'static, M2: Integer + 'static, Th2: Integer + 'static, I2: Integer + 'static, N2: Integer + 'static, J2: Integer + 'static, A2: Integer + 'static, <L1 as Sub<L2>>::Output: Integer + 'static, <T1 as Sub<T2>>::Output: Integer + 'static, <M1 as Sub<M2>>::Output: Integer + 'static, <Th1 as Sub<Th2>>::Output: Integer + 'static, <I1 as Sub<I2>>::Output: Integer + 'static, <N1 as Sub<N2>>::Output: Integer + 'static, <J1 as Sub<J2>>::Output: Integer + 'static, <A1 as Sub<A2>>::Output: Integer + 'static,

type Output = Dim<<L1 as Sub<L2>>::Output, <T1 as Sub<T2>>::Output, <M1 as Sub<M2>>::Output, <Th1 as Sub<Th2>>::Output, <I1 as Sub<I2>>::Output, <N1 as Sub<N2>>::Output, <J1 as Sub<J2>>::Output, <A1 as Sub<A2>>::Output>

The resulting dimension.

impl<L1, T1, M1, Th1, I1, N1, J1, A1, L2, T2, M2, Th2, I2, N2, J2, A2> DimMul<Dim<L2, T2, M2, Th2, I2, N2, J2, A2>> for Dim<L1, T1, M1, Th1, I1, N1, J1, A1>

where L1: Integer + Add<L2> + 'static, T1: Integer + Add<T2> + 'static, M1: Integer + Add<M2> + 'static, Th1: Integer + Add<Th2> + 'static, I1: Integer + Add<I2> + 'static, N1: Integer + Add<N2> + 'static, J1: Integer + Add<J2> + 'static, A1: Integer + Add<A2> + 'static, L2: Integer + 'static, T2: Integer + 'static, M2: Integer + 'static, Th2: Integer + 'static, I2: Integer + 'static, N2: Integer + 'static, J2: Integer + 'static, A2: Integer + 'static, <L1 as Add<L2>>::Output: Integer + 'static, <T1 as Add<T2>>::Output: Integer + 'static, <M1 as Add<M2>>::Output: Integer + 'static, <Th1 as Add<Th2>>::Output: Integer + 'static, <I1 as Add<I2>>::Output: Integer + 'static, <N1 as Add<N2>>::Output: Integer + 'static, <J1 as Add<J2>>::Output: Integer + 'static, <A1 as Add<A2>>::Output: Integer + 'static,

type Output = Dim<<L1 as Add<L2>>::Output, <T1 as Add<T2>>::Output, <M1 as Add<M2>>::Output, <Th1 as Add<Th2>>::Output, <I1 as Add<I2>>::Output, <N1 as Add<N2>>::Output, <J1 as Add<J2>>::Output, <A1 as Add<A2>>::Output>

The resulting dimension.

impl<L, T, M, Th, I, N, J, A> PartialEq for Dim<L, T, M, Th, I, N, J, A>

where L: PartialEq + Integer, T: PartialEq + Integer, M: PartialEq + Integer, Th: PartialEq + Integer, I: PartialEq + Integer, N: PartialEq + Integer, J: PartialEq + Integer, A: PartialEq + Integer,

fn eq(&self, other: &Dim<L, T, M, Th, I, N, J, A>) -> 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<L, T, M, Th, I, N, J, A> Copy for Dim<L, T, M, Th, I, N, J, A>

where L: Copy + Integer, T: Copy + Integer, M: Copy + Integer, Th: Copy + Integer, I: Copy + Integer, N: Copy + Integer, J: Copy + Integer, A: Copy + Integer,

impl<L, T, M, Th, I, N, J, A> Dimension for Dim<L, T, M, Th, I, N, J, A>

where L: Integer + 'static, T: Integer + 'static, M: Integer + 'static, Th: Integer + 'static, I: Integer + 'static, N: Integer + 'static, J: Integer + 'static, A: Integer + 'static,

impl<L, T, M, Th, I, N, J, A> Eq for Dim<L, T, M, Th, I, N, J, A>

where L: Eq + Integer, T: Eq + Integer, M: Eq + Integer, Th: Eq + Integer, I: Eq + Integer, N: Eq + Integer, J: Eq + Integer, A: Eq + Integer,

impl<L, T, M, Th, I, N, J, A> StructuralPartialEq for Dim<L, T, M, Th, I, N, J, A>

where L: Integer, T: Integer, M: Integer, Th: Integer, I: Integer, N: Integer, J: Integer, A: Integer,