Struct cw_storage_plus::MultiIndex

pub struct MultiIndex<'a, IK, T, PK> { /* private fields */ }

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

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

pub fn new(
    idx_fn: fn(_: &[u8], _: &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(
    |_pk: &[u8], 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> + 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>

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

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

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<'a, (IK, PK)>>,
    max: Option<Bound<'a, (IK, PK)>>,
    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<'a, (IK, PK)>>,
    max: Option<Bound<'a, (IK, PK)>>,
    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<()>