Struct StickTable

Source

pub struct StickTable<'lua> { /* private fields */ }

Expand description

The “StickTable” class can be used to access the HAProxy stick tables.

Implementations§

Source §

impl<'lua> StickTable<'lua>

Source

pub fn info(&self) -> Result<Table<'lua>>

Returns stick table attributes as a Lua table.

Source

pub fn lookup(&self, key: &str) -> Result<Table<'lua>>

Returns stick table entry for given key.

Source

pub fn dump(&self, filter: Option<&str>) -> Result<Table<'lua>>

Returns all entries in stick table.

An optional filter can be used to extract entries with specific data values. Filter is a table with valid comparison operators as keys followed by data type name and value pairs. Check out the HAProxy docs for “show table” for more details.

Methods from Deref<Target = Table<'lua>>§

Source

pub fn set<K, V>(&self, key: K, value: V) -> Result<(), Error>
where K: IntoLua<'lua>, V: IntoLua<'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()?;

Source

pub fn get<K, V>(&self, key: K) -> Result<V, Error>
where K: IntoLua<'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);

Source

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

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

This might invoke the __index metamethod.

Source

pub fn push<V>(&self, value: V) -> Result<(), Error>
where V: IntoLua<'lua>,

Appends a value to the back of the table.

This might invoke the __len and __newindex metamethods.

Source

pub fn pop<V>(&self) -> Result<V, Error>
where V: FromLua<'lua>,

Removes the last element from the table and returns it.

This might invoke the __len and __newindex metamethods.

Source

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)?);

Source

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

Sets a key-value pair without invoking metamethods.

Source

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

Gets the value associated to key without invoking metamethods.

Source

pub fn raw_insert<V>(&self, idx: i64, value: V) -> Result<(), Error>
where V: IntoLua<'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.

Source

pub fn raw_push<V>(&self, value: V) -> Result<(), Error>
where V: IntoLua<'lua>,

Appends a value to the back of the table without invoking metamethods.

Source

pub fn raw_pop<V>(&self) -> Result<V, Error>
where V: FromLua<'lua>,

Removes the last element from the table and returns it, without invoking metamethods.

Source

pub fn raw_remove<K>(&self, key: K) -> Result<(), Error>
where K: IntoLua<'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.

Source