Trait ZeroMapKV 

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;
}

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

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.

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

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

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", so this trait is not object safe.

Implementations on Foreign Types

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

type Container = ZeroVec<'a, i16>

type Slice = ZeroSlice<i16>

type GetType = <i16 as AsULE>::ULE

type OwnedType = i16

impl<'a> ZeroMapKV<'a> for i32

type Container = ZeroVec<'a, i32>

type Slice = ZeroSlice<i32>

type GetType = <i32 as AsULE>::ULE

type OwnedType = i32

impl<'a> ZeroMapKV<'a> for i64

type Container = ZeroVec<'a, i64>

type Slice = ZeroSlice<i64>

type GetType = <i64 as AsULE>::ULE

type OwnedType = i64

impl<'a> ZeroMapKV<'a> for i128

type Container = ZeroVec<'a, i128>

type Slice = ZeroSlice<i128>

type GetType = <i128 as AsULE>::ULE

type OwnedType = i128

impl<'a> ZeroMapKV<'a> for str

type Container = VarZeroVec<'a, str>

type Slice = VarZeroSlice<str>

type GetType = str

type OwnedType = Box<str>

impl<'a> ZeroMapKV<'a> for u8

type Container = ZeroVec<'a, u8>

type Slice = ZeroSlice<u8>

type GetType = <u8 as AsULE>::ULE

type OwnedType = u8

impl<'a> ZeroMapKV<'a> for u16

type Container = ZeroVec<'a, u16>

type Slice = ZeroSlice<u16>

type GetType = <u16 as AsULE>::ULE

type OwnedType = u16

impl<'a> ZeroMapKV<'a> for u32

type Container = ZeroVec<'a, u32>

type Slice = ZeroSlice<u32>

type GetType = <u32 as AsULE>::ULE

type OwnedType = u32

impl<'a> ZeroMapKV<'a> for u64

type Container = ZeroVec<'a, u64>

type Slice = ZeroSlice<u64>

type GetType = <u64 as AsULE>::ULE

type OwnedType = u64

impl<'a> ZeroMapKV<'a> for u128

type Container = ZeroVec<'a, u128>

type Slice = ZeroSlice<u128>

type GetType = <u128 as AsULE>::ULE

type OwnedType = u128

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, A: Ord + AsULE + 'static, B: Ord + AsULE + 'static> ZeroMapKV<'a> for (A, B)

Available on crate feature alloc only.

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, A: Ord + AsULE + 'static, B: Ord + AsULE + 'static, C: Ord + AsULE + 'static> ZeroMapKV<'a> for (A, B, C)

Available on crate feature alloc only.

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, C: Ord + AsULE + 'static, D: Ord + AsULE + 'static> ZeroMapKV<'a> for (A, B, C, D)

Available on crate feature alloc only.

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, D: Ord + AsULE + 'static, E: Ord + AsULE + 'static> ZeroMapKV<'a> for (A, B, C, D, E)

Available on crate feature alloc only.

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, E: Ord + AsULE + 'static, F: Ord + AsULE + 'static> ZeroMapKV<'a> for (A, B, C, D, E, F)

Available on crate feature alloc only.

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, 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, 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]

Implementors

impl<'a, A, B> ZeroMapKV<'a> for VarTupleULE<A, B>

where A: AsULE + 'static, B: VarULE + ?Sized,

type Container = VarZeroVec<'a, VarTupleULE<A, B>>

type Slice = VarZeroSlice<VarTupleULE<A, B>>

type GetType = VarTupleULE<A, B>

type OwnedType = Box<VarTupleULE<A, B>>

impl<'a, T> ZeroMapKV<'a> for ZeroSlice<T>

where T: AsULE + 'static,

type Container = VarZeroVec<'a, ZeroSlice<T>>

type Slice = VarZeroSlice<ZeroSlice<T>>

type GetType = ZeroSlice<T>

type OwnedType = Box<ZeroSlice<T>>

impl<'a, T> ZeroMapKV<'a> for OptionVarULE<T>

where T: VarULE + ?Sized,

type Container = VarZeroVec<'a, OptionVarULE<T>>

type Slice = VarZeroSlice<OptionVarULE<T>>

type GetType = OptionVarULE<T>

type OwnedType = Box<OptionVarULE<T>>

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

where T::ULE: NicheBytes<N>,

Available on crate feature alloc only.

type Container = ZeroVec<'a, NichedOption<T, N>>

type Slice = ZeroSlice<NichedOption<T, N>>

type GetType = <NichedOption<T, N> as AsULE>::ULE

type OwnedType = NichedOption<T, N>