Module sui::vec_set

• Struct VecSet
• Constants
• Function empty
• Function singleton
• Function insert
• Function remove
• Function contains
• Function length
• Function is_empty
• Function into_keys
• Function from_keys
• Function keys
• Function size

use std::option;
use std::vector;

Struct `VecSet`

A set data structure backed by a vector. The set is guaranteed not to contain duplicate keys. All operations are O(N) in the size of the set - the intention of this data structure is only to provide the convenience of programming against a set API. Sets that need sorted iteration rather than insertion order iteration should be handwritten.

public struct VecSet<K: copy, drop> has copy, drop, store

Fields

contents: vector<K>

Constants

This key already exists in the map

const EKeyAlreadyExists: u64 = 0;

This key does not exist in the map

const EKeyDoesNotExist: u64 = 1;

Function `empty`

Create an empty VecSet

public fun empty<K: copy, drop>(): sui::vec_set::VecSet<K>

Implementation

public fun empty<K: copy + drop>(): VecSet<K> {
    VecSet { contents: vector[] }
}

Function `singleton`

Create a singleton VecSet that only contains one element.

public fun singleton<K: copy, drop>(key: K): sui::vec_set::VecSet<K>

Implementation

public fun singleton<K: copy + drop>(key: K): VecSet<K> {
    VecSet { contents: vector[key] }
}

Function `insert`

Insert a key into self. Aborts if key is already present in self.

public fun insert<K: copy, drop>(self: &mut sui::vec_set::VecSet<K>, key: K)

Implementation

public fun insert<K: copy + drop>(self: &mut VecSet<K>, key: K) {
    assert!(!self.contains(&key), EKeyAlreadyExists);
    self.contents.push_back(key)
}

Function `remove`

Remove the entry key from self. Aborts if key is not present in self.

public fun remove<K: copy, drop>(self: &mut sui::vec_set::VecSet<K>, key: &K)

Implementation

public fun remove<K: copy + drop>(self: &mut VecSet<K>, key: &K) {
    let idx = self.contents.find_index!(|k| k == key).destroy_or!(abort EKeyDoesNotExist);
    self.contents.remove(idx);
}

Function `contains`

Return true if self contains an entry for key, false otherwise

public fun contains<K: copy, drop>(self: &sui::vec_set::VecSet<K>, key: &K): bool

Implementation

public fun contains<K: copy + drop>(self: &VecSet<K>, key: &K): bool {
    'search: {
        self.contents.do_ref!(|k| if (k == key) return 'search true);
        false
    }
}

Function `length`

Return the number of entries in self

public fun length<K: copy, drop>(self: &sui::vec_set::VecSet<K>): u64

Implementation

public fun length<K: copy + drop>(self: &VecSet<K>): u64 {
    self.contents.length()
}

Function `is_empty`

Return true if self has 0 elements, false otherwise

public fun is_empty<K: copy, drop>(self: &sui::vec_set::VecSet<K>): bool

Implementation

public fun is_empty<K: copy + drop>(self: &VecSet<K>): bool {
    self.length() == 0
}

Function `into_keys`

Unpack self into vectors of keys. The output keys are stored in insertion order, *not* sorted.

public fun into_keys<K: copy, drop>(self: sui::vec_set::VecSet<K>): vector<K>

Implementation

public fun into_keys<K: copy + drop>(self: VecSet<K>): vector<K> {
    let VecSet { contents } = self;
    contents
}

Function `from_keys`

Construct a new VecSet from a vector of keys. The keys are stored in insertion order (the original keys ordering) and are *not* sorted.

public fun from_keys<K: copy, drop>(keys: vector<K>): sui::vec_set::VecSet<K>

Implementation

public fun from_keys<K: copy + drop>(mut keys: vector<K>): VecSet<K> {
    keys.reverse();
    let mut set = empty();
    while (keys.length() != 0) set.insert(keys.pop_back());
    set
}

Function `keys`

Borrow the contents of the VecSet to access content by index without unpacking. The contents are stored in insertion order, *not* sorted.

public fun keys<K: copy, drop>(self: &sui::vec_set::VecSet<K>): &vector<K>

Implementation

public fun keys<K: copy + drop>(self: &VecSet<K>): &vector<K> {
    &self.contents
}

Function `size`

Return the number of entries in self

public fun size<K: copy, drop>(self: &sui::vec_set::VecSet<K>): u64

Implementation

public fun size<K: copy + drop>(self: &VecSet<K>): u64 {
    self.contents.length()
}