Struct cw_storage_plus::MultiIndex

pub struct MultiIndex<'a, IK, T, PK = ()> { /* fields omitted */ }

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 (optional) PK type defines the type of Primary Key deserialization.

Implementations

impl<'a, IK, T, PK> MultiIndex<'a, IK, T, PK> where
    T: Serialize + DeserializeOwned + Clone, 

pub fn new(
    idx_fn: fn(_: &T) -> IK,
    pk_namespace: &'a str,
    idx_namespace: &'a 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(
    |d: &Data| d.age,
    "age",
    "age__owner",
);

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 index_key(&self, k: IK) -> Vec<u8>

impl<'a, IK, T, PK> MultiIndex<'a, IK, T, PK> where
    T: Serialize + DeserializeOwned + Clone,
    IK: PrimaryKey<'a> + Prefixer<'a>, 

pub fn range_raw<'c>(
    &'c self,
    store: &'c dyn Storage,
    min: Option<Bound>,
    max: Option<Bound>,
    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>,
    max: Option<Bound>,
    order: Order
) -> Box<dyn Iterator<Item = Vec<u8>> + '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.

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) -> Prefix<PK, T>

pub fn sub_prefix(&self, p: IK::Prefix) -> Prefix<PK, T>

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>, 

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,
    'a: 'c,
    IK: 'c,
    PK: 'c,
    PK::Output: 'static, 

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.

pub fn range<'c>(
    &self,
    store: &'c dyn Storage,
    min: Option<Bound>,
    max: Option<Bound>,
    order: Order
) -> Box<dyn Iterator<Item = StdResult<(PK::Output, T)>> + 'c> where
    T: 'c,
    PK::Output: 'static, 

pub fn keys<'c>(
    &self,
    store: &'c dyn Storage,
    min: Option<Bound>,
    max: Option<Bound>,
    order: Order
) -> Box<dyn Iterator<Item = StdResult<PK::Output>> + 'c> where
    T: 'c,
    PK::Output: 'static, 

Trait Implementations

impl<'a, IK, T, PK> Index<T> for MultiIndex<'a, IK, T, PK> where
    T: Serialize + DeserializeOwned + Clone,
    IK: PrimaryKey<'a>, 

fn save(&self, store: &mut dyn Storage, pk: &[u8], data: &T) -> StdResult<()>

fn remove(
    &self,
    store: &mut dyn Storage,
    pk: &[u8],
    old_data: &T
) -> StdResult<()>