Skip to main content

Module iota::object_table

Similar to iota::table, an ObjectTable<K, V> is a map-like collection. But unlike iota::table, the values bound to these dynamic fields must be objects themselves. This allows for the objects to still exist within in storage, which may be important for external tools. The difference is otherwise not observable from within Move.

use iota::address;
use iota::dynamic_field;
use iota::dynamic_object_field;
use iota::hex;
use iota::object;
use iota::tx_context;
use std::ascii;
use std::bcs;
use std::option;
use std::string;
use std::vector;

Module Functions​

pub new​

Creates a new, empty table

public fun new<K: copy, drop, store, V: key, store>(ctx: &mut iota::tx_context::TxContext): iota::object_table::ObjectTable<K, V>
Implementation
public fun new<K: copy + drop + store, V: key + store>(ctx: &mut TxContext): ObjectTable<K, V> {
    ObjectTable {
        id: object::new(ctx),
        size: 0,
    }
}

Structs​

struct ObjectTable​

public struct ObjectTable<phantom K: copy, drop, store, phantom V: key, store> has key, store
Fields
id: iota::object::UID

the ID of this table

size: u64

the number of key-value pairs in the table

pub add​

Adds a key-value pair to the table table: &mut ObjectTable<K, V> Aborts with iota::dynamic_field::EFieldAlreadyExists if the table already has an entry with that key k: K.

public fun add<K: copy, drop, store, V: key, store>(table: &mut iota::object_table::ObjectTable<K, V>, k: K, v: V)
Implementation
public fun add<K: copy + drop + store, V: key + store>(table: &mut ObjectTable<K, V>, k: K, v: V) {
    ofield::add(&mut table.id, k, v);
    table.size = table.size + 1;
}

pub borrow​

Immutable borrows the value associated with the key in the table table: &ObjectTable<K, V>. Aborts with iota::dynamic_field::EFieldDoesNotExist if the table does not have an entry with that key k: K.

public fun borrow<K: copy, drop, store, V: key, store>(table: &iota::object_table::ObjectTable<K, V>, k: K): &V
Implementation
public fun borrow<K: copy + drop + store, V: key + store>(table: &ObjectTable<K, V>, k: K): &V {
    ofield::borrow(&table.id, k)
}

pub borrow_mut​

Mutably borrows the value associated with the key in the table table: &mut ObjectTable<K, V>. Aborts with iota::dynamic_field::EFieldDoesNotExist if the table does not have an entry with that key k: K.

public fun borrow_mut<K: copy, drop, store, V: key, store>(table: &mut iota::object_table::ObjectTable<K, V>, k: K): &mut V
Implementation
public fun borrow_mut<K: copy + drop + store, V: key + store>(
    table: &mut ObjectTable<K, V>,
    k: K,
): &mut V {
    ofield::borrow_mut(&mut table.id, k)
}

pub contains​

Returns true iff there is a value associated with the key k: K in table table: &ObjectTable<K, V>

public fun contains<K: copy, drop, store, V: key, store>(table: &iota::object_table::ObjectTable<K, V>, k: K): bool
Implementation
public fun contains<K: copy + drop + store, V: key + store>(table: &ObjectTable<K, V>, k: K): bool {
    ofield::exists_<K>(&table.id, k)
}

pub destroy_empty​

Destroys an empty table Aborts with ETableNotEmpty if the table still contains values

public fun destroy_empty<K: copy, drop, store, V: key, store>(table: iota::object_table::ObjectTable<K, V>)
Implementation
public fun destroy_empty<K: copy + drop + store, V: key + store>(table: ObjectTable<K, V>) {
    let ObjectTable { id, size } = table;
    assert!(size == 0, ETableNotEmpty);
    id.delete()
}

pub is_empty​

Returns true iff the table is empty (if length returns 0)

public fun is_empty<K: copy, drop, store, V: key, store>(table: &iota::object_table::ObjectTable<K, V>): bool
Implementation
public fun is_empty<K: copy + drop + store, V: key + store>(table: &ObjectTable<K, V>): bool {
    table.size == 0
}

pub length​

Returns the size of the table, the number of key-value pairs

public fun length<K: copy, drop, store, V: key, store>(table: &iota::object_table::ObjectTable<K, V>): u64
Implementation
public fun length<K: copy + drop + store, V: key + store>(table: &ObjectTable<K, V>): u64 {
    table.size
}

pub remove​

Removes the key-value pair in the table table: &mut ObjectTable<K, V> and returns the value. Aborts with iota::dynamic_field::EFieldDoesNotExist if the table does not have an entry with that key k: K.

public fun remove<K: copy, drop, store, V: key, store>(table: &mut iota::object_table::ObjectTable<K, V>, k: K): V
Implementation
public fun remove<K: copy + drop + store, V: key + store>(table: &mut ObjectTable<K, V>, k: K): V {
    let v = ofield::remove(&mut table.id, k);
    table.size = table.size - 1;
    v
}

pub value_id​

Returns the ID of the object associated with the key if the table has an entry with key k: K Returns none otherwise

public fun value_id<K: copy, drop, store, V: key, store>(table: &iota::object_table::ObjectTable<K, V>, k: K): std::option::Option<iota::object::ID>
Implementation
public fun value_id<K: copy + drop + store, V: key + store>(
    table: &ObjectTable<K, V>,
    k: K,
): Option<ID> {
    ofield::id(&table.id, k)
}

Constants​

err ETableNotEmpty​

const ETableNotEmpty: u64 = 0;