Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

Module 0x1::table_with_length

Extends Table and provides functions such as length and the ability to be destroyed

use 0x1::error;
use 0x1::table;

Struct TableWithLength

Type of tables

struct TableWithLength<K: copy, drop, V> has store
Fields
inner: table::Table<K, V>
length: u64

Constants 

const EALREADY_EXISTS: u64 = 100;


const ENOT_EMPTY: u64 = 102;


const ENOT_FOUND: u64 = 101;

Function new

Create a new Table.

public fun new<K: copy, drop, V: store>(): table_with_length::TableWithLength<K, V>
Implementation 
public fun new<K: copy + drop, V: store>(): TableWithLength<K, V> {
    TableWithLength {
        inner: table::new<K, V>(),
        length: 0,
    }
}

Function destroy_empty

Destroy a table. The table must be empty to succeed.

public fun destroy_empty<K: copy, drop, V>(self: table_with_length::TableWithLength<K, V>)
Implementation 
public fun destroy_empty<K: copy + drop, V>(self: TableWithLength<K, V>) {
    assert!(self.length == 0, error::invalid_state(ENOT_EMPTY));
    let TableWithLength { inner, length: _ } = self;
    inner.destroy_known_empty_unsafe()
}

Function add

Add a new entry to the table. Aborts if an entry for this key already exists. The entry itself is not stored in the table, and cannot be discovered from it.

public fun add<K: copy, drop, V>(self: &mut table_with_length::TableWithLength<K, V>, key: K, val: V)
Implementation 
public fun add<K: copy + drop, V>(self: &mut TableWithLength<K, V>, key: K, val: V) {
    self.inner.add(key, val);
    self.length += 1;
}

Function borrow

Acquire an immutable reference to the value which key maps to. Aborts if there is no entry for key.

public fun borrow<K: copy, drop, V>(self: &table_with_length::TableWithLength<K, V>, key: K): &V
Implementation 
public fun borrow<K: copy + drop, V>(self: &TableWithLength<K, V>, key: K): &V {
    self.inner.borrow(key)
}

Function borrow_mut

Acquire a mutable reference to the value which key maps to. Aborts if there is no entry for key.

public fun borrow_mut<K: copy, drop, V>(self: &mut table_with_length::TableWithLength<K, V>, key: K): &mut V
Implementation 
public fun borrow_mut<K: copy + drop, V>(self: &mut TableWithLength<K, V>, key: K): &mut V {
    self.inner.borrow_mut(key)
}

Function length

Returns the length of the table, i.e. the number of entries.

public fun length<K: copy, drop, V>(self: &table_with_length::TableWithLength<K, V>): u64
Implementation 
public fun length<K: copy + drop, V>(self: &TableWithLength<K, V>): u64 {
    self.length
}

Function empty

Returns true if this table is empty.

public fun empty<K: copy, drop, V>(self: &table_with_length::TableWithLength<K, V>): bool
Implementation 
public fun empty<K: copy + drop, V>(self: &TableWithLength<K, V>): bool {
    self.length == 0
}

Function borrow_mut_with_default

Acquire a mutable reference to the value which key maps to. Insert the pair (key, default) first if there is no entry for key.

public fun borrow_mut_with_default<K: copy, drop, V: drop>(self: &mut table_with_length::TableWithLength<K, V>, key: K, default: V): &mut V
Implementation 
public fun borrow_mut_with_default<K: copy + drop, V: drop>(self: &mut TableWithLength<K, V>, key: K, default: V): &mut V {
    if (self.inner.contains(key)) {
        self.inner.borrow_mut(key)
    } else {
        self.inner.add(key, default);
        self.length += 1;
        self.inner.borrow_mut(key)
    }
}

Function upsert

Insert the pair (key, value) if there is no entry for key. update the value of the entry for key to value otherwise

public fun upsert<K: copy, drop, V: drop>(self: &mut table_with_length::TableWithLength<K, V>, key: K, value: V)
Implementation 
public fun upsert<K: copy + drop, V: drop>(self: &mut TableWithLength<K, V>, key: K, value: V) {
    if (!self.inner.contains(key)) {
        self.add(copy key, value)
    } else {
        let ref = self.inner.borrow_mut(key);
        *ref = value;
    };
}

Function remove

Remove from table and return the value which key maps to. Aborts if there is no entry for key.

public fun remove<K: copy, drop, V>(self: &mut table_with_length::TableWithLength<K, V>, key: K): V
Implementation 
public fun remove<K: copy + drop, V>(self: &mut TableWithLength<K, V>, key: K): V {
    let val = self.inner.remove(key);
    self.length -= 1;
    val
}

Function contains

Returns true iff table contains an entry for key.

public fun contains<K: copy, drop, V>(self: &table_with_length::TableWithLength<K, V>, key: K): bool
Implementation 
public fun contains<K: copy + drop, V>(self: &TableWithLength<K, V>, key: K): bool {
    self.inner.contains(key)
}

Specification 

native fun spec_len<K, V>(t: TableWithLength<K, V>): num;


native fun spec_contains<K, V>(t: TableWithLength<K, V>, k: K): bool;


native fun spec_set<K, V>(t: TableWithLength<K, V>, k: K, v: V): TableWithLength<K, V>;


native fun spec_remove<K, V>(t: TableWithLength<K, V>, k: K): TableWithLength<K, V>;


native fun spec_get<K, V>(t: TableWithLength<K, V>, k: K): V;

Struct TableWithLength 

struct TableWithLength<K: copy, drop, V> has store
inner: table::Table<K, V>
length: u64 
pragma intrinsic = map,
    map_new = new,
    map_destroy_empty = destroy_empty,
    map_len = length,
    map_is_empty = empty,
    map_has_key = contains,
    map_add_no_override = add,
    map_add_override_if_exists = upsert,
    map_del_must_exist = remove,
    map_borrow = borrow,
    map_borrow_mut = borrow_mut,
    map_borrow_mut_with_default = borrow_mut_with_default,
    map_spec_get = spec_get,
    map_spec_set = spec_set,
    map_spec_del = spec_remove,
    map_spec_len = spec_len,
    map_spec_has_key = spec_contains;

Function new 

public fun new<K: copy, drop, V: store>(): table_with_length::TableWithLength<K, V>

pragma intrinsic;

Function destroy_empty 

public fun destroy_empty<K: copy, drop, V>(self: table_with_length::TableWithLength<K, V>)

pragma intrinsic;

Function add 

public fun add<K: copy, drop, V>(self: &mut table_with_length::TableWithLength<K, V>, key: K, val: V)

pragma intrinsic;

Function borrow 

public fun borrow<K: copy, drop, V>(self: &table_with_length::TableWithLength<K, V>, key: K): &V

pragma intrinsic;

Function borrow_mut 

public fun borrow_mut<K: copy, drop, V>(self: &mut table_with_length::TableWithLength<K, V>, key: K): &mut V

pragma intrinsic;

Function length 

public fun length<K: copy, drop, V>(self: &table_with_length::TableWithLength<K, V>): u64

pragma intrinsic;

Function empty 

public fun empty<K: copy, drop, V>(self: &table_with_length::TableWithLength<K, V>): bool

pragma intrinsic;

Function borrow_mut_with_default 

public fun borrow_mut_with_default<K: copy, drop, V: drop>(self: &mut table_with_length::TableWithLength<K, V>, key: K, default: V): &mut V

aborts_if false;
pragma intrinsic;

Function upsert 

public fun upsert<K: copy, drop, V: drop>(self: &mut table_with_length::TableWithLength<K, V>, key: K, value: V)

pragma intrinsic;

Function remove 

public fun remove<K: copy, drop, V>(self: &mut table_with_length::TableWithLength<K, V>, key: K): V

pragma intrinsic;

Function contains 

public fun contains<K: copy, drop, V>(self: &table_with_length::TableWithLength<K, V>, key: K): bool

pragma intrinsic;