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

Implementations

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

pub const fn new(idx_fn: fn(&T) -> IK, idx_namespace: &'static 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, 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.

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) -> IndexPrefix<PK, T, IK::Suffix>

pub fn sub_prefix( &self, p: IK::SubPrefix, ) -> IndexPrefix<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<()>