Struct cw_storage_plus::MultiIndex
source · pub struct MultiIndex<'a, IK, T, PK> { /* private fields */ }
Expand description
MultiIndex stores (namespace, index_name, idx_value, pk) -> b“pk_len“. Allows many values per index, and references pk. The associated primary key value is stored in the main (pk_namespace) map, which stores (namespace, pk_namespace, pk) -> value.
The stored pk_len is used to recover the pk from the index namespace, and perform the secondary load of the associated value from the main map.
The PK type defines the type of Primary Key, both for deserialization, and
more important, as the type-safe bound key type.
This type must match the encompassing IndexedMap
primary key type,
or its owned variant.
Implementations§
source§impl<'a, IK, T, PK> MultiIndex<'a, IK, T, PK>
impl<'a, IK, T, PK> MultiIndex<'a, IK, T, PK>
sourcepub const fn new(
idx_fn: fn(_: &[u8], _: &T) -> IK,
pk_namespace: &'a str,
idx_namespace: &'static str
) -> Self
pub const fn new( idx_fn: fn(_: &[u8], _: &T) -> IK, pk_namespace: &'a str, idx_namespace: &'static str ) -> Self
Create a new MultiIndex
idx_fn - lambda creating index key from value pk_namespace - prefix for the primary key idx_namespace - prefix for the index value
§Example:
use cw_storage_plus::MultiIndex;
use serde::{Deserialize, Serialize};
#[derive(Deserialize, Serialize, Clone)]
struct Data {
pub name: String,
pub age: u32,
}
let index: MultiIndex<_, _, String> = MultiIndex::new(
|_pk: &[u8], d: &Data| d.age,
"age",
"age__owner",
);
source§impl<'a, IK, T, PK> MultiIndex<'a, IK, T, PK>where
PK: PrimaryKey<'a> + KeyDeserialize,
T: Serialize + DeserializeOwned + Clone,
IK: PrimaryKey<'a> + Prefixer<'a>,
impl<'a, IK, T, PK> MultiIndex<'a, IK, T, PK>where
PK: PrimaryKey<'a> + KeyDeserialize,
T: Serialize + DeserializeOwned + Clone,
IK: PrimaryKey<'a> + Prefixer<'a>,
source§impl<'a, IK, T, PK> MultiIndex<'a, IK, T, PK>where
T: Serialize + DeserializeOwned + Clone,
IK: PrimaryKey<'a> + Prefixer<'a> + KeyDeserialize,
PK: PrimaryKey<'a> + KeyDeserialize,
impl<'a, IK, T, PK> MultiIndex<'a, IK, T, PK>where
T: Serialize + DeserializeOwned + Clone,
IK: PrimaryKey<'a> + Prefixer<'a> + KeyDeserialize,
PK: PrimaryKey<'a> + KeyDeserialize,
pub fn range_raw<'c>(
&'c self,
store: &'c dyn Storage,
min: Option<Bound<'a, (IK, PK)>>,
max: Option<Bound<'a, (IK, PK)>>,
order: Order
) -> Box<dyn Iterator<Item = StdResult<Record<T>>> + 'c>where
T: 'c,
pub fn keys_raw<'c>( &'c self, store: &'c dyn Storage, min: Option<Bound<'a, (IK, PK)>>, max: Option<Bound<'a, (IK, PK)>>, order: Order ) -> Box<dyn Iterator<Item = Vec<u8>> + 'c>
sourcepub fn prefix_range_raw<'c>(
&'c self,
store: &'c dyn Storage,
min: Option<PrefixBound<'a, IK>>,
max: Option<PrefixBound<'a, IK>>,
order: Order
) -> Box<dyn Iterator<Item = StdResult<Record<T>>> + 'c>where
T: 'c,
'a: 'c,
pub fn prefix_range_raw<'c>(
&'c self,
store: &'c dyn Storage,
min: Option<PrefixBound<'a, IK>>,
max: Option<PrefixBound<'a, IK>>,
order: Order
) -> Box<dyn Iterator<Item = StdResult<Record<T>>> + 'c>where
T: 'c,
'a: 'c,
While range_raw
over a prefix
fixes the prefix to one element and iterates over the
remaining, prefix_range_raw
accepts bounds for the lowest and highest elements of the
Prefix
itself, and iterates over those (inclusively or exclusively, depending on
PrefixBound
).
There are some issues that distinguish these two, and blindly casting to Vec<u8>
doesn’t
solve them.
source§impl<'a, IK, T, PK> MultiIndex<'a, IK, T, PK>where
PK: PrimaryKey<'a> + KeyDeserialize,
T: Serialize + DeserializeOwned + Clone,
IK: PrimaryKey<'a> + Prefixer<'a>,
impl<'a, IK, T, PK> MultiIndex<'a, IK, T, PK>where
PK: PrimaryKey<'a> + KeyDeserialize,
T: Serialize + DeserializeOwned + Clone,
IK: PrimaryKey<'a> + Prefixer<'a>,
pub fn prefix(&self, p: IK) -> IndexPrefix<PK, T, PK>
pub fn sub_prefix(&self, p: IK::Prefix) -> IndexPrefix<PK, T, (IK::Suffix, PK)>
source§impl<'a, IK, T, PK> MultiIndex<'a, IK, T, PK>where
PK: PrimaryKey<'a> + KeyDeserialize,
T: Serialize + DeserializeOwned + Clone,
IK: PrimaryKey<'a> + KeyDeserialize + Prefixer<'a>,
impl<'a, IK, T, PK> MultiIndex<'a, IK, T, PK>where
PK: PrimaryKey<'a> + KeyDeserialize,
T: Serialize + DeserializeOwned + Clone,
IK: PrimaryKey<'a> + KeyDeserialize + Prefixer<'a>,
sourcepub fn prefix_range<'c>(
&self,
store: &'c dyn Storage,
min: Option<PrefixBound<'a, IK>>,
max: Option<PrefixBound<'a, IK>>,
order: Order
) -> Box<dyn Iterator<Item = StdResult<(PK::Output, T)>> + 'c>where
T: 'c,
IK: 'c,
PK: 'c,
PK::Output: 'static,
'a: 'c,
pub fn prefix_range<'c>(
&self,
store: &'c dyn Storage,
min: Option<PrefixBound<'a, IK>>,
max: Option<PrefixBound<'a, IK>>,
order: Order
) -> Box<dyn Iterator<Item = StdResult<(PK::Output, T)>> + 'c>where
T: 'c,
IK: 'c,
PK: 'c,
PK::Output: 'static,
'a: 'c,
While range
over a prefix
fixes the prefix to one element and iterates over the
remaining, prefix_range
accepts bounds for the lowest and highest elements of the
Prefix
itself, and iterates over those (inclusively or exclusively, depending on
PrefixBound
).
There are some issues that distinguish these two, and blindly casting to Vec<u8>
doesn’t
solve them.