Struct LookupSet

pub struct LookupSet<T, H = Identity>
where
    T: BorshSerialize,
    H: ToKey,
{ /* private fields */ }

A non-iterable implementation of a set that stores its content directly on the storage trie.

This set stores the values under a hash of the set’s prefix and BorshSerialize of the value and transformed using the set’s ToKey implementation.

The default hash function for LookupSet is Identity which just prefixes the serialized key object and uses these bytes as the key. This is to be backwards-compatible with collections::LookupSet and be fast for small keys. To use a custom function, use with_hasher. Alternative builtin hash functions can be found at near_sdk::store::key.

Examples

use near_sdk::store::LookupSet;

// Initializes a set, the generic types can be inferred to `LookupSet<String, Identity>`
// The `b"a"` parameter is a prefix for the storage keys of this data structure.
let mut books = LookupSet::new(b"a");


// Add some books.
books.insert("A Dance With Dragons".to_string());
books.insert("To Kill a Mockingbird".to_string());
books.insert("The Odyssey".to_string());
books.insert("The Great Gatsby".to_string());

// Check for a specific one.
assert!(!books.contains("The Winds of Winter"));
assert!(books.contains("The Odyssey"));

// Remove a book.
books.remove("The Odyssey");

assert!(!books.contains("The Odyssey"));

Implementations

impl<T> LookupSet<T, Identity>

where T: BorshSerialize,

pub fn new<S>(prefix: S) -> Self

where S: IntoStorageKey,

Initialize new LookupSet with the prefix provided.

This prefix can be anything that implements IntoStorageKey. The prefix is used when storing and looking up values in storage to ensure no collisions with other collections.

impl<T, H> LookupSet<T, H>

where T: BorshSerialize, H: ToKey,

pub fn with_hasher<S>(prefix: S) -> Self

where S: IntoStorageKey,

Initialize a LookupSet with a custom hash function.

Example

use near_sdk::store::{LookupSet, key::Keccak256};

let map = LookupSet::<String, Keccak256>::with_hasher(b"m");

pub fn contains<Q>(&self, value: &Q) -> bool

where T: Borrow<Q>, Q: BorshSerialize + ?Sized,

Returns true if the set contains the specified value.

The value may be any borrowed form of the set’s value type, but BorshSerialize on the borrowed form must match those for the value type.

pub fn insert(&mut self, value: T) -> bool

Adds a value to the set.

If the set did not have this value present, true is returned.

If the set did have this value present, false is returned.

pub fn remove<Q>(&mut self, value: &Q) -> bool

where T: Borrow<Q>, Q: BorshSerialize + ?Sized,

Removes a value from the set. Returns whether the value was present in the set.

The value may be any borrowed form of the set’s value type, but BorshSerialize on the borrowed form must match those for the value type.

Trait Implementations

impl<T, H> BorshDeserialize for LookupSet<T, H>

where T: BorshSerialize, H: ToKey,

fn deserialize_reader<__R: Read>(reader: &mut __R) -> Result<Self, Error>

fn deserialize(buf: &mut &[u8]) -> Result<Self, Error>

Deserializes this instance from a given slice of bytes. Updates the buffer to point at the remaining bytes.

fn try_from_slice(v: &[u8]) -> Result<Self, Error>

Deserialize this instance from a slice of bytes.

fn try_from_reader<R>(reader: &mut R) -> Result<Self, Error>

where R: Read,

impl<T, H> BorshSchema for LookupSet<T, H>

where T: BorshSerialize, H: ToKey,

fn declaration() -> Declaration

Get the name of the type without brackets.

fn add_definitions_recursively( definitions: &mut BTreeMap<Declaration, Definition>, )

Recursively, using DFS, add type definitions required for this type. Type definition partially explains how to serialize/deserialize a type.

impl<T, H> BorshSerialize for LookupSet<T, H>

where T: BorshSerialize, H: ToKey,

fn serialize<__W: Write>(&self, writer: &mut __W) -> Result<(), Error>

impl<T, H> Debug for LookupSet<T, H>

where T: BorshSerialize, H: ToKey,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T, H> Extend<T> for LookupSet<T, H>

where T: BorshSerialize, H: ToKey,

fn extend<I>(&mut self, iter: I)

where I: IntoIterator<Item = T>,

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.