Struct bones_framework::prelude::piccolo::Table

pub struct Table<'gc>(/* private fields */);

Implementations

impl<'gc> Table<'gc>

pub fn new(mc: &Mutation<'gc>) -> Table<'gc>

pub fn from_parts( mc: &Mutation<'gc>, raw_table: RawTable<'gc>, metatable: Option<Table<'gc>>, ) -> Table<'gc>

pub fn from_inner(inner: Gc<'gc, RefLock<TableState<'gc>>>) -> Table<'gc>

pub fn into_inner(self) -> Gc<'gc, RefLock<TableState<'gc>>>

pub fn get<K>(self, ctx: Context<'gc>, key: K) -> Value<'gc>

where K: IntoValue<'gc>,

pub fn set<K, V>( self, ctx: Context<'gc>, key: K, value: V, ) -> Result<Value<'gc>, InvalidTableKey>

where K: IntoValue<'gc>, V: IntoValue<'gc>,

pub fn get_value(self, key: Value<'gc>) -> Value<'gc>

pub fn set_value( self, mc: &Mutation<'gc>, key: Value<'gc>, value: Value<'gc>, ) -> Result<Value<'gc>, InvalidTableKey>

pub fn length(self) -> i64

Returns a ‘border’ for this table.

A ‘border’ for a table is any i >= 0 where: (i == 0 or table[i] ~= nil) and table[i + 1] == nil

If a table has exactly one border, it is called a ‘sequence’, and this border is the table’s length.

pub fn next(self, key: Value<'gc>) -> NextValue<'gc>

Returns the next value after this key in the table order.

The table order in the map portion of the table is defined by the incidental order of the internal bucket list. This order may change whenever the bucket list changes size, such as when inserting into the table, so relying on the order while inserting may result in unspecified (but not unsafe) behavior.

If given Nil, it will return the first pair in the table. If given a key that is present in the table, it will return the next pair in iteration order. If given a key that is not present in the table, the behavior is unspecified.

pub fn iter(self) -> Iter<'gc>

Iterate over the key-value pairs of the table.

Internally uses the Table::next method and thus matches the behavior of Lua.

pub fn metatable(self) -> Option<Table<'gc>>

pub fn set_metatable( self, mc: &Mutation<'gc>, metatable: Option<Table<'gc>>, ) -> Option<Table<'gc>>

Trait Implementations

impl<'gc> Clone for Table<'gc>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'gc> Collect for Table<'gc>

fn needs_trace() -> bool

As an optimization, if this type can never hold a Gc pointer and trace is unnecessary to call, you may implement this method and return false. The default implementation returns true, signaling that Collect::trace must be called.

fn trace(&self, cc: &Collection)

Must call Collect::trace on all held Gc pointers. If this type holds inner types that implement Collect, a valid implementation would simply call Collect::trace on all the held values to ensure this.

impl<'gc> Debug for Table<'gc>

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

Formats the value using the given formatter.

impl<'gc> From<Table<'gc>> for Value<'gc>

fn from(v: Table<'gc>) -> Value<'gc>

Converts to this type from the input type.

impl<'gc> FromValue<'gc> for Table<'gc>

fn from_value( _: Context<'gc>, value: Value<'gc>, ) -> Result<Table<'gc>, TypeError>

impl<'gc> Hash for Table<'gc>

fn hash<H>(&self, state: &mut H)

where H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'gc> IntoIterator for Table<'gc>

type Item = (Value<'gc>, Value<'gc>)

The type of the elements being iterated over.

type IntoIter = Iter<'gc>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <Table<'gc> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'gc> IntoValue<'gc> for &'a Table<'gc>

fn into_value(self, ctx: Context<'gc>) -> Value<'gc>

impl<'gc> IntoValue<'gc> for Table<'gc>

fn into_value(self, _: Context<'gc>) -> Value<'gc>

impl<'gc> PartialEq for Table<'gc>

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

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

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<'gc> Stashable<'gc> for Table<'gc>

type Stashed = StashedTable

fn stash( self, roots: &DynamicRootSet<'gc>, mc: &Mutation<'gc>, ) -> <Table<'gc> as Stashable<'gc>>::Stashed

impl<'gc> Copy for Table<'gc>

impl<'gc> Eq for Table<'gc>