Struct rkyv::collections::index_set::ArchivedIndexSet

#[repr(transparent)]
pub struct ArchivedIndexSet<K> { /* fields omitted */ }

An archived IndexSet.

Implementations

impl<K> ArchivedIndexSet<K>

pub fn contains<Q: ?Sized>(&self, k: &Q) -> bool where
    K: Borrow<Q>,
    Q: Hash + Eq, 

Returns whether a key is present in the hash set.

pub fn first(&self) -> Option<&K>

Returns the first key.

pub fn get<Q: ?Sized>(&self, k: &Q) -> Option<&K> where
    K: Borrow<Q>,
    Q: Hash + Eq, 

Returns the value stored in the set, if any.

pub fn get_full<Q: ?Sized>(&self, k: &Q) -> Option<(usize, &K)> where
    K: Borrow<Q>,
    Q: Hash + Eq, 

Returns the item index and value stored in the set, if any.

pub fn get_index(&self, index: usize) -> Option<&K>

Gets a key by index.

pub fn get_index_of<Q: ?Sized>(&self, key: &Q) -> Option<usize> where
    K: Borrow<Q>,
    Q: Hash + Eq, 

Returns the index of a key if it exists in the set.

pub fn hasher(&self) -> HashBuilder

Gets the hasher for this index set.

pub fn is_empty(&self) -> bool

Returns whether the index set contains no values.

pub fn iter(&self) -> Keys<'_, K, ()>

Returns an iterator over the keys of the index set in order.

pub fn last(&self) -> Option<&K>

Returns the last key.

pub fn len(&self) -> usize

Returns the number of elements in the index set.

pub unsafe fn resolve_from_len(
    len: usize,
    pos: usize,
    resolver: IndexSetResolver,
    out: *mut Self
)

Resolves an archived index map from a given length and parameters.

Safety

• len must be the number of elements that were serialized
• pos must be the position of out within the archive
• resolver must be the result of serializing a hash map

Trait Implementations

impl<K: Debug> Debug for ArchivedIndexSet<K>

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

Formats the value using the given formatter.

impl<K: PartialEq> PartialEq<ArchivedIndexSet<K>> for ArchivedIndexSet<K>

fn eq(&self, other: &Self) -> 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 !=.