Trait Size 

pub trait Size {
    type Size: Unsigned;

    const SIZE: usize = <Self::Size as Unsigned>::USIZE;
}

Provided Associated Constants

const SIZE: usize = <Self::Size as Unsigned>::USIZE

Required Associated Types

type Size: Unsigned

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl Size for Ordering

const SIZE: usize = 1

type Size = UInt<UTerm, B1>

impl Size for Infallible

const SIZE: usize = 0

type Size = UTerm

impl Size for bool

type Size = UInt<UTerm, B1>

impl Size for f32

const SIZE: usize

type Size = <Const<{ Self::SIZE }> as ToUInt>::Output

impl Size for f64

const SIZE: usize

type Size = <Const<{ Self::SIZE }> as ToUInt>::Output

impl Size for i8

const SIZE: usize

type Size = <Const<{ Self::SIZE }> as ToUInt>::Output

impl Size for i16

const SIZE: usize

type Size = <Const<{ Self::SIZE }> as ToUInt>::Output

impl Size for i32

const SIZE: usize

type Size = <Const<{ Self::SIZE }> as ToUInt>::Output

impl Size for i64

const SIZE: usize

type Size = <Const<{ Self::SIZE }> as ToUInt>::Output

impl Size for i128

const SIZE: usize

type Size = <Const<{ Self::SIZE }> as ToUInt>::Output

impl Size for u8

const SIZE: usize = 1

type Size = UInt<UTerm, B1>

impl Size for u16

const SIZE: usize

type Size = <Const<{ Self::SIZE }> as ToUInt>::Output

impl Size for u32

const SIZE: usize

type Size = <Const<{ Self::SIZE }> as ToUInt>::Output

impl Size for u64

const SIZE: usize

type Size = <Const<{ Self::SIZE }> as ToUInt>::Output

impl Size for u128

const SIZE: usize

type Size = <Const<{ Self::SIZE }> as ToUInt>::Output

impl Size for ()

const SIZE: usize = 0

type Size = UTerm

impl Size for NonZero<i8>

const SIZE: usize = <i8 as Size>::SIZE

type Size = <i8 as Size>::Size

impl Size for NonZero<i16>

const SIZE: usize = <i16 as Size>::SIZE

type Size = <i16 as Size>::Size

impl Size for NonZero<i32>

const SIZE: usize = <i32 as Size>::SIZE

type Size = <i32 as Size>::Size

impl Size for NonZero<i64>

const SIZE: usize = <i64 as Size>::SIZE

type Size = <i64 as Size>::Size

impl Size for NonZero<i128>

const SIZE: usize = <i128 as Size>::SIZE

type Size = <i128 as Size>::Size

impl Size for NonZero<u8>

const SIZE: usize = <u8 as Size>::SIZE

type Size = <u8 as Size>::Size

impl Size for NonZero<u16>

const SIZE: usize = <u16 as Size>::SIZE

type Size = <u16 as Size>::Size

impl Size for NonZero<u32>

const SIZE: usize = <u32 as Size>::SIZE

type Size = <u32 as Size>::Size

impl Size for NonZero<u64>

const SIZE: usize = <u64 as Size>::SIZE

type Size = <u64 as Size>::Size

impl Size for NonZero<u128>

const SIZE: usize = <u128 as Size>::SIZE

type Size = <u128 as Size>::Size

impl Size for Ulid

Available on crate feature ulid only.

const SIZE: usize = 16

type Size = UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>

impl<'a, B: 'a + ToOwned + Size + ?Sized> Size for Cow<'a, B>

const SIZE: usize = B::SIZE

type Size = <B as Size>::Size

impl<A, O: BitOrder> Size for BitArray<A, O>

where PhantomData<O>: Size, A: Size + BitViewSized, TArr<U0, TArr<<PhantomData<O> as Size>::Size, TArr<<A as Size>::Size, ATerm>>>: FoldAdd<Output: Unsigned>,

Available on crate feature bitvec only.

const SIZE: usize

type Size = <TArr<UTerm, TArr<<PhantomData<O> as Size>::Size, TArr<<A as Size>::Size, ATerm>>> as FoldAdd>::Output

impl<A: Size, B: Size> Size for (A, B)

where TArr<A::Size, TArr<B::Size, ATerm>>: FoldAdd<Output: Unsigned>,

const SIZE: usize

type Size = <TArr<<A as Size>::Size, TArr<<B as Size>::Size, ATerm>> as FoldAdd>::Output

impl<A: Size, B: Size, C: Size> Size for (A, B, C)

where TArr<A::Size, TArr<B::Size, TArr<C::Size, ATerm>>>: FoldAdd<Output: Unsigned>,

const SIZE: usize

type Size = <TArr<<A as Size>::Size, TArr<<B as Size>::Size, TArr<<C as Size>::Size, ATerm>>> as FoldAdd>::Output

impl<A: Size, B: Size, C: Size, D: Size> Size for (A, B, C, D)

where TArr<A::Size, TArr<B::Size, TArr<C::Size, TArr<D::Size, ATerm>>>>: FoldAdd<Output: Unsigned>,

const SIZE: usize

type Size = <TArr<<A as Size>::Size, TArr<<B as Size>::Size, TArr<<C as Size>::Size, TArr<<D as Size>::Size, ATerm>>>> as FoldAdd>::Output

impl<A: Size, B: Size, C: Size, D: Size, E: Size> Size for (A, B, C, D, E)

where TArr<A::Size, TArr<B::Size, TArr<C::Size, TArr<D::Size, TArr<E::Size, ATerm>>>>>: FoldAdd<Output: Unsigned>,

const SIZE: usize

type Size = <TArr<<A as Size>::Size, TArr<<B as Size>::Size, TArr<<C as Size>::Size, TArr<<D as Size>::Size, TArr<<E as Size>::Size, ATerm>>>>> as FoldAdd>::Output

impl<A: Size, B: Size, C: Size, D: Size, E: Size, F: Size> Size for (A, B, C, D, E, F)

where TArr<A::Size, TArr<B::Size, TArr<C::Size, TArr<D::Size, TArr<E::Size, TArr<F::Size, ATerm>>>>>>: FoldAdd<Output: Unsigned>,

const SIZE: usize

type Size = <TArr<<A as Size>::Size, TArr<<B as Size>::Size, TArr<<C as Size>::Size, TArr<<D as Size>::Size, TArr<<E as Size>::Size, TArr<<F as Size>::Size, ATerm>>>>>> as FoldAdd>::Output

impl<A: Size, B: Size, C: Size, D: Size, E: Size, F: Size, G: Size> Size for (A, B, C, D, E, F, G)

where TArr<A::Size, TArr<B::Size, TArr<C::Size, TArr<D::Size, TArr<E::Size, TArr<F::Size, TArr<G::Size, ATerm>>>>>>>: FoldAdd<Output: Unsigned>,

const SIZE: usize

type Size = <TArr<<A as Size>::Size, TArr<<B as Size>::Size, TArr<<C as Size>::Size, TArr<<D as Size>::Size, TArr<<E as Size>::Size, TArr<<F as Size>::Size, TArr<<G as Size>::Size, ATerm>>>>>>> as FoldAdd>::Output

impl<A: Size, B: Size, C: Size, D: Size, E: Size, F: Size, G: Size, H: Size> Size for (A, B, C, D, E, F, G, H)

where TArr<A::Size, TArr<B::Size, TArr<C::Size, TArr<D::Size, TArr<E::Size, TArr<F::Size, TArr<G::Size, TArr<H::Size, ATerm>>>>>>>>: FoldAdd<Output: Unsigned>,

const SIZE: usize

type Size = <TArr<<A as Size>::Size, TArr<<B as Size>::Size, TArr<<C as Size>::Size, TArr<<D as Size>::Size, TArr<<E as Size>::Size, TArr<<F as Size>::Size, TArr<<G as Size>::Size, TArr<<H as Size>::Size, ATerm>>>>>>>> as FoldAdd>::Output

impl<A: Size, B: Size, C: Size, D: Size, E: Size, F: Size, G: Size, H: Size, I: Size> Size for (A, B, C, D, E, F, G, H, I)

where TArr<A::Size, TArr<B::Size, TArr<C::Size, TArr<D::Size, TArr<E::Size, TArr<F::Size, TArr<G::Size, TArr<H::Size, TArr<I::Size, ATerm>>>>>>>>>: FoldAdd<Output: Unsigned>,

const SIZE: usize

type Size = <TArr<<A as Size>::Size, TArr<<B as Size>::Size, TArr<<C as Size>::Size, TArr<<D as Size>::Size, TArr<<E as Size>::Size, TArr<<F as Size>::Size, TArr<<G as Size>::Size, TArr<<H as Size>::Size, TArr<<I as Size>::Size, ATerm>>>>>>>>> as FoldAdd>::Output

impl<A: Size, B: Size, C: Size, D: Size, E: Size, F: Size, G: Size, H: Size, I: Size, J: Size> Size for (A, B, C, D, E, F, G, H, I, J)

where TArr<A::Size, TArr<B::Size, TArr<C::Size, TArr<D::Size, TArr<E::Size, TArr<F::Size, TArr<G::Size, TArr<H::Size, TArr<I::Size, TArr<J::Size, ATerm>>>>>>>>>>: FoldAdd<Output: Unsigned>,

const SIZE: usize

type Size = <TArr<<A as Size>::Size, TArr<<B as Size>::Size, TArr<<C as Size>::Size, TArr<<D as Size>::Size, TArr<<E as Size>::Size, TArr<<F as Size>::Size, TArr<<G as Size>::Size, TArr<<H as Size>::Size, TArr<<I as Size>::Size, TArr<<J as Size>::Size, ATerm>>>>>>>>>> as FoldAdd>::Output

impl<A: Size, B: Size, C: Size, D: Size, E: Size, F: Size, G: Size, H: Size, I: Size, J: Size, K: Size> Size for (A, B, C, D, E, F, G, H, I, J, K)

where TArr<A::Size, TArr<B::Size, TArr<C::Size, TArr<D::Size, TArr<E::Size, TArr<F::Size, TArr<G::Size, TArr<H::Size, TArr<I::Size, TArr<J::Size, TArr<K::Size, ATerm>>>>>>>>>>>: FoldAdd<Output: Unsigned>,

const SIZE: usize

type Size = <TArr<<A as Size>::Size, TArr<<B as Size>::Size, TArr<<C as Size>::Size, TArr<<D as Size>::Size, TArr<<E as Size>::Size, TArr<<F as Size>::Size, TArr<<G as Size>::Size, TArr<<H as Size>::Size, TArr<<I as Size>::Size, TArr<<J as Size>::Size, TArr<<K as Size>::Size, ATerm>>>>>>>>>>> as FoldAdd>::Output

impl<A: Size, B: Size, C: Size, D: Size, E: Size, F: Size, G: Size, H: Size, I: Size, J: Size, K: Size, L: Size> Size for (A, B, C, D, E, F, G, H, I, J, K, L)

where TArr<A::Size, TArr<B::Size, TArr<C::Size, TArr<D::Size, TArr<E::Size, TArr<F::Size, TArr<G::Size, TArr<H::Size, TArr<I::Size, TArr<J::Size, TArr<K::Size, TArr<L::Size, ATerm>>>>>>>>>>>>: FoldAdd<Output: Unsigned>,

const SIZE: usize

type Size = <TArr<<A as Size>::Size, TArr<<B as Size>::Size, TArr<<C as Size>::Size, TArr<<D as Size>::Size, TArr<<E as Size>::Size, TArr<<F as Size>::Size, TArr<<G as Size>::Size, TArr<<H as Size>::Size, TArr<<I as Size>::Size, TArr<<J as Size>::Size, TArr<<K as Size>::Size, TArr<<L as Size>::Size, ATerm>>>>>>>>>>>> as FoldAdd>::Output

impl<T> Size for dyn Send + Sync + ExtraFor<T>

const SIZE: usize = 0

type Size = UTerm

impl<T: Size + MaybeHasNiche<MnArray: MnArray<MaybeNiche: Niche<NeedsTag = B, N: Add<B, Output = N>>>>, B: Bit, N: Unsigned> Size for Option<T>

type Size = N

impl<T: Size> Size for (T,)

const SIZE: usize = T::SIZE

type Size = <T as Size>::Size

impl<T: Size, N> Size for GenericArray<T, N>

where N: Mul<T::Size, Output: Unsigned> + ArrayLength,

type Size = <N as Mul<<T as Size>::Size>>::Output

impl<T: Size, const N: usize> Size for [T; N]

where Const<N>: ToUInt<Output: Unsigned + Mul<T::Size, Output: Unsigned>>,

const SIZE: usize

type Size = <<Const<N> as ToUInt>::Output as Mul<<T as Size>::Size>>::Output

impl<T: ?Sized + Size> Size for Box<T>

const SIZE: usize = T::SIZE

type Size = <T as Size>::Size

impl<T: ?Sized + Size> Size for Arc<T>

const SIZE: usize = T::SIZE

type Size = <T as Size>::Size

impl<T: ?Sized> Size for PhantomData<T>

const SIZE: usize = 0

type Size = UTerm

Implementors

impl Size for Be<f32>

const SIZE: usize

type Size = <Const<{ Self::SIZE }> as ToUInt>::Output

impl Size for Be<f64>

const SIZE: usize

type Size = <Const<{ Self::SIZE }> as ToUInt>::Output

impl Size for Be<i8>

const SIZE: usize

type Size = <Const<{ Self::SIZE }> as ToUInt>::Output

impl Size for Be<i16>

const SIZE: usize

type Size = <Const<{ Self::SIZE }> as ToUInt>::Output

impl Size for Be<i32>

const SIZE: usize

type Size = <Const<{ Self::SIZE }> as ToUInt>::Output

impl Size for Be<i64>

const SIZE: usize

type Size = <Const<{ Self::SIZE }> as ToUInt>::Output

impl Size for Be<i128>

const SIZE: usize

type Size = <Const<{ Self::SIZE }> as ToUInt>::Output

impl Size for Be<u8>

const SIZE: usize

type Size = <Const<{ Self::SIZE }> as ToUInt>::Output

impl Size for Be<u16>

const SIZE: usize

type Size = <Const<{ Self::SIZE }> as ToUInt>::Output

impl Size for Be<u32>

const SIZE: usize

type Size = <Const<{ Self::SIZE }> as ToUInt>::Output

impl Size for Be<u64>

const SIZE: usize

type Size = <Const<{ Self::SIZE }> as ToUInt>::Output

impl Size for Be<u128>

const SIZE: usize

type Size = <Const<{ Self::SIZE }> as ToUInt>::Output

impl Size for Be<NonZero<i8>>

const SIZE: usize = <Be<i8> as Size>::SIZE

type Size = <Be<i8> as Size>::Size

impl Size for Be<NonZero<i16>>

const SIZE: usize = <Be<i16> as Size>::SIZE

type Size = <Be<i16> as Size>::Size

impl Size for Be<NonZero<i32>>

const SIZE: usize = <Be<i32> as Size>::SIZE

type Size = <Be<i32> as Size>::Size

impl Size for Be<NonZero<i64>>

const SIZE: usize = <Be<i64> as Size>::SIZE

type Size = <Be<i64> as Size>::Size

impl Size for Be<NonZero<i128>>

const SIZE: usize = <Be<i128> as Size>::SIZE

type Size = <Be<i128> as Size>::Size

impl Size for Be<NonZero<u8>>

const SIZE: usize = <Be<u8> as Size>::SIZE

type Size = <Be<u8> as Size>::Size

impl Size for Be<NonZero<u16>>

const SIZE: usize = <Be<u16> as Size>::SIZE

type Size = <Be<u16> as Size>::Size

impl Size for Be<NonZero<u32>>

const SIZE: usize = <Be<u32> as Size>::SIZE

type Size = <Be<u32> as Size>::Size

impl Size for Be<NonZero<u64>>

const SIZE: usize = <Be<u64> as Size>::SIZE

type Size = <Be<u64> as Size>::Size

impl Size for Be<NonZero<u128>>

const SIZE: usize = <Be<u128> as Size>::SIZE

type Size = <Be<u128> as Size>::Size

impl Size for Le<f32>

const SIZE: usize

type Size = <Const<{ Self::SIZE }> as ToUInt>::Output

impl Size for Le<f64>

const SIZE: usize

type Size = <Const<{ Self::SIZE }> as ToUInt>::Output

impl Size for Le<i8>

const SIZE: usize

type Size = <Const<{ Self::SIZE }> as ToUInt>::Output

impl Size for Le<i16>

const SIZE: usize

type Size = <Const<{ Self::SIZE }> as ToUInt>::Output

impl Size for Le<i32>

const SIZE: usize

type Size = <Const<{ Self::SIZE }> as ToUInt>::Output

impl Size for Le<i64>

const SIZE: usize

type Size = <Const<{ Self::SIZE }> as ToUInt>::Output

impl Size for Le<i128>

const SIZE: usize

type Size = <Const<{ Self::SIZE }> as ToUInt>::Output

impl Size for Le<u8>

const SIZE: usize

type Size = <Const<{ Self::SIZE }> as ToUInt>::Output

impl Size for Le<u16>

const SIZE: usize

type Size = <Const<{ Self::SIZE }> as ToUInt>::Output

impl Size for Le<u32>

const SIZE: usize

type Size = <Const<{ Self::SIZE }> as ToUInt>::Output

impl Size for Le<u64>

const SIZE: usize

type Size = <Const<{ Self::SIZE }> as ToUInt>::Output

impl Size for Le<u128>

const SIZE: usize

type Size = <Const<{ Self::SIZE }> as ToUInt>::Output

impl Size for Le<NonZero<i8>>

const SIZE: usize = <Le<i8> as Size>::SIZE

type Size = <Le<i8> as Size>::Size

impl Size for Le<NonZero<i16>>

const SIZE: usize = <Le<i16> as Size>::SIZE

type Size = <Le<i16> as Size>::Size

impl Size for Le<NonZero<i32>>

const SIZE: usize = <Le<i32> as Size>::SIZE

type Size = <Le<i32> as Size>::Size

impl Size for Le<NonZero<i64>>

const SIZE: usize = <Le<i64> as Size>::SIZE

type Size = <Le<i64> as Size>::Size

impl Size for Le<NonZero<i128>>

const SIZE: usize = <Le<i128> as Size>::SIZE

type Size = <Le<i128> as Size>::Size

impl Size for Le<NonZero<u8>>

const SIZE: usize = <Le<u8> as Size>::SIZE

type Size = <Le<u8> as Size>::Size

impl Size for Le<NonZero<u16>>

const SIZE: usize = <Le<u16> as Size>::SIZE

type Size = <Le<u16> as Size>::Size

impl Size for Le<NonZero<u32>>

const SIZE: usize = <Le<u32> as Size>::SIZE

type Size = <Le<u32> as Size>::Size

impl Size for Le<NonZero<u64>>

const SIZE: usize = <Le<u64> as Size>::SIZE

type Size = <Le<u64> as Size>::Size

impl Size for Le<NonZero<u128>>

const SIZE: usize = <Le<u128> as Size>::SIZE

type Size = <Le<u128> as Size>::Size

impl Size for Hash

where TArr<U0, TArr<<[u8; 32] as Size>::Size, ATerm>>: FoldAdd<Output: Unsigned>,

const SIZE: usize = <[u8; HASH_SIZE] as ::object_rainbow::Size>::SIZE

type Size = <TArr<UTerm, TArr<<[u8; 32] as Size>::Size, ATerm>> as FoldAdd>::Output

impl Size for OptionalHash

where TArr<U0, TArr<<[u8; 32] as Size>::Size, ATerm>>: FoldAdd<Output: Unsigned>,

const SIZE: usize = <[u8; HASH_SIZE] as ::object_rainbow::Size>::SIZE

type Size = <TArr<UTerm, TArr<<[u8; 32] as Size>::Size, ATerm>> as FoldAdd>::Output

impl<K> Size for PartialByteTag<K>

const SIZE: usize = 1

type Size = UInt<UTerm, B1>

impl<T, M> Size for MappedExtra<T, M>

where M: Size, T: Size, TArr<U0, TArr<<M as Size>::Size, TArr<<T as Size>::Size, ATerm>>>: FoldAdd<Output: Unsigned>,

const SIZE: usize

type Size = <TArr<UTerm, TArr<<M as Size>::Size, TArr<<T as Size>::Size, ATerm>>> as FoldAdd>::Output

impl<T, const MAX: usize> Size for EnumTag<T, MAX>

where T: Size, TArr<U0, TArr<<T as Size>::Size, ATerm>>: FoldAdd<Output: Unsigned>,

const SIZE: usize = <T as ::object_rainbow::Size>::SIZE

type Size = <TArr<UTerm, TArr<<T as Size>::Size, ATerm>> as FoldAdd>::Output

impl<T: ToOutput> Size for Hashed<T>

const SIZE: usize = Hash::SIZE

type Size = <Hash as Size>::Size