Struct zerovec::map2d::cursor::ZeroMap2dCursor

pub struct ZeroMap2dCursor<'l, 'a, K0, K1, V>
where
    K0: ZeroMapKV<'a> + ?Sized,
    K1: ZeroMapKV<'a> + ?Sized,
    V: ZeroMapKV<'a> + ?Sized,
{
    keys0: &'l K0::Slice,
    joiner: &'l ZeroSlice<u32>,
    keys1: &'l K1::Slice,
    values: &'l V::Slice,
    key0_index: usize,
}

An intermediate state of queries over ZeroMap2d and ZeroMap2dBorrowed.

Fields

keys0: &'l K0::Slice

joiner: &'l ZeroSlice<u32>

keys1: &'l K1::Slice

values: &'l V::Slice

key0_index: usize

Implementations

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

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

pub(crate) fn from_borrowed( borrowed: &ZeroMap2dBorrowed<'a, K0, K1, V>, key0_index: usize, ) -> Self

key0_index must be in range

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

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

pub(crate) fn from_cow( cow: &'l ZeroMap2d<'a, K0, K1, V>, key0_index: usize, ) -> Self

key0_index must be in range

pub fn key0(&self) -> &'l K0::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");

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

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().

pub fn into_iter1( self, ) -> impl Iterator<Item = (&'l <K1 as ZeroMapKV<'a>>::GetType, &'l <V as ZeroMapKV<'a>>::GetType)>

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

pub(super) fn get_range(&self) -> Range<usize>

Given key0_index, returns the corresponding range of keys1, which will be valid

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

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

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

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, usize> = [
    ("a", 0u8, 1usize),
    ("b", 1u8, 1000usize),
    ("b", 2u8, 2000usize),
]
.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 get1_copied_at(&self, index: usize) -> Option<V>

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

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

pub fn get1(&self, key1: &K1) -> Option<&'l V::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);

pub fn get1_by( &self, predicate: impl FnMut(&K1) -> Ordering, ) -> Option<&'l V::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);

fn get_key1_index_by( &self, predicate: impl FnMut(&K1) -> Ordering, ) -> Option<usize>

Given key0_index and predicate, returns the index into the values array

fn get_key1_index(&self, key1: &K1) -> Option<usize>

Given key0_index and key1, returns the index into the values array

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

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

pub fn get1_copied(&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));

pub fn get1_copied_by( &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

Trait Implementations

impl<'l, 'a, K0, K1, V> Debug for ZeroMap2dCursor<'l, '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<'m, 'n, 'a, 'b, K0, K1, V> PartialEq<ZeroMap2dCursor<'n, 'b, K0, K1, V>> for ZeroMap2dCursor<'m, '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: &ZeroMap2dCursor<'n, 'b, K0, K1, V>) -> 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 !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.