Struct zerovec::map2d::borrowed::ZeroMap2dBorrowed
source · pub struct ZeroMap2dBorrowed<'a, K0, K1, V>{
pub(crate) keys0: &'a K0::Slice,
pub(crate) joiner: &'a ZeroSlice<u32>,
pub(crate) keys1: &'a K1::Slice,
pub(crate) values: &'a V::Slice,
}
Expand description
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; 51] = &[
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, 11, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 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
Fields§
§keys0: &'a K0::Slice
§joiner: &'a ZeroSlice<u32>
§keys1: &'a K1::Slice
§values: &'a V::Slice
Implementations§
source§impl<'a, K0, K1, V> ZeroMap2dBorrowed<'a, K0, K1, V>
impl<'a, K0, K1, V> ZeroMap2dBorrowed<'a, K0, K1, V>
sourcepub fn new() -> Self
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());
source§impl<'a, K0, K1, V> ZeroMap2dBorrowed<'a, K0, K1, V>
impl<'a, K0, K1, V> ZeroMap2dBorrowed<'a, K0, K1, V>
sourcepub fn len(&self) -> usize
pub fn len(&self) -> usize
The number of elements in the ZeroMap2dBorrowed
sourcepub fn is_empty(&self) -> bool
pub fn is_empty(&self) -> bool
Whether the ZeroMap2dBorrowed
is empty
source§impl<'a, K0, K1, V> ZeroMap2dBorrowed<'a, K0, K1, V>
impl<'a, K0, K1, V> ZeroMap2dBorrowed<'a, K0, K1, V>
sourcepub fn get_2d(&self, key0: &K0, key1: &K1) -> Option<&'a V::GetType>
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);
source§impl<'a, K0, K1, V> ZeroMap2dBorrowed<'a, K0, K1, V>
impl<'a, K0, K1, V> ZeroMap2dBorrowed<'a, K0, K1, V>
sourcepub fn get0<'l>(
&'l self,
key0: &K0,
) -> Option<ZeroMap2dCursor<'a, 'a, K0, K1, V>>
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));
sourcepub fn get0_by<'l>(
&'l self,
predicate: impl FnMut(&K0) -> Ordering,
) -> Option<ZeroMap2dCursor<'a, 'a, K0, K1, V>>
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));
sourcepub fn contains_key0(&self, key0: &K0) -> bool
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));
source§impl<'a, K0, K1, V> ZeroMap2dBorrowed<'a, K0, K1, V>
impl<'a, K0, K1, V> ZeroMap2dBorrowed<'a, K0, K1, V>
sourcepub fn iter0<'l>(
&'l self,
) -> impl Iterator<Item = ZeroMap2dCursor<'a, 'a, K0, K1, V>> + '_
pub fn iter0<'l>( &'l self, ) -> impl Iterator<Item = ZeroMap2dCursor<'a, 'a, K0, K1, V>> + '_
Produce an ordered iterator over keys0
source§impl<'a, K0, K1, V> ZeroMap2dBorrowed<'a, K0, K1, V>
impl<'a, K0, K1, V> ZeroMap2dBorrowed<'a, K0, K1, V>
sourcepub fn get_copied_2d(&self, key0: &K0, key1: &K1) -> Option<V>
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§
source§impl<'a, K0, K1, V> Clone for ZeroMap2dBorrowed<'a, K0, K1, V>
impl<'a, K0, K1, V> Clone for ZeroMap2dBorrowed<'a, K0, K1, V>
source§impl<'a, K0, K1, V> Debug for ZeroMap2dBorrowed<'a, K0, K1, V>
impl<'a, K0, K1, V> Debug for ZeroMap2dBorrowed<'a, K0, K1, V>
source§impl<'a, K0, K1, V> Default for ZeroMap2dBorrowed<'a, K0, K1, V>
impl<'a, K0, K1, V> Default for ZeroMap2dBorrowed<'a, K0, K1, V>
source§impl<'a, K0, K1, V> From<ZeroMap2dBorrowed<'a, K0, K1, V>> for ZeroMap2d<'a, K0, K1, V>
impl<'a, K0, K1, V> From<ZeroMap2dBorrowed<'a, K0, K1, V>> for ZeroMap2d<'a, K0, K1, V>
source§fn from(other: ZeroMap2dBorrowed<'a, K0, K1, V>) -> Self
fn from(other: ZeroMap2dBorrowed<'a, K0, K1, V>) -> Self
source§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>,
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>,
source§fn eq(&self, other: &ZeroMap2dBorrowed<'b, K0, K1, V>) -> bool
fn eq(&self, other: &ZeroMap2dBorrowed<'b, K0, K1, V>) -> bool
self
and other
values to be equal, and is used
by ==
.source§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>,
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>
type Output = ZeroMap2dBorrowed<'a, K0, K1, V>
Self
with the 'static
replaced with 'a
, i.e. Self<'a>