Struct tlua::IndexableRW

pub struct IndexableRW<L> { /* private fields */ }

An opaque value on lua stack that can be indexed immutably as well as mutably. Can represent a lua table, a lua table with a __index and __newindex metamethods or other indexable lua value.

Use this type when reading return values from lua functions or getting lua function from tables.

Trait Implementations

impl<L> AsLua for IndexableRW<L> where
    L: AsLua, 

fn as_lua(&self) -> LuaState

fn try_push<T>(
    self,
    v: T
) -> Result<PushGuard<Self>, (<T as PushInto<Self>>::Err, Self)> where
    Self: Sized,
    T: PushInto<Self>, 

Try to push v onto the lua stack.

fn push<T>(self, v: T) -> PushGuard<Self> where
    Self: Sized,
    T: PushInto<Self>,
    <T as PushInto<Self>>::Err: Into<Void>, 

Push v onto the lua stack.

fn try_push_one<T>(
    self,
    v: T
) -> Result<PushGuard<Self>, (<T as PushInto<Self>>::Err, Self)> where
    Self: Sized,
    T: PushOneInto<Self>, 

Try to push v onto the lua stack.

fn push_one<T>(self, v: T) -> PushGuard<Self> where
    Self: Sized,
    T: PushOneInto<Self>,
    <T as PushInto<Self>>::Err: Into<Void>, 

Push v onto the lua stack.

fn push_iter<I>(self, iterator: I) -> Result<PushGuard<Self>, Self> where
    Self: Sized,
    I: Iterator,
    <I as Iterator>::Item: PushInto<LuaState>,
    <<I as Iterator>::Item as PushInto<LuaState>>::Err: Into<Void>, 

Push iterator onto the lua stack as a lua table.

fn try_push_iter<I>(
    self,
    iterator: I
) -> Result<PushGuard<Self>, (PushIterErrorOf<I>, Self)> where
    Self: Sized,
    I: Iterator,
    <I as Iterator>::Item: PushInto<LuaState>, 

Push iterator onto the lua stack as a lua table.

fn read<T>(self) -> Result<T, Self> where
    Self: Sized,
    T: LuaRead<Self>, 

fn read_at<T>(self, index: i32) -> Result<T, Self> where
    Self: Sized,
    T: LuaRead<Self>, 

fn read_at_nz<T>(self, index: NonZeroI32) -> Result<T, Self> where
    Self: Sized,
    T: LuaRead<Self>, 

fn pcall<F, R>(&self, f: F) -> Result<R, LuaError> where
    F: FnOnce(StaticLua) -> R, 

Call a rust function in protected mode. If a lua error is thrown during execution of f the function will return a LuaError.

impl<L> AsRef<Object<L>> for IndexableRW<L>

fn as_ref(&self) -> &Object<L>

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

impl<L: Debug> Debug for IndexableRW<L>

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

Formats the value using the given formatter.

impl<L> From<IndexableRW<L>> for Object<L> where
    L: AsLua, 

fn from(o: IndexableRW<L>) -> Self

Converts to this type from the input type.

impl<L> Index<L> for IndexableRW<L> where
    L: AsLua, 

fn get<'lua, K, R>(&'lua self, key: K) -> Option<R> where
    L: 'lua,
    K: PushOneInto<LuaState>,
    K::Err: Into<Void>,
    R: LuaRead<PushGuard<&'lua L>>, 

Loads a value from the table (or other object using the __index metamethod) given its index.

fn try_get<'lua, K, R>(&'lua self, key: K) -> Result<R, LuaError> where
    L: 'lua,
    K: PushOneInto<LuaState>,
    K::Err: Into<Void>,
    R: LuaRead<PushGuard<&'lua L>>, 

Loads a value from the table (or other object using the __index metamethod) given its index.

fn into_get<K, R>(self, key: K) -> Result<R, Self> where
    Self: AsLua + Sized,
    K: PushOneInto<LuaState>,
    K::Err: Into<Void>,
    R: LuaRead<PushGuard<Self>>, 

Loads a value in the table (or other object using the __index metamethod) given its index, with the result capturing the table by value.

fn try_into_get<K, R>(self, key: K) -> Result<R, (Self, LuaError)> where
    Self: AsLua + Sized,
    K: PushOneInto<LuaState>,
    K::Err: Into<Void>,
    R: LuaRead<PushGuard<Self>>, 

Loads a value in the table (or other object using the __index metamethod) given its index, with the result capturing the table by value.

fn call_method<'lua, A, R>(
    &'lua self,
    name: &str,
    args: A
) -> Result<R, MethodCallError<A::Err>> where
    L: 'lua,
    Self: Push<LuaState>,
    Self::Err: Into<Void>,
    A: PushInto<LuaState>,
    R: LuaRead<PushGuard<Callable<PushGuard<&'lua L>>>>, 

Calls the method called name of the table (or other indexable object) with the provided args.

impl<L> LuaRead<L> for IndexableRW<L> where
    L: AsLua, 

fn lua_read_at_position(lua: L, index: NonZeroI32) -> Result<Self, L>

Reads the data from Lua at a given position.

fn n_values_expected() -> i32

fn lua_read(lua: L) -> Result<Self, L>

Reads the data from Lua.

fn lua_read_at_maybe_zero_position(lua: L, index: i32) -> Result<Self, L>

impl<L> NewIndex<L> for IndexableRW<L> where
    L: AsLua, 

fn set<K, V>(&self, key: K, value: V) where
    K: PushOneInto<LuaState>,
    K::Err: Into<Void>,
    V: PushOneInto<LuaState>,
    V::Err: Into<Void>, 

Inserts or modifies a value of the table (or other object using the __index or __newindex metamethod) given its index.

fn try_set<K, V>(&self, key: K, value: V) -> Result<(), LuaError> where
    K: PushOneInto<LuaState>,
    K::Err: Into<Void>,
    V: PushOneInto<LuaState>,
    V::Err: Into<Void>, 

Inserts or modifies a value of the table (or other object using the __index or __newindex metamethod) given its index.

fn checked_set<K, V>(
    &self,
    key: K,
    value: V
) -> Result<(), CheckedSetError<K::Err, V::Err>> where
    K: PushOneInto<LuaState>,
    V: PushOneInto<LuaState>, 

Inserts or modifies a value of the table (or other object using the __newindex metamethod) given its index.

fn try_checked_set<K, V>(
    &self,
    key: K,
    value: V
) -> Result<(), Result<CheckedSetError<K::Err, V::Err>, LuaError>> where
    K: PushOneInto<LuaState>,
    V: PushOneInto<LuaState>, 

Inserts or modifies a value of the table (or other object using the __newindex metamethod) given its index.

impl<L, T> Push<L> for IndexableRW<T> where
    L: AsLua, 

type Err = Void

Error that can happen when pushing a value.

fn push_to_lua(&self, lua: L) -> PushResult<L, Self>

Pushes the value on the top of the stack.

fn push_no_err(&self, lua: L) -> PushGuard<L> where
    <Self as Push<L>>::Err: Into<Void>, 

Same as push_to_lua but can only succeed and is only available if Err implements Into<Void>.

impl<L> TryFrom<Object<L>> for IndexableRW<L> where
    L: AsLua, 

type Error = Object<L>

The type returned in the event of a conversion error.

fn try_from(o: Object<L>) -> Result<Self, Self::Error>

Performs the conversion.

impl<L, T> PushOne<L> for IndexableRW<T> where
    L: AsLua,