Skip to main content

Module iota::dynamic_object_field

Similar to iota::dynamic_field, this module allows for the access of dynamic fields. But unlike, iota::dynamic_field 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::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 add​

Adds a dynamic object field to the object object: &mut UID at field specified by name: Name. Aborts with EFieldAlreadyExists if the object already has that field with that name.

public fun add<Name: copy, drop, store, Value: key, store>(object: &mut iota::object::UID, name: Name, value: Value)
Implementation
public fun add<Name: copy + drop + store, Value: key + store>(
    // we use &mut UID in several spots for access control
    object: &mut UID,
    name: Name,
    value: Value,
) {
    add_impl!(object, name, value)
}

pub borrow​

Immutably borrows the objects dynamic object field with the name specified by name: Name. Aborts with EFieldDoesNotExist if the object does not have a field with that name. Aborts with EFieldTypeMismatch if the field exists, but the value object does not have the specified type.

public fun borrow<Name: copy, drop, store, Value: key, store>(object: &iota::object::UID, name: Name): &Value
Implementation
public fun borrow<Name: copy + drop + store, Value: key + store>(object: &UID, name: Name): &Value {
    borrow_impl!(object, name)
}

pub borrow_mut​

Mutably borrows the objects dynamic object field with the name specified by name: Name. Aborts with EFieldDoesNotExist if the object does not have a field with that name. Aborts with EFieldTypeMismatch if the field exists, but the value object does not have the specified type.

public fun borrow_mut<Name: copy, drop, store, Value: key, store>(object: &mut iota::object::UID, name: Name): &mut Value
Implementation
public fun borrow_mut<Name: copy + drop + store, Value: key + store>(
    object: &mut UID,
    name: Name,
): &mut Value {
    borrow_mut_impl!(object, name)
}

pub exists_​

Returns true if and only if the object has a dynamic object field with the name specified by name: Name.

public fun exists_<Name: copy, drop, store>(object: &iota::object::UID, name: Name): bool
Implementation
public fun exists_<Name: copy + drop + store>(object: &UID, name: Name): bool {
    let key = Wrapper { name };
    field::exists_with_type<Wrapper<Name>, ID>(object, key)
}

pub exists_with_type​

Returns true if and only if the object has a dynamic field with the name specified by name: Name with an assigned value of type Value.

public fun exists_with_type<Name: copy, drop, store, Value: key, store>(object: &iota::object::UID, name: Name): bool
Implementation
public fun exists_with_type<Name: copy + drop + store, Value: key + store>(
    object: &UID,
    name: Name,
): bool {
    exists_with_type_impl!<_, Value>(object, name)
}

pub id​

Returns the ID of the object associated with the dynamic object field Returns none otherwise

public fun id<Name: copy, drop, store>(object: &iota::object::UID, name: Name): std::option::Option<iota::object::ID>
Implementation
public fun id<Name: copy + drop + store>(object: &UID, name: Name): Option<ID> {
    let key = Wrapper { name };
    if (!field::exists_with_type<Wrapper<Name>, ID>(object, key)) return option::none();
    let (_field, value_addr) = field::field_info<Wrapper<Name>>(object, key);
    option::some(value_addr.to_id())
}

pub remove​

Removes the objects dynamic object field with the name specified by name: Name and returns the bound object. Aborts with EFieldDoesNotExist if the object does not have a field with that name. Aborts with EFieldTypeMismatch if the field exists, but the value object does not have the specified type.

public fun remove<Name: copy, drop, store, Value: key, store>(object: &mut iota::object::UID, name: Name): Value
Implementation
public fun remove<Name: copy + drop + store, Value: key + store>(
    object: &mut UID,
    name: Name,
): Value {
    remove_impl!(object, name)
}

pub(pkg) internal_add​

public(package) fun internal_add<Name: copy, drop, store, Value: key>(object: &mut iota::object::UID, name: Name, value: Value)
Implementation
public(package) fun internal_add<Name: copy + drop + store, Value: key>(
    // we use &mut UID in several spots for access control
    object: &mut UID,
    name: Name,
    value: Value,
) {
    add_impl!(object, name, value)
}

pub(pkg) internal_borrow​

public(package) fun internal_borrow<Name: copy, drop, store, Value: key>(object: &iota::object::UID, name: Name): &Value
Implementation
public(package) fun internal_borrow<Name: copy + drop + store, Value: key>(
    object: &UID,
    name: Name,
): &Value {
    borrow_impl!(object, name)
}

pub(pkg) internal_borrow_mut​

public(package) fun internal_borrow_mut<Name: copy, drop, store, Value: key>(object: &mut iota::object::UID, name: Name): &mut Value
Implementation
public(package) fun internal_borrow_mut<Name: copy + drop + store, Value: key>(
    object: &mut UID,
    name: Name,
): &mut Value {
    borrow_mut_impl!(object, name)
}

pub(pkg) internal_exists_with_type​

public(package) fun internal_exists_with_type<Name: copy, drop, store, Value: key>(object: &iota::object::UID, name: Name): bool
Implementation
public(package) fun internal_exists_with_type<Name: copy + drop + store, Value: key>(
    object: &UID,
    name: Name,
): bool {
    exists_with_type_impl!<_, Value>(object, name)
}

pub(pkg) internal_remove​

public(package) fun internal_remove<Name: copy, drop, store, Value: key>(object: &mut iota::object::UID, name: Name): Value
Implementation
public(package) fun internal_remove<Name: copy + drop + store, Value: key>(
    object: &mut UID,
    name: Name,
): Value {
    remove_impl!(object, name)
}

prv add_impl (macro)​

macro fun add_impl<$Name: copy, drop, store, $Value: key>($object: &mut iota::object::UID, $name: $Name, $value: $Value)
Implementation
macro fun add_impl<$Name: copy + drop + store, $Value: key>(
    // we use &mut UID in several spots for access control
    $object: &mut UID,
    $name: $Name,
    $value: $Value,
) {
    let object = $object;
    let name = $name;
    let value = $value;
    let key = Wrapper { name };
    let id = object::id(&value);
    field::add(object, key, id);
    let (field, _) = field::field_info<Wrapper<$Name>>(object, key);
    add_child_object(field.to_address(), value);
}

prv borrow_impl (macro)​

macro fun borrow_impl<$Name: copy, drop, store, $Value: key>($object: &iota::object::UID, $name: $Name): &$Value
Implementation
macro fun borrow_impl<$Name: copy + drop + store, $Value: key>(
    $object: &UID,
    $name: $Name,
): &$Value {
    let object = $object;
    let name = $name;
    let key = Wrapper { name };
    let (field, value_id) = field::field_info<Wrapper<$Name>>(object, key);
    borrow_child_object<$Value>(field, value_id)
}

prv borrow_mut_impl (macro)​

macro fun borrow_mut_impl<$Name: copy, drop, store, $Value: key>($object: &mut iota::object::UID, $name: $Name): &mut $Value
Implementation
macro fun borrow_mut_impl<$Name: copy + drop + store, $Value: key>(
    $object: &mut UID,
    $name: $Name,
): &mut $Value {
    let object = $object;
    let name = $name;
    let key = Wrapper { name };
    let (field, value_id) = field::field_info_mut<Wrapper<$Name>>(object, key);
    borrow_child_object_mut<$Value>(field, value_id)
}

prv exists_with_type_impl (macro)​

macro fun exists_with_type_impl<$Name: copy, drop, store, $Value: key>($object: &iota::object::UID, $name: $Name): bool
Implementation
macro fun exists_with_type_impl<$Name: copy + drop + store, $Value: key>(
    $object: &UID,
    $name: $Name,
): bool {
    let object = $object;
    let name = $name;
    let key = Wrapper { name };
    if (!field::exists_with_type<Wrapper<$Name>, ID>(object, key)) return false;
    let (field, value_id) = field::field_info<Wrapper<$Name>>(object, key);
    field::has_child_object_with_ty<$Value>(field.to_address(), value_id)
}

prv remove_impl (macro)​

macro fun remove_impl<$Name: copy, drop, store, $Value: key>($object: &mut iota::object::UID, $name: $Name): $Value
Implementation
macro fun remove_impl<$Name: copy + drop + store, $Value: key>(
    $object: &mut UID,
    $name: $Name,
): $Value {
    let object = $object;
    let name = $name;
    let key = Wrapper { name };
    let (field, value_id) = field::field_info<Wrapper<$Name>>(object, key);
    let value = remove_child_object<$Value>(field.to_address(), value_id);
    field::remove<Wrapper<$Name>, ID>(object, key);
    value
}

Structs​

struct Wrapper​

public struct Wrapper<Name> has copy, drop, store
Fields
name: Name