Enum me3_framework::scripting::lua::Value

pub enum Value<'lua> {
    Nil,
    Boolean(bool),
    LightUserData(LightUserData),
    Integer(i32),
    Number(f64),
    Vector(f32, f32, f32),
    String(String<'lua>),
    Table(Table<'lua>),
    Function(Function<'lua>),
    Thread(Thread<'lua>),
    UserData(AnyUserData<'lua>),
    Error(Error),
}

A dynamically typed Lua value. The String, Table, Function, Thread, and UserData variants contain handle types into the internal Lua state. It is a logic error to mix handle types between separate Lua instances, and doing so will result in a panic.

Variants

Nil

The Lua value nil.

Boolean(bool)

The Lua value true or false.

LightUserData(LightUserData)

A “light userdata” object, equivalent to a raw pointer.

Integer(i32)

An integer number.

Any Lua number convertible to a Integer will be represented as this variant.

Number(f64)

A floating point number.

Vector(f32, f32, f32)

A Luau vector.

String(String<'lua>)

An interned string, managed by Lua.

Unlike Rust strings, Lua strings may not be valid UTF-8.

Table(Table<'lua>)

Reference to a Lua table.

Function(Function<'lua>)

Reference to a Lua function (or closure).

Thread(Thread<'lua>)

Reference to a Lua thread (or coroutine).

UserData(AnyUserData<'lua>)

Reference to a userdata object that holds a custom type which implements UserData. Special builtin userdata types will be represented as other Value variants.

Error(Error)

Error is a special builtin userdata type. When received from Lua it is implicitly cloned.

Implementations

impl<'lua> Value<'lua>

pub const fn type_name(&self) -> &'static str

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

Compares two values for equality.

Equality comparisons do not convert strings to numbers or vice versa. Tables, Functions, Threads, and Userdata are compared by reference: two objects are considered equal only if they are the same object.

If Tables or Userdata have __eq metamethod then mlua will try to invoke it. The first value is checked first. If that value does not define a metamethod for __eq, then mlua will check the second value. Then mlua calls the metamethod with the two values as arguments, if found.

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

Converts the value to a generic C pointer.

The value can be a userdata, a table, a thread, a string, or a function; otherwise it returns NULL. Different objects 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.

Trait Implementations

impl<'lua> AsRef<Value<'lua>> for Value<'lua>

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

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

impl<'lua> Clone for Value<'lua>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'lua> Debug for Value<'lua>

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

Formats the value using the given formatter.

impl<'lua> FromIterator<Value<'lua>> for MultiValue<'lua>

fn from_iter<I>(iter: I) -> MultiValue<'lua>where
    I: IntoIterator<Item = Value<'lua>>,

Creates a value from an iterator.

impl<'lua> FromLua<'lua> for Value<'lua>

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

Performs the conversion.

impl<'lua> PartialEq<Value<'lua>> for Value<'lua>

fn eq(&self, other: &Value<'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 Value<'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> ToLua<'lua> for Value<'lua>

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

Performs the conversion.