Struct zerovec::maps::ZeroMapBorrowed

pub struct ZeroMapBorrowed<'a, K, V>
where
    K: ZeroMapKV<'a> + ?Sized,
    V: ZeroMapKV<'a> + ?Sized,
{ /* private fields */ }

A borrowed-only version of ZeroMap

This is useful for fully-zero-copy deserialization from non-human-readable serialization formats. It also has the advantage that it can return references that live for the lifetime of the backing buffer as opposed to that of the ZeroMapBorrowed instance.

Examples

use zerovec::maps::ZeroMapBorrowed;

// Example byte buffer representing the map { 1: "one" }
let BINCODE_BYTES: &[u8; 25] = &[
    4, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 1, 0,
    111, 110, 101,
];

// Deserializing to ZeroMap requires no heap allocations.
let zero_map: ZeroMapBorrowed<u32, str> =
    bincode::deserialize(BINCODE_BYTES)
        .expect("Should deserialize successfully");
assert_eq!(zero_map.get(&1), Some("one"));

This can be obtained from a ZeroMap via ZeroMap::as_borrowed

Implementations

impl<'a, K, V> ZeroMapBorrowed<'a, K, V>

where K: ZeroMapKV<'a> + ?Sized, V: ZeroMapKV<'a> + ?Sized, K::Slice: 'static, V::Slice: 'static,

pub fn new() -> Self

Creates a new, empty ZeroMapBorrowed<K, V>.

Note: Since ZeroMapBorrowed is not mutable, the return value will be a stub unless converted into a ZeroMap.

Examples

use zerovec::maps::ZeroMapBorrowed;

let zm: ZeroMapBorrowed<u16, str> = ZeroMapBorrowed::new();
assert!(zm.is_empty());

impl<'a, K, V> ZeroMapBorrowed<'a, K, V>

where K: ZeroMapKV<'a> + ?Sized, V: ZeroMapKV<'a> + ?Sized,

pub fn len(&self) -> usize

The number of elements in the ZeroMapBorrowed

pub fn is_empty(&self) -> bool

Whether the ZeroMapBorrowed is empty

impl<'a, K, V> ZeroMapBorrowed<'a, K, V>

where K: ZeroMapKV<'a> + Ord + ?Sized, V: ZeroMapKV<'a> + ?Sized,

pub fn get(&self, key: &K) -> Option<&'a V::GetType>

Get the value associated with key, if it exists.

This is able to return values that live longer than the map itself since they borrow directly from the backing buffer. This is the primary advantage of using ZeroMapBorrowed over ZeroMap.

use zerovec::ZeroMap;

let mut map = ZeroMap::new();
map.insert(&1, "one");
map.insert(&2, "two");
let borrowed = map.as_borrowed();
assert_eq!(borrowed.get(&1), Some("one"));
assert_eq!(borrowed.get(&3), None);

pub fn get_by( &self, predicate: impl FnMut(&K) -> Ordering, ) -> Option<&'a V::GetType>

Binary search the map with predicate to find a key, returning the value.

This is able to return values that live longer than the map itself since they borrow directly from the backing buffer. This is the primary advantage of using ZeroMapBorrowed over ZeroMap.

use zerovec::ZeroMap;

let mut map = ZeroMap::new();
map.insert(&1, "one");
map.insert(&2, "two");
let borrowed = map.as_borrowed();
assert_eq!(borrowed.get_by(|probe| probe.cmp(&1)), Some("one"));
assert_eq!(borrowed.get_by(|probe| probe.cmp(&3)), None);

pub fn contains_key(&self, key: &K) -> bool

Returns whether key is contained in this map

use zerovec::ZeroMap;

let mut map = ZeroMap::new();
map.insert(&1, "one");
map.insert(&2, "two");
let borrowed = map.as_borrowed();
assert!(borrowed.contains_key(&1));
assert!(!borrowed.contains_key(&3));

impl<'a, K, V> ZeroMapBorrowed<'a, K, V>

where K: ZeroMapKV<'a> + ?Sized, V: ZeroMapKV<'a> + ?Sized,

pub fn iter<'b>( &'b self, ) -> impl Iterator<Item = (&'a <K as ZeroMapKV<'a>>::GetType, &'a <V as ZeroMapKV<'a>>::GetType)> + 'b

Produce an ordered iterator over key-value pairs

pub fn iter_keys<'b>( &'b self, ) -> impl Iterator<Item = &'a <K as ZeroMapKV<'a>>::GetType> + 'b

Produce an ordered iterator over keys

pub fn iter_values<'b>( &'b self, ) -> impl Iterator<Item = &'a <V as ZeroMapKV<'a>>::GetType> + 'b

Produce an iterator over values, ordered by keys

impl<'a, K, V> ZeroMapBorrowed<'a, K, V>

where K: ZeroMapKV<'a> + Ord + ?Sized, V: ZeroMapKV<'a, Slice = ZeroSlice<V>> + AsULE + Copy + 'static,

pub fn get_copied(&self, key: &K) -> Option<V>

For cases when V is fixed-size, obtain a direct copy of V instead of V::ULE

pub fn get_copied_by(&self, predicate: impl FnMut(&K) -> Ordering) -> Option<V>

For cases when V is fixed-size, obtain a direct copy of V instead of V::ULE

pub fn iter_copied_values<'b>( &'b self, ) -> impl Iterator<Item = (&'b <K as ZeroMapKV<'a>>::GetType, V)>

Similar to Self::iter() except it returns a direct copy of the values instead of references to V::ULE, in cases when V is fixed-size

impl<'a, K, V> ZeroMapBorrowed<'a, K, V>

where K: ZeroMapKV<'a, Slice = ZeroSlice<K>> + AsULE + Copy + Ord + 'static, V: ZeroMapKV<'a, Slice = ZeroSlice<V>> + AsULE + Copy + 'static,

pub fn iter_copied<'b: 'a>(&'b self) -> impl Iterator<Item = (K, V)> + 'b

Similar to Self::iter() except it returns a direct copy of the keys values instead of references to K::ULE and V::ULE, in cases when K and V are fixed-size

Trait Implementations

impl<'a, K, V> Bake for ZeroMapBorrowed<'a, K, V>

where K: ZeroMapKV<'a> + ?Sized, V: ZeroMapKV<'a> + ?Sized, &'a K::Slice: Bake, &'a V::Slice: Bake,

fn bake(&self, env: &CrateEnv) -> TokenStream

Returns a TokenStream that would evaluate to self.

impl<'a, K, V> BakeSize for ZeroMapBorrowed<'a, K, V>

where K: ZeroMapKV<'a> + ?Sized, V: ZeroMapKV<'a> + ?Sized, &'a K::Slice: BakeSize, &'a V::Slice: BakeSize,

fn borrows_size(&self) -> usize

Returns the size

impl<'a, K, V> Clone for ZeroMapBorrowed<'a, K, V>

where K: ZeroMapKV<'a> + ?Sized, V: ZeroMapKV<'a> + ?Sized,

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a, K, V> Debug for ZeroMapBorrowed<'a, K, V>

where K: ZeroMapKV<'a> + ?Sized, V: ZeroMapKV<'a> + ?Sized, K::Slice: Debug, V::Slice: Debug,

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

Formats the value using the given formatter.

impl<'a, K, V> Default for ZeroMapBorrowed<'a, K, V>

where K: ZeroMapKV<'a> + ?Sized, V: ZeroMapKV<'a> + ?Sized, K::Slice: 'static, V::Slice: 'static,

fn default() -> Self

Returns the “default value” for a type.

impl<'de, 'a, K, V> Deserialize<'de> for ZeroMapBorrowed<'a, K, V>

where K: ZeroMapKV<'a> + Ord + ?Sized, V: ZeroMapKV<'a> + ?Sized, K::Container: Deserialize<'de>, V::Container: Deserialize<'de>, K::OwnedType: Deserialize<'de>, V::OwnedType: Deserialize<'de>, 'de: 'a,

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'a, K, V> From<ZeroMapBorrowed<'a, K, V>> for ZeroMap<'a, K, V>

where K: ZeroMapKV<'a> + ?Sized, V: ZeroMapKV<'a> + ?Sized,

fn from(other: ZeroMapBorrowed<'a, K, V>) -> Self

Converts to this type from the input type.

impl<'a, 'b, K, V> PartialEq<ZeroMapBorrowed<'b, K, V>> for ZeroMapBorrowed<'a, K, V>

where K: for<'c> ZeroMapKV<'c> + ?Sized, V: for<'c> ZeroMapKV<'c> + ?Sized, <K as ZeroMapKV<'a>>::Slice: PartialEq<<K as ZeroMapKV<'b>>::Slice>, <V as ZeroMapKV<'a>>::Slice: PartialEq<<V as ZeroMapKV<'b>>::Slice>,

fn eq(&self, other: &ZeroMapBorrowed<'b, K, V>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl<'a, K, V> Serialize for ZeroMapBorrowed<'a, K, V>

where K: ZeroMapKV<'a> + Serialize + ?Sized + Ord, V: ZeroMapKV<'a> + Serialize + ?Sized, K::Container: Serialize, V::Container: Serialize,

This impl requires enabling the optional serde Cargo feature of the zerovec crate

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<'a, K, V> Yokeable<'a> for ZeroMapBorrowed<'static, K, V>

where K: 'static + for<'b> ZeroMapKV<'b> + ?Sized, V: 'static + for<'b> ZeroMapKV<'b> + ?Sized, &'static <K as ZeroMapKV<'static>>::Slice: for<'b> Yokeable<'b>, &'static <V as ZeroMapKV<'static>>::Slice: for<'b> Yokeable<'b>,

This impl requires enabling the optional yoke Cargo feature of the zerovec crate

type Output = ZeroMapBorrowed<'a, K, V>

This type MUST be Self with the 'static replaced with 'a, i.e. Self<'a>

fn transform(&'a self) -> &'a Self::Output

This method must cast self between &'a Self<'static> and &'a Self<'a>.

fn transform_owned(self) -> Self::Output

This method must cast self between Self<'static> and Self<'a>.

unsafe fn make(from: Self::Output) -> Self

This method can be used to cast away Self<'a>’s lifetime.

fn transform_mut<F>(&'a mut self, f: F)

where F: 'static + for<'b> FnOnce(&'b mut Self::Output),

This method must cast self between &'a mut Self<'static> and &'a mut Self<'a>, and pass it to f.

impl<'a, K, V> Copy for ZeroMapBorrowed<'a, K, V>

where K: ZeroMapKV<'a> + ?Sized, V: ZeroMapKV<'a> + ?Sized,