Struct cw_storage_plus::UniqueIndex

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

UniqueIndex stores (namespace, index_name, idx_value) -> {key, value} Allows one value per index (i.e. unique) and copies pk and data The optional PK type defines the type of Primary Key deserialization.

Implementations

impl<'a, IK, T, PK> UniqueIndex<'a, IK, T, PK>

pub fn new(idx_fn: fn(_: &T) -> IK, idx_namespace: &'a str) -> Self

Create a new UniqueIndex

idx_fn - lambda creating index key from index value idx_namespace - prefix for the index value

Example:

use cw_storage_plus::UniqueIndex;

struct Data {
    pub name: String,
    pub age: u32,
}

UniqueIndex::<_, _, ()>::new(|d: &Data| d.age, "data__age");

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

pub fn index_key(&self, k: IK) -> Vec<u8>

pub fn item(&self, store: &dyn Storage, idx: IK) -> StdResult<Option<Record<T>>>

returns all items that match this secondary index, always by pk Ascending

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

pub fn range_raw<'c>(
    &self,
    store: &'c dyn Storage,
    min: Option<Bound<'a, IK>>,
    max: Option<Bound<'a, IK>>,
    order: Order
) -> Box<dyn Iterator<Item = StdResult<Record<T>>> + 'c>where
    T: 'c,

pub fn keys_raw<'c>(
    &self,
    store: &'c dyn Storage,
    min: Option<Bound<'a, IK>>,
    max: Option<Bound<'a, IK>>,
    order: Order
) -> Box<dyn Iterator<Item = Vec<u8>> + 'c>

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

pub fn prefix_range<'c>(
    &self,
    store: &'c dyn Storage,
    min: Option<PrefixBound<'a, IK::Prefix>>,
    max: Option<PrefixBound<'a, IK::Prefix>>,
    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>>,
    max: Option<Bound<'a, IK>>,
    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>>,
    max: Option<Bound<'a, IK>>,
    order: Order
) -> Box<dyn Iterator<Item = StdResult<PK::Output>> + 'c>where
    T: 'c,
    PK::Output: 'static,

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

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

Trait Implementations

impl<'a, IK, T, PK> Index<T> for UniqueIndex<'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<()>