Trait rkyv::Resolve

pub trait Resolve<T: ?Sized> {
    type Archived;
    pub fn resolve(self, pos: usize, value: &T) -> Self::Archived;
}

Creates an archived value when given a value and position.

Resolvers are passed the original value, so any information that is already in them doesn't have to be stored in the resolver.

See Archive for an example of how to use Resolve.

Associated Types

type Archived

The type that this resolver resolves to.

Loading content...

Required methods

pub fn resolve(self, pos: usize, value: &T) -> Self::Archived

Creates the archived version of the given value at the given position.

Loading content...

Implementations on Foreign Types

impl<T: Archive> Resolve<Range<T>> for Range<T::Resolver>

type Archived = ArchivedRange<T::Archived>

pub fn resolve(self, pos: usize, value: &Range<T>) -> Self::Archived

impl<T: Archive> Resolve<RangeInclusive<T>> for Range<T::Resolver>

type Archived = ArchivedRangeInclusive<T::Archived>

pub fn resolve(self, pos: usize, value: &RangeInclusive<T>) -> Self::Archived

impl<T: Archive> Resolve<T> for usize

type Archived = ArchivedRef<T::Archived>

pub fn resolve(self, pos: usize, _value: &T) -> Self::Archived

impl<T: Archive> Resolve<[T]> for usize

type Archived = ArchivedSlice<T::Archived>

pub fn resolve(self, pos: usize, value: &[T]) -> Self::Archived

impl<T11: Archive, T10: Archive, T9: Archive, T8: Archive, T7: Archive, T6: Archive, T5: Archive, T4: Archive, T3: Archive, T2: Archive, T1: Archive, T0: Archive> Resolve<(T11, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0)> for (T11::Resolver, T10::Resolver, T9::Resolver, T8::Resolver, T7::Resolver, T6::Resolver, T5::Resolver, T4::Resolver, T3::Resolver, T2::Resolver, T1::Resolver, T0::Resolver)

type Archived = (T11::Archived, T10::Archived, T9::Archived, T8::Archived, T7::Archived, T6::Archived, T5::Archived, T4::Archived, T3::Archived, T2::Archived, T1::Archived, T0::Archived)

pub fn resolve(
    self,
    pos: usize,
    value: &(T11, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0)
) -> Self::Archived

impl<T10: Archive, T9: Archive, T8: Archive, T7: Archive, T6: Archive, T5: Archive, T4: Archive, T3: Archive, T2: Archive, T1: Archive, T0: Archive> Resolve<(T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0)> for (T10::Resolver, T9::Resolver, T8::Resolver, T7::Resolver, T6::Resolver, T5::Resolver, T4::Resolver, T3::Resolver, T2::Resolver, T1::Resolver, T0::Resolver)

type Archived = (T10::Archived, T9::Archived, T8::Archived, T7::Archived, T6::Archived, T5::Archived, T4::Archived, T3::Archived, T2::Archived, T1::Archived, T0::Archived)

pub fn resolve(
    self,
    pos: usize,
    value: &(T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0)
) -> Self::Archived

impl<T9: Archive, T8: Archive, T7: Archive, T6: Archive, T5: Archive, T4: Archive, T3: Archive, T2: Archive, T1: Archive, T0: Archive> Resolve<(T9, T8, T7, T6, T5, T4, T3, T2, T1, T0)> for (T9::Resolver, T8::Resolver, T7::Resolver, T6::Resolver, T5::Resolver, T4::Resolver, T3::Resolver, T2::Resolver, T1::Resolver, T0::Resolver)

type Archived = (T9::Archived, T8::Archived, T7::Archived, T6::Archived, T5::Archived, T4::Archived, T3::Archived, T2::Archived, T1::Archived, T0::Archived)

pub fn resolve(
    self,
    pos: usize,
    value: &(T9, T8, T7, T6, T5, T4, T3, T2, T1, T0)
) -> Self::Archived

impl<T8: Archive, T7: Archive, T6: Archive, T5: Archive, T4: Archive, T3: Archive, T2: Archive, T1: Archive, T0: Archive> Resolve<(T8, T7, T6, T5, T4, T3, T2, T1, T0)> for (T8::Resolver, T7::Resolver, T6::Resolver, T5::Resolver, T4::Resolver, T3::Resolver, T2::Resolver, T1::Resolver, T0::Resolver)

type Archived = (T8::Archived, T7::Archived, T6::Archived, T5::Archived, T4::Archived, T3::Archived, T2::Archived, T1::Archived, T0::Archived)

pub fn resolve(
    self,
    pos: usize,
    value: &(T8, T7, T6, T5, T4, T3, T2, T1, T0)
) -> Self::Archived

impl<T7: Archive, T6: Archive, T5: Archive, T4: Archive, T3: Archive, T2: Archive, T1: Archive, T0: Archive> Resolve<(T7, T6, T5, T4, T3, T2, T1, T0)> for (T7::Resolver, T6::Resolver, T5::Resolver, T4::Resolver, T3::Resolver, T2::Resolver, T1::Resolver, T0::Resolver)

type Archived = (T7::Archived, T6::Archived, T5::Archived, T4::Archived, T3::Archived, T2::Archived, T1::Archived, T0::Archived)

pub fn resolve(
    self,
    pos: usize,
    value: &(T7, T6, T5, T4, T3, T2, T1, T0)
) -> Self::Archived

impl<T6: Archive, T5: Archive, T4: Archive, T3: Archive, T2: Archive, T1: Archive, T0: Archive> Resolve<(T6, T5, T4, T3, T2, T1, T0)> for (T6::Resolver, T5::Resolver, T4::Resolver, T3::Resolver, T2::Resolver, T1::Resolver, T0::Resolver)

type Archived = (T6::Archived, T5::Archived, T4::Archived, T3::Archived, T2::Archived, T1::Archived, T0::Archived)

pub fn resolve(
    self,
    pos: usize,
    value: &(T6, T5, T4, T3, T2, T1, T0)
) -> Self::Archived

impl<T5: Archive, T4: Archive, T3: Archive, T2: Archive, T1: Archive, T0: Archive> Resolve<(T5, T4, T3, T2, T1, T0)> for (T5::Resolver, T4::Resolver, T3::Resolver, T2::Resolver, T1::Resolver, T0::Resolver)

type Archived = (T5::Archived, T4::Archived, T3::Archived, T2::Archived, T1::Archived, T0::Archived)

pub fn resolve(
    self,
    pos: usize,
    value: &(T5, T4, T3, T2, T1, T0)
) -> Self::Archived

impl<T4: Archive, T3: Archive, T2: Archive, T1: Archive, T0: Archive> Resolve<(T4, T3, T2, T1, T0)> for (T4::Resolver, T3::Resolver, T2::Resolver, T1::Resolver, T0::Resolver)

type Archived = (T4::Archived, T3::Archived, T2::Archived, T1::Archived, T0::Archived)

pub fn resolve(self, pos: usize, value: &(T4, T3, T2, T1, T0)) -> Self::Archived

impl<T3: Archive, T2: Archive, T1: Archive, T0: Archive> Resolve<(T3, T2, T1, T0)> for (T3::Resolver, T2::Resolver, T1::Resolver, T0::Resolver)

type Archived = (T3::Archived, T2::Archived, T1::Archived, T0::Archived)

pub fn resolve(self, pos: usize, value: &(T3, T2, T1, T0)) -> Self::Archived

impl<T2: Archive, T1: Archive, T0: Archive> Resolve<(T2, T1, T0)> for (T2::Resolver, T1::Resolver, T0::Resolver)

type Archived = (T2::Archived, T1::Archived, T0::Archived)

pub fn resolve(self, pos: usize, value: &(T2, T1, T0)) -> Self::Archived

impl<T1: Archive, T0: Archive> Resolve<(T1, T0)> for (T1::Resolver, T0::Resolver)

type Archived = (T1::Archived, T0::Archived)

pub fn resolve(self, pos: usize, value: &(T1, T0)) -> Self::Archived

impl<T0: Archive> Resolve<(T0,)> for (T0::Resolver,)

type Archived = (T0::Archived,)

pub fn resolve(self, pos: usize, value: &(T0,)) -> Self::Archived

impl<T: Archive> Resolve<[T; 31]> for [T::Resolver; 31]

type Archived = [T::Archived; 31]

pub fn resolve(self, pos: usize, value: &[T; 31]) -> Self::Archived

impl<T: Archive> Resolve<[T; 30]> for [T::Resolver; 30]

type Archived = [T::Archived; 30]

pub fn resolve(self, pos: usize, value: &[T; 30]) -> Self::Archived

impl<T: Archive> Resolve<[T; 29]> for [T::Resolver; 29]

type Archived = [T::Archived; 29]

pub fn resolve(self, pos: usize, value: &[T; 29]) -> Self::Archived

impl<T: Archive> Resolve<[T; 28]> for [T::Resolver; 28]

type Archived = [T::Archived; 28]

pub fn resolve(self, pos: usize, value: &[T; 28]) -> Self::Archived

impl<T: Archive> Resolve<[T; 27]> for [T::Resolver; 27]

type Archived = [T::Archived; 27]

pub fn resolve(self, pos: usize, value: &[T; 27]) -> Self::Archived

impl<T: Archive> Resolve<[T; 26]> for [T::Resolver; 26]

type Archived = [T::Archived; 26]

pub fn resolve(self, pos: usize, value: &[T; 26]) -> Self::Archived

impl<T: Archive> Resolve<[T; 25]> for [T::Resolver; 25]

type Archived = [T::Archived; 25]

pub fn resolve(self, pos: usize, value: &[T; 25]) -> Self::Archived

impl<T: Archive> Resolve<[T; 24]> for [T::Resolver; 24]

type Archived = [T::Archived; 24]

pub fn resolve(self, pos: usize, value: &[T; 24]) -> Self::Archived

impl<T: Archive> Resolve<[T; 23]> for [T::Resolver; 23]

type Archived = [T::Archived; 23]

pub fn resolve(self, pos: usize, value: &[T; 23]) -> Self::Archived

impl<T: Archive> Resolve<[T; 22]> for [T::Resolver; 22]

type Archived = [T::Archived; 22]

pub fn resolve(self, pos: usize, value: &[T; 22]) -> Self::Archived

impl<T: Archive> Resolve<[T; 21]> for [T::Resolver; 21]

type Archived = [T::Archived; 21]

pub fn resolve(self, pos: usize, value: &[T; 21]) -> Self::Archived

impl<T: Archive> Resolve<[T; 20]> for [T::Resolver; 20]

type Archived = [T::Archived; 20]

pub fn resolve(self, pos: usize, value: &[T; 20]) -> Self::Archived

impl<T: Archive> Resolve<[T; 19]> for [T::Resolver; 19]

type Archived = [T::Archived; 19]

pub fn resolve(self, pos: usize, value: &[T; 19]) -> Self::Archived

impl<T: Archive> Resolve<[T; 18]> for [T::Resolver; 18]

type Archived = [T::Archived; 18]

pub fn resolve(self, pos: usize, value: &[T; 18]) -> Self::Archived

impl<T: Archive> Resolve<[T; 17]> for [T::Resolver; 17]

type Archived = [T::Archived; 17]

pub fn resolve(self, pos: usize, value: &[T; 17]) -> Self::Archived

impl<T: Archive> Resolve<[T; 16]> for [T::Resolver; 16]

type Archived = [T::Archived; 16]

pub fn resolve(self, pos: usize, value: &[T; 16]) -> Self::Archived

impl<T: Archive> Resolve<[T; 15]> for [T::Resolver; 15]

type Archived = [T::Archived; 15]

pub fn resolve(self, pos: usize, value: &[T; 15]) -> Self::Archived

impl<T: Archive> Resolve<[T; 14]> for [T::Resolver; 14]

type Archived = [T::Archived; 14]

pub fn resolve(self, pos: usize, value: &[T; 14]) -> Self::Archived

impl<T: Archive> Resolve<[T; 13]> for [T::Resolver; 13]

type Archived = [T::Archived; 13]

pub fn resolve(self, pos: usize, value: &[T; 13]) -> Self::Archived

impl<T: Archive> Resolve<[T; 12]> for [T::Resolver; 12]

type Archived = [T::Archived; 12]

pub fn resolve(self, pos: usize, value: &[T; 12]) -> Self::Archived

impl<T: Archive> Resolve<[T; 11]> for [T::Resolver; 11]

type Archived = [T::Archived; 11]

pub fn resolve(self, pos: usize, value: &[T; 11]) -> Self::Archived

impl<T: Archive> Resolve<[T; 10]> for [T::Resolver; 10]

type Archived = [T::Archived; 10]

pub fn resolve(self, pos: usize, value: &[T; 10]) -> Self::Archived

impl<T: Archive> Resolve<[T; 9]> for [T::Resolver; 9]

type Archived = [T::Archived; 9]

pub fn resolve(self, pos: usize, value: &[T; 9]) -> Self::Archived

impl<T: Archive> Resolve<[T; 8]> for [T::Resolver; 8]

type Archived = [T::Archived; 8]

pub fn resolve(self, pos: usize, value: &[T; 8]) -> Self::Archived

impl<T: Archive> Resolve<[T; 7]> for [T::Resolver; 7]

type Archived = [T::Archived; 7]

pub fn resolve(self, pos: usize, value: &[T; 7]) -> Self::Archived

impl<T: Archive> Resolve<[T; 6]> for [T::Resolver; 6]

type Archived = [T::Archived; 6]

pub fn resolve(self, pos: usize, value: &[T; 6]) -> Self::Archived

impl<T: Archive> Resolve<[T; 5]> for [T::Resolver; 5]

type Archived = [T::Archived; 5]

pub fn resolve(self, pos: usize, value: &[T; 5]) -> Self::Archived

impl<T: Archive> Resolve<[T; 4]> for [T::Resolver; 4]

type Archived = [T::Archived; 4]

pub fn resolve(self, pos: usize, value: &[T; 4]) -> Self::Archived

impl<T: Archive> Resolve<[T; 3]> for [T::Resolver; 3]

type Archived = [T::Archived; 3]

pub fn resolve(self, pos: usize, value: &[T; 3]) -> Self::Archived

impl<T: Archive> Resolve<[T; 2]> for [T::Resolver; 2]

type Archived = [T::Archived; 2]

pub fn resolve(self, pos: usize, value: &[T; 2]) -> Self::Archived

impl<T: Archive> Resolve<[T; 1]> for [T::Resolver; 1]

type Archived = [T::Archived; 1]

pub fn resolve(self, pos: usize, value: &[T; 1]) -> Self::Archived

impl<T: Archive> Resolve<[T; 0]> for [T::Resolver; 0]

type Archived = [T::Archived; 0]

pub fn resolve(self, pos: usize, value: &[T; 0]) -> Self::Archived

impl Resolve<str> for usize

type Archived = ArchivedStringSlice

pub fn resolve(self, pos: usize, value: &str) -> Self::Archived

impl<T: Archive> Resolve<Option<T>> for Option<T::Resolver>

type Archived = ArchivedOption<T::Archived>

pub fn resolve(self, pos: usize, value: &Option<T>) -> Self::Archived

Loading content...

Implementors

impl Resolve<AtomicBool> for AtomicResolver

type Archived = AtomicBool

pub fn resolve(self, _pos: usize, value: &AtomicBool) -> AtomicBool

impl Resolve<AtomicI8> for AtomicResolver

type Archived = AtomicI8

pub fn resolve(self, _pos: usize, value: &AtomicI8) -> AtomicI8

impl Resolve<AtomicI16> for AtomicResolver

type Archived = AtomicI16

pub fn resolve(self, _pos: usize, value: &AtomicI16) -> AtomicI16

impl Resolve<AtomicI32> for AtomicResolver

type Archived = AtomicI32

pub fn resolve(self, _pos: usize, value: &AtomicI32) -> AtomicI32

impl Resolve<AtomicI64> for AtomicResolver

type Archived = AtomicI64

pub fn resolve(self, _pos: usize, value: &AtomicI64) -> AtomicI64

impl Resolve<AtomicU8> for AtomicResolver

type Archived = AtomicU8

pub fn resolve(self, _pos: usize, value: &AtomicU8) -> AtomicU8

impl Resolve<AtomicU16> for AtomicResolver

type Archived = AtomicU16

pub fn resolve(self, _pos: usize, value: &AtomicU16) -> AtomicU16

impl Resolve<AtomicU32> for AtomicResolver

type Archived = AtomicU32

pub fn resolve(self, _pos: usize, value: &AtomicU32) -> AtomicU32

impl Resolve<AtomicU64> for AtomicResolver

type Archived = AtomicU64

pub fn resolve(self, _pos: usize, value: &AtomicU64) -> AtomicU64

impl<K: Archive + Hash + Eq> Resolve<HashSet<K, RandomState>> for ArchivedHashSetResolver where
    K::Archived: Hash + Eq, 

type Archived = ArchivedHashSet<K::Archived>

pub fn resolve(self, pos: usize, value: &HashSet<K>) -> Self::Archived

impl<K: Archive + Hash + Eq, V: Archive> Resolve<HashMap<K, V, RandomState>> for ArchivedHashMapResolver

type Archived = ArchivedHashMap<K::Archived, V::Archived>

pub fn resolve(self, pos: usize, value: &HashMap<K, V>) -> Self::Archived

impl<T: ArchiveCopy> Resolve<T> for CopyResolver

type Archived = T

pub fn resolve(self, _pos: usize, value: &T) -> T

Loading content...