impl<'l, 'a, K0, K1, V> ZeroMap2dCursor<'l, 'a, K0, K1, V>

fn iter1_copied(self: &Self) -> impl DoubleEndedIterator<Item = (&'l <K1 as ZeroMapKV<'a>>::GetType, V)> + ExactSizeIterator + '_

Borrow an ordered iterator over keys1 and values for a particular key0.

The values are returned as copy types.

Examples

use zerovec::ZeroMap2d;

let zm2d: ZeroMap2d<str, u8, u16> =
    [("a", 0u8, 1u16), ("b", 1u8, 1000u16), ("b", 2u8, 2000u16)]
        .into_iter()
        .collect();

let mut total_value = 0;

for cursor in zm2d.iter0() {
    for (_, value) in cursor.iter1_copied() {
        total_value += value;
    }
}

assert_eq!(total_value, 3001);

fn into_iter1_copied(self: Self) -> impl DoubleEndedIterator<Item = (&'l <K1 as ZeroMapKV<'a>>::GetType, V)> + ExactSizeIterator

Transform this cursor into an ordered iterator over keys1 for a particular key0.

The values are returned as copy types.

Examples

use zerovec::ZeroMap2d;

let zm2d: ZeroMap2d<str, u8, u16> =
    [("a", 0u8, 1u16), ("b", 1u8, 1000u16), ("b", 2u8, 2000u16)]
        .into_iter()
        .collect();

let mut total_value = 0;

for cursor in zm2d.iter0() {
    for (_, value) in cursor.into_iter1_copied() {
        total_value += value;
    }
}

assert_eq!(total_value, 3001);

impl<'l, 'a, K0, K1, V> ZeroMap2dCursor<'l, 'a, K0, K1, V>

fn get1(self: &Self, key1: &K1) -> Option<&'l <V as >::GetType>

Gets the value for a key1 from this cursor, or None if key1 is not in the map.

use zerovec::ZeroMap2d;

let mut map = ZeroMap2d::new();
map.insert("one", &1u32, "foo");
assert_eq!(map.get0("one").unwrap().get1(&1), Some("foo"));
assert_eq!(map.get0("one").unwrap().get1(&2), None);

fn get1_by<impl FnMut(&K1) -> Ordering: FnMut(&K1) -> Ordering>(self: &Self, predicate: impl FnMut(&K1) -> Ordering) -> Option<&'l <V as >::GetType>

Gets the value for a predicate from this cursor, or None if key1 is not in the map.

use zerovec::ZeroMap2d;

let mut map = ZeroMap2d::new();
map.insert("one", &1u32, "foo");
assert_eq!(map.get0("one").unwrap().get1_by(|v| v.cmp(&1)), Some("foo"));
assert_eq!(map.get0("one").unwrap().get1_by(|v| v.cmp(&2)), None);

impl<'l, 'a, K0, K1, V> ZeroMap2dCursor<'l, 'a, K0, K1, V>

fn get1_copied(self: &Self, key1: &K1) -> Option<V>

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

use zerovec::ZeroMap2d;

let mut map: ZeroMap2d<u16, u16, u16> = ZeroMap2d::new();
map.insert(&1, &2, &3);
map.insert(&1, &4, &5);
map.insert(&6, &7, &8);

assert_eq!(map.get0(&6).unwrap().get1_copied(&7), Some(8));

fn get1_copied_by<impl FnMut(&K1) -> Ordering: FnMut(&K1) -> Ordering>(self: &Self, predicate: impl FnMut(&K1) -> Ordering) -> Option<V>

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

impl<'l, 'a, K0, K1, V> ZeroMap2dCursor<'l, 'a, K0, K1, V>

fn key0(self: &Self) -> &'l <K0 as >::GetType

Returns the key0 corresponding to the cursor position.

use zerovec::ZeroMap2d;

let mut map = ZeroMap2d::new();
map.insert("one", &1u32, "foo");
assert_eq!(map.get0("one").unwrap().key0(), "one");

fn iter1(self: &Self) -> impl DoubleEndedIterator<Item = (&'l <K1 as ZeroMapKV<'a>>::GetType, &'l <V as ZeroMapKV<'a>>::GetType)> + ExactSizeIterator + '_

Borrow an ordered iterator over keys1 and values for a particular key0.

To get the values as copy types, see Self::iter1_copied.

For an example, see [ZeroMap2d::iter0()].

fn into_iter1(self: Self) -> impl DoubleEndedIterator<Item = (&'l <K1 as ZeroMapKV<'a>>::GetType, &'l <V as ZeroMapKV<'a>>::GetType)> + ExactSizeIterator

Transform this cursor into an ordered iterator over keys1 for a particular key0.

impl<'l, 'a, K0, K1, V> Debug for ZeroMap2dCursor<'l, 'a, K0, K1, V>

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

impl<'l, 'a, K0, K1, V> Freeze for ZeroMap2dCursor<'l, 'a, K0, K1, V>

impl<'l, 'a, K0, K1, V> RefUnwindSafe for ZeroMap2dCursor<'l, 'a, K0, K1, V>

impl<'l, 'a, K0, K1, V> Send for ZeroMap2dCursor<'l, 'a, K0, K1, V>

impl<'l, 'a, K0, K1, V> Sync for ZeroMap2dCursor<'l, 'a, K0, K1, V>

impl<'l, 'a, K0, K1, V> Unpin for ZeroMap2dCursor<'l, 'a, K0, K1, V>

impl<'l, 'a, K0, K1, V> UnsafeUnpin for ZeroMap2dCursor<'l, 'a, K0, K1, V>

impl<'l, 'a, K0, K1, V> UnwindSafe for ZeroMap2dCursor<'l, 'a, K0, K1, V>

impl<'m, 'n, 'a, 'b, K0, K1, V> PartialEq for ZeroMap2dCursor<'m, 'a, K0, K1, V>

fn eq(self: &Self, other: &ZeroMap2dCursor<'n, 'b, K0, K1, V>) -> bool

impl<T> Any for ZeroMap2dCursor<'l, 'a, K0, K1, V>

fn type_id(self: &Self) -> TypeId

impl<T> Borrow for ZeroMap2dCursor<'l, 'a, K0, K1, V>

fn borrow(self: &Self) -> &T

impl<T> BorrowMut for ZeroMap2dCursor<'l, 'a, K0, K1, V>

fn borrow_mut(self: &mut Self) -> &mut T

impl<T> ErasedDestructor for ZeroMap2dCursor<'l, 'a, K0, K1, V>

impl<T> From for ZeroMap2dCursor<'l, 'a, K0, K1, V>

fn from(t: T) -> T

Returns the argument unchanged.

impl<T, U> Into for ZeroMap2dCursor<'l, 'a, K0, K1, V>

fn into(self: Self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

impl<T, U> TryFrom for ZeroMap2dCursor<'l, 'a, K0, K1, V>

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

impl<T, U> TryInto for ZeroMap2dCursor<'l, 'a, K0, K1, V>

fn try_into(self: Self) -> Result<U, <U as TryFrom<T>>::Error>