Trait ZeroMapKV

Source

pub trait ZeroMapKV<'a> {
    type Container: MutableZeroVecLike<'a, Self, SliceVariant = Self::Slice, GetType = Self::GetType, OwnedType = Self::OwnedType> + Sized;
    type Slice: ZeroVecLike<Self, GetType = Self::GetType> + ?Sized;
    type GetType: ?Sized + 'static;
    type OwnedType: 'static;
}

Expand description

Trait marking types which are allowed to be keys or values in ZeroMap.

Users should not be calling methods of this trait directly, however if you are implementing your own AsULE or VarULE type you may wish to implement this trait.

Required Associated Types§

Source

type Container: MutableZeroVecLike<'a, Self, SliceVariant = Self::Slice, GetType = Self::GetType, OwnedType = Self::OwnedType> + Sized

The container that can be used with this type: ZeroVec or VarZeroVec.

Source

type Slice: ZeroVecLike<Self, GetType = Self::GetType> + ?Sized

Source

type GetType: ?Sized + 'static

The type produced by Container::get()

This type will be predetermined by the choice of Self::Container: For sized types this must be T::ULE, and for unsized types this must be T

Source

type OwnedType: 'static

The type produced by Container::replace() and Container::remove(), also used during deserialization. If Self is human readable serialized, deserializing to Self::OwnedType should produce the same value once passed through Self::owned_as_self()

This type will be predetermined by the choice of Self::Container: For sized types this must be T and for unsized types this must be Box<T>

Dyn Compatibility§

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

ZeroMapKV

Trait ZeroMapKV Copy item path

Required Associated Types§

type Container: MutableZeroVecLike<'a, Self, SliceVariant = Self::Slice, GetType = Self::GetType, OwnedType = Self::OwnedType> + Sized

type Slice: ZeroVecLike<Self, GetType = Self::GetType> + ?Sized

type GetType: ?Sized + 'static

type OwnedType: 'static

Dyn Compatibility§

Implementations on Foreign Types§

impl<'a, A: Ord + AsULE + 'static, B: Ord + AsULE + 'static, C: Ord + AsULE + 'static, D: Ord + AsULE + 'static, E: Ord + AsULE + 'static, F: Ord + AsULE + 'static> ZeroMapKV<'a> for (A, B, C, D, E, F)

type Container = ZeroVec<'a, (A, B, C, D, E, F)>

type Slice = ZeroSlice<(A, B, C, D, E, F)>

type GetType = Tuple6ULE<<A as AsULE>::ULE, <B as AsULE>::ULE, <C as AsULE>::ULE, <D as AsULE>::ULE, <E as AsULE>::ULE, <F as AsULE>::ULE>

type OwnedType = (A, B, C, D, E, F)

impl<'a, A: Ord + AsULE + 'static, B: Ord + AsULE + 'static, C: Ord + AsULE + 'static, D: Ord + AsULE + 'static, E: Ord + AsULE + 'static> ZeroMapKV<'a> for (A, B, C, D, E)

type Container = ZeroVec<'a, (A, B, C, D, E)>

type Slice = ZeroSlice<(A, B, C, D, E)>

type GetType = Tuple5ULE<<A as AsULE>::ULE, <B as AsULE>::ULE, <C as AsULE>::ULE, <D as AsULE>::ULE, <E as AsULE>::ULE>

type OwnedType = (A, B, C, D, E)

impl<'a, A: Ord + AsULE + 'static, B: Ord + AsULE + 'static, C: Ord + AsULE + 'static, D: Ord + AsULE + 'static> ZeroMapKV<'a> for (A, B, C, D)

type Container = ZeroVec<'a, (A, B, C, D)>

type Slice = ZeroSlice<(A, B, C, D)>

type GetType = Tuple4ULE<<A as AsULE>::ULE, <B as AsULE>::ULE, <C as AsULE>::ULE, <D as AsULE>::ULE>

type OwnedType = (A, B, C, D)

impl<'a, A: Ord + AsULE + 'static, B: Ord + AsULE + 'static, C: Ord + AsULE + 'static> ZeroMapKV<'a> for (A, B, C)

type Container = ZeroVec<'a, (A, B, C)>

type Slice = ZeroSlice<(A, B, C)>

type GetType = Tuple3ULE<<A as AsULE>::ULE, <B as AsULE>::ULE, <C as AsULE>::ULE>

type OwnedType = (A, B, C)

impl<'a, A: Ord + AsULE + 'static, B: Ord + AsULE + 'static> ZeroMapKV<'a> for (A, B)

type Container = ZeroVec<'a, (A, B)>

type Slice = ZeroSlice<(A, B)>

type GetType = Tuple2ULE<<A as AsULE>::ULE, <B as AsULE>::ULE>

type OwnedType = (A, B)

impl<'a, T, const N: usize> ZeroMapKV<'a> for [T; N]where T: AsULE + 'static,

type Container = ZeroVec<'a, [T; N]>

type Slice = ZeroSlice<[T; N]>

type GetType = [<T as AsULE>::ULE; N]

type OwnedType = [T; N]

impl<'a, T> ZeroMapKV<'a> for Option<T>where Option<T>: AsULE + 'static,

type Container = ZeroVec<'a, Option<T>>

type Slice = ZeroSlice<Option<T>>

type GetType = <Option<T> as AsULE>::ULE

type OwnedType = Option<T>

impl<'a, T> ZeroMapKV<'a> for [T]where T: ULE + AsULE<ULE = T>,

type Container = VarZeroVec<'a, [T]>

type Slice = VarZeroSlice<[T]>

type GetType = [T]

type OwnedType = Box<[T]>

impl<'a> ZeroMapKV<'a> for NonZeroI8

type Container = ZeroVec<'a, NonZero<i8>>

type Slice = ZeroSlice<NonZero<i8>>

type GetType = <NonZero<i8> as AsULE>::ULE

type OwnedType = NonZero<i8>

impl<'a> ZeroMapKV<'a> for NonZeroU8

type Container = ZeroVec<'a, NonZero<u8>>

type Slice = ZeroSlice<NonZero<u8>>

type GetType = <NonZero<u8> as AsULE>::ULE

type OwnedType = NonZero<u8>

impl<'a> ZeroMapKV<'a> for char

type Container = ZeroVec<'a, char>

type Slice = ZeroSlice<char>

type GetType = <char as AsULE>::ULE

type OwnedType = char

impl<'a> ZeroMapKV<'a> for f32

type Container = ZeroVec<'a, f32>

type Slice = ZeroSlice<f32>

type GetType = <f32 as AsULE>::ULE

type OwnedType = f32

impl<'a> ZeroMapKV<'a> for f64

type Container = ZeroVec<'a, f64>

type Slice = ZeroSlice<f64>

type GetType = <f64 as AsULE>::ULE

type OwnedType = f64

impl<'a> ZeroMapKV<'a> for i8

type Container = ZeroVec<'a, i8>

type Slice = ZeroSlice<i8>

type GetType = <i8 as AsULE>::ULE

type OwnedType = i8

impl<'a> ZeroMapKV<'a> for i16

Trait ZeroMapKV

impl<'a, T, const N: usize> ZeroMapKV<'a> for [T; N]
where T: AsULE + 'static,

impl<'a, T> ZeroMapKV<'a> for Option<T>
where Option<T>: AsULE + 'static,

impl<'a, T> ZeroMapKV<'a> for [T]
where T: ULE + AsULE<ULE = T>,

impl<'a, A, B> ZeroMapKV<'a> for VarTupleULE<A, B>
where A: AsULE + 'static, B: VarULE + ?Sized,

impl<'a, T: AsULE + 'static, const N: usize> ZeroMapKV<'a> for NichedOption<T, N>
where T::ULE: NicheBytes<N>,

impl<'a, T> ZeroMapKV<'a> for OptionVarULE<T>
where T: VarULE + ?Sized,