Skip to main content

Module 0x2::table_vec

A basic scalable vector library implemented using Table.

use 0x2::table;
use 0x2::tx_context;

Struct TableVec​

struct TableVec<Element: store> has store
Fields
contents: table::Table<u64, Element>
The contents of the table vector.

Constants​

const EIndexOutOfBound: u64 = 0;


const ETableNonEmpty: u64 = 1;

Function empty​

Create an empty TableVec.

public fun empty<Element: store>(ctx: &mut tx_context::TxContext): table_vec::TableVec<Element>
Implementation
public fun empty<Element: store>(ctx: &mut TxContext): TableVec<Element> {
    TableVec {
        contents: table::new(ctx)
    }
}

Function singleton​

Return a TableVec of size one containing element e.

public fun singleton<Element: store>(e: Element, ctx: &mut tx_context::TxContext): table_vec::TableVec<Element>
Implementation
public fun singleton<Element: store>(e: Element, ctx: &mut TxContext): TableVec<Element> {
    let mut t = empty(ctx);
    t.push_back(e);
    t
}

Function length​

Return the length of the TableVec.

public fun length<Element: store>(t: &table_vec::TableVec<Element>): u64
Implementation
public fun length<Element: store>(t: &TableVec<Element>): u64 {
    t.contents.length()
}

Function is_empty​

Return if the TableVec is empty or not.

public fun is_empty<Element: store>(t: &table_vec::TableVec<Element>): bool
Implementation
public fun is_empty<Element: store>(t: &TableVec<Element>): bool {
    t.length() == 0
}

Function borrow​

Acquire an immutable reference to the ith element of the TableVec t. Aborts if i is out of bounds.

public fun borrow<Element: store>(t: &table_vec::TableVec<Element>, i: u64): &Element
Implementation
public fun borrow<Element: store>(t: &TableVec<Element>, i: u64): &Element {
    assert!(t.length() > i, EIndexOutOfBound);
    &t.contents[i]
}

Function push_back​

Add element e to the end of the TableVec t.

public fun push_back<Element: store>(t: &mut table_vec::TableVec<Element>, e: Element)
Implementation
public fun push_back<Element: store>(t: &mut TableVec<Element>, e: Element) {
    let key = t.length();
    t.contents.add(key, e);
}

Function borrow_mut​

Return a mutable reference to the ith element in the TableVec t. Aborts if i is out of bounds.

public fun borrow_mut<Element: store>(t: &mut table_vec::TableVec<Element>, i: u64): &mut Element
Implementation
public fun borrow_mut<Element: store>(t: &mut TableVec<Element>, i: u64): &mut Element {
    assert!(t.length() > i, EIndexOutOfBound);
    &mut t.contents[i]
}

Function pop_back​

Pop an element from the end of TableVec t. Aborts if t is empty.

public fun pop_back<Element: store>(t: &mut table_vec::TableVec<Element>): Element
Implementation
public fun pop_back<Element: store>(t: &mut TableVec<Element>): Element {
    let length = length(t);
    assert!(length > 0, EIndexOutOfBound);
    t.contents.remove(length - 1)
}

Function destroy_empty​

Destroy the TableVec t. Aborts if t is not empty.

public fun destroy_empty<Element: store>(t: table_vec::TableVec<Element>)
Implementation
public fun destroy_empty<Element: store>(t: TableVec<Element>) {
    assert!(length(&t) == 0, ETableNonEmpty);
    let TableVec { contents } = t;
    contents.destroy_empty();
}

Function drop​

Drop a possibly non-empty TableVec t. Usable only if the value type Element has the drop ability

public fun drop<Element: drop, store>(t: table_vec::TableVec<Element>)
Implementation
public fun drop<Element: drop + store>(t: TableVec<Element>) {
    let TableVec { contents } = t;
    contents.drop()
}

Function swap​

Swaps the elements at the ith and jth indices in the TableVec t. Aborts if i or j is out of bounds.

public fun swap<Element: store>(t: &mut table_vec::TableVec<Element>, i: u64, j: u64)
Implementation
public fun swap<Element: store>(t: &mut TableVec<Element>, i: u64, j: u64) {
    assert!(t.length() > i, EIndexOutOfBound);
    assert!(t.length() > j, EIndexOutOfBound);
    if (i == j) { return };
    let element_i = t.contents.remove(i);
    let element_j = t.contents.remove(j);
    t.contents.add(j, element_i);
    t.contents.add(i, element_j);
}

Function swap_remove​

Swap the ith element of the TableVec t with the last element and then pop the TableVec. This is O(1), but does not preserve ordering of elements in the TableVec. Aborts if i is out of bounds.

public fun swap_remove<Element: store>(t: &mut table_vec::TableVec<Element>, i: u64): Element
Implementation
public fun swap_remove<Element: store>(t: &mut TableVec<Element>, i: u64): Element {
    assert!(t.length() > i, EIndexOutOfBound);
    let last_idx = t.length() - 1;
    t.swap(i, last_idx);
    t.pop_back()
}