Struct me3_framework::scripting::lua::prelude::LuaTable

pub struct LuaTable<'lua>(_);

Handle to an internal Lua table.

Implementations

impl<'lua> Table<'lua>

pub fn set<K, V>(&self, key: K, value: V) -> Result<(), Error>where
    K: ToLua<'lua>,
    V: ToLua<'lua>,

Sets a key-value pair in the table.

If the value is nil, this will effectively remove the pair.

This might invoke the __newindex metamethod. Use the raw_set method if that is not desired.

Examples

Export a value as a global to make it usable from Lua:

let globals = lua.globals();

globals.set("assertions", cfg!(debug_assertions))?;

lua.load(r#"
    if assertions == true then
        -- ...
    elseif assertions == false then
        -- ...
    else
        error("assertions neither on nor off?")
    end
"#).exec()?;

pub fn get<K, V>(&self, key: K) -> Result<V, Error>where
    K: ToLua<'lua>,
    V: FromLua<'lua>,

Gets the value associated to key from the table.

If no value is associated to key, returns the nil value.

This might invoke the __index metamethod. Use the raw_get method if that is not desired.

Examples

Query the version of the Lua interpreter:

let globals = lua.globals();

let version: String = globals.get("_VERSION")?;
println!("Lua version: {}", version);

pub fn contains_key<K>(&self, key: K) -> Result<bool, Error>where
    K: ToLua<'lua>,

Checks whether the table contains a non-nil value for key.

pub fn equals<T>(&self, other: T) -> Result<bool, Error>where
    T: AsRef<Table<'lua>>,

Compares two tables for equality.

Tables are compared by reference first. If they are not primitively equals, then mlua will try to invoke the __eq metamethod. mlua will check self first for the metamethod, then other if not found.

Examples

Compare two tables using __eq metamethod:

let table1 = lua.create_table()?;
table1.set(1, "value")?;

let table2 = lua.create_table()?;
table2.set(2, "value")?;

let always_equals_mt = lua.create_table()?;
always_equals_mt.set("__eq", lua.create_function(|_, (_t1, _t2): (Table, Table)| Ok(true))?)?;
table2.set_metatable(Some(always_equals_mt));

assert!(table1.equals(&table1.clone())?);
assert!(table1.equals(&table2)?);

pub fn raw_set<K, V>(&self, key: K, value: V) -> Result<(), Error>where
    K: ToLua<'lua>,
    V: ToLua<'lua>,

Sets a key-value pair without invoking metamethods.

pub fn raw_get<K, V>(&self, key: K) -> Result<V, Error>where
    K: ToLua<'lua>,
    V: FromLua<'lua>,

Gets the value associated to key without invoking metamethods.

pub fn raw_insert<V>(&self, idx: i32, value: V) -> Result<(), Error>where
    V: ToLua<'lua>,

Inserts element value at position idx to the table, shifting up the elements from table[idx]. The worst case complexity is O(n), where n is the table length.

pub fn raw_remove<K>(&self, key: K) -> Result<(), Error>where
    K: ToLua<'lua>,

Removes a key from the table.

If key is an integer, mlua shifts down the elements from table[key+1], and erases element table[key]. The complexity is O(n) in the worst case, where n is the table length.

For other key types this is equivalent to setting table[key] = nil.

pub fn len(&self) -> Result<i32, Error>

Returns the result of the Lua # operator.

This might invoke the __len metamethod. Use the raw_len method if that is not desired.

pub fn raw_len(&self) -> i32

Returns the result of the Lua # operator, without invoking the __len metamethod.

pub fn get_metatable(&self) -> Option<Table<'lua>>

Returns a reference to the metatable of this table, or None if no metatable is set.

Unlike the getmetatable Lua function, this method ignores the __metatable field.

pub fn set_metatable(&self, metatable: Option<Table<'lua>>)

Sets or removes the metatable of this table.

If metatable is None, the metatable is removed (if no metatable is set, this does nothing).

pub fn set_readonly(&self, enabled: bool)

Sets readonly attribute on the table.

Requires feature = "luau"

pub fn is_readonly(&self) -> bool

Returns readonly attribute of the table.

Requires feature = "luau"

pub fn to_pointer(&self) -> *const c_void

Converts the table to a generic C pointer.

Different tables will give different pointers. There is no way to convert the pointer back to its original value.

Typically this function is used only for hashing and debug information.

pub fn pairs<K, V>(self) -> TablePairs<'lua, K, V>where
    K: FromLua<'lua>,
    V: FromLua<'lua>,

Consume this table and return an iterator over the pairs of the table.

This works like the Lua pairs function, but does not invoke the __pairs metamethod.

The pairs are wrapped in a Result, since they are lazily converted to K and V types.

Note

While this method consumes the Table object, it can not prevent code from mutating the table while the iteration is in progress. Refer to the Lua manual for information about the consequences of such mutation.

Examples

Iterate over all globals:

let globals = lua.globals();

for pair in globals.pairs::<Value, Value>() {
    let (key, value) = pair?;
    // ...
}

pub fn sequence_values<V>(self) -> TableSequence<'lua, V>where
    V: FromLua<'lua>,

Consume this table and return an iterator over all values in the sequence part of the table.

The iterator will yield all values t[1], t[2], and so on, until a nil value is encountered. This mirrors the behavior of Lua’s ipairs function and will invoke the __index metamethod according to the usual rules. However, the deprecated __ipairs metatable will not be called.

Just like pairs, the values are wrapped in a Result.

Note

While this method consumes the Table object, it can not prevent code from mutating the table while the iteration is in progress. Refer to the Lua manual for information about the consequences of such mutation.

Examples

let my_table: Table = lua.load(r#"
    {
        [1] = 4,
        [2] = 5,
        [4] = 7,
        key = 2
    }
"#).eval()?;

let expected = [4, 5];
for (&expected, got) in expected.iter().zip(my_table.sequence_values::<u32>()) {
    assert_eq!(expected, got?);
}

pub fn raw_sequence_values<V>(self) -> TableSequence<'lua, V>where
    V: FromLua<'lua>,

Consume this table and return an iterator over all values in the sequence part of the table.

Unlike the sequence_values, does not invoke __index metamethod when iterating.

Trait Implementations

impl<'lua> AsRef<Table<'lua>> for Table<'lua>

fn as_ref(&self) -> &Table<'lua>

Converts this type into a shared reference of the (usually inferred) input type.

impl<'lua> Clone for Table<'lua>

fn clone(&self) -> Table<'lua>

Returns a copy of the value.

const fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'lua> Debug for Table<'lua>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<'lua> FromLua<'lua> for Table<'lua>

fn from_lua(value: Value<'lua>, &'lua Lua) -> Result<Table<'lua>, Error>

Performs the conversion.

impl<'lua> PartialEq<Table<'lua>> for Table<'lua>

fn eq(&self, other: &Table<'lua>) -> bool

This method tests for self and other values to be equal, and is used by ==.

const fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'lua> Serialize for Table<'lua>

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

Serialize this value into the given Serde serializer.

impl<'lua> TableExt<'lua> for Table<'lua>

fn call<A, R>(&self, args: A) -> Result<R, Error>where
    A: ToLuaMulti<'lua>,
    R: FromLuaMulti<'lua>,

Calls the table as function assuming it has __call metamethod.

fn call_async<'fut, A, R>(
    &self,
    args: A
) -> Pin<Box<dyn Future<Output = Result<R, Error>> + 'fut, Global>>where
    'lua: 'fut,
    A: ToLuaMulti<'lua>,
    R: 'fut + FromLuaMulti<'lua>,

Asynchronously calls the table as function assuming it has __call metamethod.

fn call_method<K, A, R>(&self, key: K, args: A) -> Result<R, Error>where
    K: ToLua<'lua>,
    A: ToLuaMulti<'lua>,
    R: FromLuaMulti<'lua>,

Gets the function associated to key from the table and executes it, passing the table itself along with args as function arguments.

fn call_function<K, A, R>(&self, key: K, args: A) -> Result<R, Error>where
    K: ToLua<'lua>,
    A: ToLuaMulti<'lua>,
    R: FromLuaMulti<'lua>,

Gets the function associated to key from the table and executes it, passing args as function arguments.

fn call_async_method<'fut, K, A, R>(
    &self,
    key: K,
    args: A
) -> Pin<Box<dyn Future<Output = Result<R, Error>> + 'fut, Global>>where
    'lua: 'fut,
    K: ToLua<'lua>,
    A: ToLuaMulti<'lua>,
    R: 'fut + FromLuaMulti<'lua>,

Gets the function associated to key from the table and asynchronously executes it, passing the table itself along with args as function arguments and returning Future.

fn call_async_function<'fut, K, A, R>(
    &self,
    key: K,
    args: A
) -> Pin<Box<dyn Future<Output = Result<R, Error>> + 'fut, Global>>where
    'lua: 'fut,
    K: ToLua<'lua>,
    A: ToLuaMulti<'lua>,
    R: 'fut + FromLuaMulti<'lua>,

Gets the function associated to key from the table and asynchronously executes it, passing args as function arguments and returning Future.

impl<'lua> ToLua<'lua> for Table<'lua>

fn to_lua(self, &'lua Lua) -> Result<Value<'lua>, Error>

Performs the conversion.