Struct ValRef 

pub struct ValRef<'a> { /* private fields */ }

Value reference on the lua stack

Implementations

impl<'a> ValRef<'a>

pub fn deserialize<T: Deserialize<'a>>(&'a self) -> Result<T, DesErr>

Deserialize a lua value

pub fn transcode<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>

Transcode a lua value to another serialize format

impl<'a> ValRef<'a>

pub fn state(&self) -> &'a State

pub fn type_of(&self) -> Type

Type of this value

pub fn is_nil(&self) -> bool

pub fn is_integer(&self) -> bool

pub fn is_table(&self) -> bool

pub fn is_function(&self) -> bool

pub fn check_safe_index(&self) -> Result<()>

pub fn to_safe_bytes(&self) -> Result<&'a [u8]>

pub fn to_safe_str(&self) -> Result<&'a str>

pub fn to_bytes(&self) -> Option<&[u8]>

pub fn to_str(&self) -> Option<&str>

pub fn to_string_lossy(&self) -> Option<Cow<'_, str>>

pub fn to_bool(&self) -> bool

pub fn to_integer(&self) -> lua_Integer

pub fn to_number(&self) -> lua_Number

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

pub fn to_cstr_ptr(&self) -> *const c_char

pub fn tostring(&self) -> Cow<'_, str>

Call tostring if this value is not a string

pub fn index(&self) -> Index

Index number of this value on the lua stack

pub fn check_type(&self, ty: Type) -> Result<()>

pub fn check_type2(&self, ty1: Type, ty2: Type) -> Result<()>

pub fn cast_into<T: FromLua<'a> + 'a>(self) -> Result<T>

Cast a lua value to its rust type, wrapper of FromLua::from_lua

See FromLua

pub fn cast<T: FromLua<'a> + 'static>(&self) -> Result<T>

Alias to cast_into(), not take the ownship, but only convert to static-lifetime types

pub fn geti(&self, i: impl Into<lua_Integer>) -> Result<ValRef<'a>>

Get value associated to integer key, equivalent to return self[i] in lua

pub fn seti<V: ToLua>(&self, i: impl Into<lua_Integer>, v: V) -> Result<()>

Set value with integer key, equivalent to self[i] = v in lua

pub fn len(&self) -> Result<ValRef<'a>>

Get length of the value, equivalent to return #self in lua

pub fn set<K: ToLua, V: ToLua>(&self, k: K, v: V) -> Result<()>

Set value with any key, equivalent to self[k] = v in lua

pub fn get<K: ToLua>(&self, key: K) -> Result<ValRef<'a>>

Get value associated to key, equivalent to return self[k] in lua

pub fn getopt<K: ToLua, V: FromLua<'a> + 'a>(&self, k: K) -> Result<Option<V>>

pub fn pcall<T: ToLuaMulti, R: FromLuaMulti<'a>>(&self, args: T) -> Result<R>

Call this value as a function

pub fn pcall_void<T: ToLuaMulti>(&self, args: T) -> Result<()>

Invoke pcall() without return value

pub fn has_metatable(&self) -> bool

pub fn metatable(&self) -> Result<Option<Table<'a>>>

Get metatable of lua table or userdata

pub fn set_metatable(&self, t: Table<'_>) -> Result<()>

Set metatable for lua table or userdata

pub fn remove_metatable(&self)

Remove metatable for lua table or userdata

pub fn call_metamethod<T: ToLuaMulti, R: FromLuaMulti<'a>>( &self, m: &str, args: T, ) -> Result<R>

Call a metamethod

pub fn close_and_remove_metatable(self) -> Result<()>

Close this value, if userdata, the subsequent access to it in lua is invalid

pub fn call_close_and_remove_metatable(&self) -> Result<()>

pub fn raw_equal(&self, other: &Self) -> bool

Tests whether two lua values are equal without metamethod triggers

pub fn raw_len(&self) -> usize

Get length of the string/userdata/table without metamethod triggers

pub fn checked_into_value(self) -> Option<Value<'a>>

pub fn into_registry_value(self) -> Result<RegVal>

pub fn into_value(self) -> Value<'a>

pub fn check_valid(self) -> Option<Self>

Return Some(self) if type is neither Type::Invalid nor Type::None

impl<'a> ValRef<'a>

pub fn as_table(&self) -> Option<&Table<'a>>

impl<'a> ValRef<'a>

pub fn as_function(&self) -> Option<&Function<'a>>

impl<'a> ValRef<'a>

pub fn as_string(&self) -> Option<&LuaString<'a>>

impl<'a> ValRef<'a>

pub fn as_thread(&self) -> Option<&LuaThread<'a>>

impl<'a> ValRef<'a>

pub fn as_userdata(&self) -> Option<&LuaUserData<'a>>

impl ValRef<'_>

pub fn airth_add(&self, rhs: impl ToLua) -> Result<Self>

pub fn airth_sub(&self, rhs: impl ToLua) -> Result<Self>

pub fn airth_mul(&self, rhs: impl ToLua) -> Result<Self>

pub fn airth_div(&self, rhs: impl ToLua) -> Result<Self>

pub fn airth_rem(&self, rhs: impl ToLua) -> Result<Self>

pub fn airth_bitand(&self, rhs: impl ToLua) -> Result<Self>

pub fn airth_bitor(&self, rhs: impl ToLua) -> Result<Self>

pub fn airth_bitxor(&self, rhs: impl ToLua) -> Result<Self>

pub fn airth_shl(&self, rhs: impl ToLua) -> Result<Self>

pub fn airth_shr(&self, rhs: impl ToLua) -> Result<Self>

pub fn arith_neg(&self) -> Result<Self>

pub fn arith_not(&self) -> Result<Self>

pub fn idiv(&self, rhs: impl ToLua) -> Result<Self>

pub fn pow(&self, rhs: impl ToLua) -> Result<Self>

Trait Implementations

impl<'l, T: ToLua> Add<T> for &ValRef<'l>

type Output = Result<ValRef<'l>, Error>

The resulting type after applying the + operator.

fn add(self, rhs: T) -> Self::Output

Performs the + operation.

impl<'l, T: ToLua> Add<T> for ValRef<'l>

type Output = Result<ValRef<'l>, Error>

The resulting type after applying the + operator.

fn add(self, rhs: T) -> Self::Output

Performs the + operation.

impl<'l, T: ToLua> BitAnd<T> for &ValRef<'l>

type Output = Result<ValRef<'l>, Error>

The resulting type after applying the & operator.

fn bitand(self, rhs: T) -> Self::Output

Performs the & operation.

impl<'l, T: ToLua> BitAnd<T> for ValRef<'l>

type Output = Result<ValRef<'l>, Error>

The resulting type after applying the & operator.

fn bitand(self, rhs: T) -> Self::Output

Performs the & operation.

impl<'l, T: ToLua> BitOr<T> for &ValRef<'l>

type Output = Result<ValRef<'l>, Error>

The resulting type after applying the | operator.

fn bitor(self, rhs: T) -> Self::Output

Performs the | operation.

impl<'l, T: ToLua> BitOr<T> for ValRef<'l>

type Output = Result<ValRef<'l>, Error>

The resulting type after applying the | operator.

fn bitor(self, rhs: T) -> Self::Output

Performs the | operation.

impl<'l, T: ToLua> BitXor<T> for &ValRef<'l>

type Output = Result<ValRef<'l>, Error>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: T) -> Self::Output

Performs the ^ operation.

impl<'l, T: ToLua> BitXor<T> for ValRef<'l>

type Output = Result<ValRef<'l>, Error>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: T) -> Self::Output

Performs the ^ operation.

impl Clone for ValRef<'_>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for ValRef<'a>

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

Formats the value using the given formatter.

impl<'de> Deserializer<'de> for &'de ValRef<'_>

fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>

where V: Visitor<'de>,

Require the Deserializer to figure out how to drive the visitor based on what data type is in the input.

When implementing Deserialize, you should avoid relying on Deserializer::deserialize_any unless you need to be told by the Deserializer what type is in the input. Know that relying on Deserializer::deserialize_any means your data type will be able to deserialize from self-describing formats only, ruling out Bincode and many others.

fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Self::Error>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a bool value.

fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value, Self::Error>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting an i8 value.

fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value, Self::Error>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting an i16 value.

fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value, Self::Error>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting an i32 value.

fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value, Self::Error>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting an i64 value.

fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value, Self::Error>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a u8 value.

fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value, Self::Error>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a u16 value.

fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value, Self::Error>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a u32 value.

fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value, Self::Error>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a u64 value.

fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value, Self::Error>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a f32 value.

fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value, Self::Error>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a f64 value.

fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Self::Error>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a char value.

fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::Error>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a string value and does not benefit from taking ownership of buffered data owned by the Deserializer.

If the Visitor would benefit from taking ownership of String data, indiciate this to the Deserializer by using deserialize_string instead.

fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Self::Error>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a string value and would benefit from taking ownership of buffered data owned by the Deserializer.

If the Visitor would not benefit from taking ownership of String data, indicate that to the Deserializer by using deserialize_str instead.

fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Self::Error>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a byte array and does not benefit from taking ownership of buffered data owned by the Deserializer.

If the Visitor would benefit from taking ownership of Vec<u8> data, indicate this to the Deserializer by using deserialize_byte_buf instead.

fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Self::Error>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a byte array and would benefit from taking ownership of buffered data owned by the Deserializer.

If the Visitor would not benefit from taking ownership of Vec<u8> data, indicate that to the Deserializer by using deserialize_bytes instead.

fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting an optional value.

This allows deserializers that encode an optional value as a nullable value to convert the null value into None and a regular value into Some(value).

fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a unit value.

fn deserialize_unit_struct<V>( self, name: &'static str, visitor: V, ) -> Result<V::Value, Self::Error>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a unit struct with a particular name.

fn deserialize_newtype_struct<V>( self, name: &'static str, visitor: V, ) -> Result<V::Value, Self::Error>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a newtype struct with a particular name.

fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a sequence of values.

fn deserialize_tuple<V>( self, len: usize, visitor: V, ) -> Result<V::Value, Self::Error>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a sequence of values and knows how many values there are without looking at the serialized data.

fn deserialize_tuple_struct<V>( self, name: &'static str, len: usize, visitor: V, ) -> Result<V::Value, Self::Error>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a tuple struct with a particular name and number of fields.

fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a map of key-value pairs.

fn deserialize_struct<V>( self, name: &'static str, fields: &'static [&'static str], visitor: V, ) -> Result<V::Value, Self::Error>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a struct with a particular name and fields.

fn deserialize_enum<V>( self, name: &'static str, variants: &'static [&'static str], visitor: V, ) -> Result<V::Value, Self::Error>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting an enum value with a particular name and possible variants.

fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Self::Error>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting the name of a struct field or the discriminant of an enum variant.

fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>

where V: Visitor<'de>,

Hint that the Deserialize type needs to deserialize a value whose type doesn’t matter because it is ignored.

Deserializers for non-self-describing formats may not support this mode.

type Error = DesErr

The error type that can be returned if some error occurs during deserialization.

fn deserialize_i128<V>( self, visitor: V, ) -> Result<<V as Visitor<'de>>::Value, Self::Error>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting an i128 value.

fn deserialize_u128<V>( self, visitor: V, ) -> Result<<V as Visitor<'de>>::Value, Self::Error>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting an u128 value.

fn is_human_readable(&self) -> bool

Determine whether Deserialize implementations should expect to deserialize their human-readable form.

impl<'l, T: ToLua> Div<T> for &ValRef<'l>

type Output = Result<ValRef<'l>, Error>

The resulting type after applying the / operator.

fn div(self, rhs: T) -> Self::Output

Performs the / operation.

impl<'l, T: ToLua> Div<T> for ValRef<'l>

type Output = Result<ValRef<'l>, Error>

The resulting type after applying the / operator.

fn div(self, rhs: T) -> Self::Output

Performs the / operation.

impl Drop for ValRef<'_>

fn drop(&mut self)

Executes the destructor for this type.

impl<'a> FromLua<'a> for ValRef<'a>

fn from_lua(s: &'a State, val: ValRef<'a>) -> Result<Self>

const TYPE_NAME: &'static str = _

impl<'a> Into<ValRef<'a>> for Function<'a>

fn into(self) -> ValRef<'a>

Converts this type into the (usually inferred) input type.

impl<'a> Into<ValRef<'a>> for LuaString<'a>

fn into(self) -> ValRef<'a>

Converts this type into the (usually inferred) input type.

impl<'a> Into<ValRef<'a>> for LuaThread<'a>

fn into(self) -> ValRef<'a>

Converts this type into the (usually inferred) input type.

impl<'a> Into<ValRef<'a>> for LuaUserData<'a>

fn into(self) -> ValRef<'a>

Converts this type into the (usually inferred) input type.

impl<'a> Into<ValRef<'a>> for Table<'a>

fn into(self) -> ValRef<'a>

Converts this type into the (usually inferred) input type.

impl<'l, T: ToLua> Mul<T> for &ValRef<'l>

type Output = Result<ValRef<'l>, Error>

The resulting type after applying the * operator.

fn mul(self, rhs: T) -> Self::Output

Performs the * operation.

impl<'l, T: ToLua> Mul<T> for ValRef<'l>

type Output = Result<ValRef<'l>, Error>

The resulting type after applying the * operator.

fn mul(self, rhs: T) -> Self::Output

Performs the * operation.

impl<'l> Neg for &ValRef<'l>

type Output = Result<ValRef<'l>, Error>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<'l> Neg for ValRef<'l>

type Output = Result<ValRef<'l>, Error>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<'l> Not for &ValRef<'l>

type Output = Result<ValRef<'l>, Error>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<'l> Not for ValRef<'l>

type Output = Result<ValRef<'l>, Error>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl PartialEq for ValRef<'_>

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl<'l, T: ToLua> Rem<T> for &ValRef<'l>

type Output = Result<ValRef<'l>, Error>

The resulting type after applying the % operator.

fn rem(self, rhs: T) -> Self::Output

Performs the % operation.

impl<'l, T: ToLua> Rem<T> for ValRef<'l>

type Output = Result<ValRef<'l>, Error>

The resulting type after applying the % operator.

fn rem(self, rhs: T) -> Self::Output

Performs the % operation.

impl Serialize for ValRef<'_>

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

Serialize this value into the given Serde serializer.

impl<'l, T: ToLua> Shl<T> for &ValRef<'l>

type Output = Result<ValRef<'l>, Error>

The resulting type after applying the << operator.

fn shl(self, rhs: T) -> Self::Output

Performs the << operation.

impl<'l, T: ToLua> Shl<T> for ValRef<'l>

type Output = Result<ValRef<'l>, Error>

The resulting type after applying the << operator.

fn shl(self, rhs: T) -> Self::Output

Performs the << operation.

impl<'l, T: ToLua> Shr<T> for &ValRef<'l>

type Output = Result<ValRef<'l>, Error>

The resulting type after applying the >> operator.

fn shr(self, rhs: T) -> Self::Output

Performs the >> operation.

impl<'l, T: ToLua> Shr<T> for ValRef<'l>

type Output = Result<ValRef<'l>, Error>

The resulting type after applying the >> operator.

fn shr(self, rhs: T) -> Self::Output

Performs the >> operation.

impl<'l, T: ToLua> Sub<T> for &ValRef<'l>

type Output = Result<ValRef<'l>, Error>

The resulting type after applying the - operator.

fn sub(self, rhs: T) -> Self::Output

Performs the - operation.

impl<'l, T: ToLua> Sub<T> for ValRef<'l>

type Output = Result<ValRef<'l>, Error>

The resulting type after applying the - operator.

fn sub(self, rhs: T) -> Self::Output

Performs the - operation.

impl ToLua for &ValRef<'_>

fn to_lua<'a>(self, lua: &'a State) -> Result<ValRef<'a>>

impl ToLua for ValRef<'_>

fn to_lua<'a>(self, lua: &'a State) -> Result<ValRef<'a>>

impl<'a> TryFrom<ValRef<'a>> for Function<'a>

type Error = Error

The type returned in the event of a conversion error.

fn try_from(val: ValRef<'a>) -> Result<Self>

Performs the conversion.

impl<'a> TryFrom<ValRef<'a>> for LuaString<'a>

type Error = Error

The type returned in the event of a conversion error.

fn try_from(val: ValRef<'a>) -> Result<Self>

Performs the conversion.

impl<'a> TryFrom<ValRef<'a>> for LuaThread<'a>

type Error = Error

The type returned in the event of a conversion error.

fn try_from(val: ValRef<'a>) -> Result<Self>

Performs the conversion.

impl<'a> TryFrom<ValRef<'a>> for LuaUserData<'a>

type Error = Error

The type returned in the event of a conversion error.

fn try_from(val: ValRef<'a>) -> Result<Self>

Performs the conversion.

impl<'a> TryFrom<ValRef<'a>> for Table<'a>

type Error = Error

The type returned in the event of a conversion error.

fn try_from(val: ValRef<'a>) -> Result<Self>

Performs the conversion.