Struct zerovec::maps::ZeroMap2dBorrowed

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

A borrowed-only version of ZeroMap2d

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 ZeroMap2dBorrowed instance.

Examples

use zerovec::maps::ZeroMap2dBorrowed;

// Example byte buffer representing the map { 1: {2: "three" } }
let BINCODE_BYTES: &[u8; 47] = &[
    2, 0, 0, 0, 0, 0, 0, 0, 1, 0, 4, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 2, 0,
    0, 0, 0, 0, 0, 0, 2, 0, 7, 0, 0, 0, 0, 0, 0, 0, 1, 0, 116, 104,
    114, 101, 101
];

// Deserializing to ZeroMap2d requires no heap allocations.
let zero_map: ZeroMap2dBorrowed<u16, u16, str> =
    bincode::deserialize(BINCODE_BYTES)
        .expect("Should deserialize successfully");
assert_eq!(zero_map.get_2d(&1, &2), Some("three"));

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

Implementations

impl<'a, K0, K1, V> ZeroMap2dBorrowed<'a, K0, K1, V>

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

pub fn new() -> Self

Creates a new, empty ZeroMap2dBorrowed<K0, K1, V>.

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

Examples

use zerovec::maps::ZeroMap2dBorrowed;

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

impl<'a, K0, K1, V> ZeroMap2dBorrowed<'a, K0, K1, V>

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

pub fn len(&self) -> usize

The number of elements in the ZeroMap2dBorrowed

pub fn is_empty(&self) -> bool

Whether the ZeroMap2dBorrowed is empty

impl<'a, K0, K1, V> ZeroMap2dBorrowed<'a, K0, K1, V>

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

pub fn get_2d(&self, key0: &K0, key1: &K1) -> Option<&'a V::GetType>

Get the value associated with key0 and key1, 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 ZeroMap2dBorrowed over ZeroMap2d.

use zerovec::ZeroMap2d;

let mut map = ZeroMap2d::new();
map.insert(&1, "one", "foo");
map.insert(&2, "one", "bar");
map.insert(&2, "two", "baz");

let borrowed = map.as_borrowed();
assert_eq!(borrowed.get_2d(&1, "one"), Some("foo"));
assert_eq!(borrowed.get_2d(&1, "two"), None);
assert_eq!(borrowed.get_2d(&2, "one"), Some("bar"));
assert_eq!(borrowed.get_2d(&2, "two"), Some("baz"));
assert_eq!(borrowed.get_2d(&3, "three"), None);

impl<'a, K0, K1, V> ZeroMap2dBorrowed<'a, K0, K1, V>

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

pub fn get0<'l>( &'l self, key0: &K0, ) -> Option<ZeroMap2dCursor<'a, 'a, K0, K1, V>>

Gets a cursor for key0. If None, then key0 is not in the map. If Some, then key0 is in the map, and key1 can be queried.

use zerovec::ZeroMap2d;

let mut map = ZeroMap2d::new();
map.insert(&1, "one", "foo");
map.insert(&2, "two", "bar");
let borrowed = map.as_borrowed();
assert!(matches!(borrowed.get0(&1), Some(_)));
assert!(matches!(borrowed.get0(&3), None));

pub fn get0_by<'l>( &'l self, predicate: impl FnMut(&K0) -> Ordering, ) -> Option<ZeroMap2dCursor<'a, 'a, K0, K1, V>>

Binary search the map for key0, returning a cursor.

use zerovec::ZeroMap2d;

let mut map = ZeroMap2d::new();
map.insert(&1, "one", "foo");
map.insert(&2, "two", "bar");
let borrowed = map.as_borrowed();
assert!(matches!(borrowed.get0_by(|probe| probe.cmp(&1)), Some(_)));
assert!(matches!(borrowed.get0_by(|probe| probe.cmp(&3)), None));

pub fn contains_key0(&self, key0: &K0) -> bool

Returns whether key0 is contained in this map

use zerovec::ZeroMap2d;

let mut map = ZeroMap2d::new();
map.insert(&1, "one", "foo");
map.insert(&2, "two", "bar");
let borrowed = map.as_borrowed();
assert!(borrowed.contains_key0(&1));
assert!(!borrowed.contains_key0(&3));

impl<'a, K0, K1, V> ZeroMap2dBorrowed<'a, K0, K1, V>

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

pub fn iter0<'l>( &'l self, ) -> impl Iterator<Item = ZeroMap2dCursor<'a, 'a, K0, K1, V>> + 'l

Produce an ordered iterator over keys0

impl<'a, K0, K1, V> ZeroMap2dBorrowed<'a, K0, K1, V>

where K0: ZeroMapKV<'a> + Ord + ?Sized, K1: ZeroMapKV<'a> + Ord + ?Sized, V: ZeroMapKV<'a> + Copy,

pub fn get_copied_2d(&self, key0: &K0, key1: &K1) -> Option<V>

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

Trait Implementations

impl<'a, K0, K1, V> Bake for ZeroMap2dBorrowed<'a, K0, K1, V>

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

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

Returns a TokenStream that would evaluate to self.

impl<'a, K0, K1, V> BakeSize for ZeroMap2dBorrowed<'a, K0, K1, V>

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

fn borrows_size(&self) -> usize

Returns the size

impl<'a, K0, K1, V> Clone for ZeroMap2dBorrowed<'a, K0, K1, V>

where K0: ZeroMapKV<'a> + ?Sized, K1: 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, K0, K1, V> Debug for ZeroMap2dBorrowed<'a, K0, K1, V>

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

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

Formats the value using the given formatter.

impl<'a, K0, K1, V> Default for ZeroMap2dBorrowed<'a, K0, K1, V>

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

fn default() -> Self

Returns the “default value” for a type.

impl<'de, 'a, K0, K1, V> Deserialize<'de> for ZeroMap2dBorrowed<'a, K0, K1, V>

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

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

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

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'a, K0, K1, V> From<ZeroMap2dBorrowed<'a, K0, K1, V>> for ZeroMap2d<'a, K0, K1, V>

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

fn from(other: ZeroMap2dBorrowed<'a, K0, K1, V>) -> Self

Converts to this type from the input type.

impl<'a, 'b, K0, K1, V> PartialEq<ZeroMap2dBorrowed<'b, K0, K1, V>> for ZeroMap2dBorrowed<'a, K0, K1, V>

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

fn eq(&self, other: &ZeroMap2dBorrowed<'b, K0, K1, 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, K0, K1, V> Serialize for ZeroMap2dBorrowed<'a, K0, K1, V>

where K0: ZeroMapKV<'a> + Serialize + ?Sized + Ord, K1: ZeroMapKV<'a> + Serialize + ?Sized + Ord, V: ZeroMapKV<'a> + Serialize + ?Sized, K0::Container: Serialize, K1::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, K0, K1, V> Yokeable<'a> for ZeroMap2dBorrowed<'static, K0, K1, V>

where K0: 'static + for<'b> ZeroMapKV<'b> + ?Sized, K1: 'static + for<'b> ZeroMapKV<'b> + ?Sized, V: 'static + for<'b> ZeroMapKV<'b> + ?Sized, &'static <K0 as ZeroMapKV<'static>>::Slice: for<'b> Yokeable<'b>, &'static <K1 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 = ZeroMap2dBorrowed<'a, K0, K1, 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, K0, K1, V> Copy for ZeroMap2dBorrowed<'a, K0, K1, V>

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