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()
}