Struct rkyv::collections::util::Entry

pub struct Entry<K, V> {
    pub key: K,
    pub value: V,
}

A simple key-value pair.

This is typically used by associative containers that store keys and values together.

Fields

key: K

The key of the pair.

value: V

The value of the pair.

Trait Implementations

impl<K: Archive, V: Archive> Archive for Entry<&K, &V>

type Archived = Entry<<K as Archive>::Archived, <V as Archive>::Archived>

The archived representation of this type.

type Resolver = (<K as Archive>::Resolver, <V as Archive>::Resolver)

The resolver for this type. It must contain all the additional information from serializing needed to make the archived type from the normal type.

unsafe fn resolve( &self, pos: usize, resolver: Self::Resolver, out: *mut Self::Archived )

Creates the archived version of this value at the given position and writes it to the given output.

impl<K, V, C> CheckBytes<C> for Entry<K, V>

where K: CheckBytes<C>, V: CheckBytes<C>, C: ArchiveContext + ?Sized,

type Error = ArchivedEntryError<<K as CheckBytes<C>>::Error, <V as CheckBytes<C>>::Error>

The error that may result from checking the type.

unsafe fn check_bytes<'a>( value: *const Self, context: &mut C ) -> Result<&'a Self, Self::Error>

Checks whether the given pointer points to a valid value within the given context.

impl<K: Debug, V: Debug> Debug for Entry<K, V>

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

Formats the value using the given formatter.

impl<K, V, UK, UV> PartialEq<Entry<UK, UV>> for Entry<K, V>

where K: PartialEq<UK>, V: PartialEq<UV>,

fn eq(&self, other: &Entry<UK, UV>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<K: Serialize<S>, V: Serialize<S>, S: Fallible + ?Sized> Serialize<S> for Entry<&K, &V>

fn serialize(&self, serializer: &mut S) -> Result<Self::Resolver, S::Error>

Writes the dependencies for the object and returns a resolver that can create the archived type.

impl<K: Eq, V: Eq> Eq for Entry<K, V>