Trait LuaStateStubExt

Source

pub trait LuaStateStubExt {
Show 175 methods    // Provided methods
    fn push_value(&mut self, idx: i32) -> Result<(), LuaError> { ... }
    fn push_copy(&mut self, idx: i32) -> Result<(), LuaError> { ... }
    fn push_string(&mut self, s: &[u8]) -> Result<(), LuaError> { ... }
    fn push_bytes(&mut self, s: &[u8]) -> Result<(), LuaError> { ... }
    fn push_fstring(&mut self, args: Arguments<'_>) -> Result<(), LuaError> { ... }
    fn push_c_function(&mut self, f: lua_CFunction) -> Result<(), LuaError> { ... }
    fn push_c_closure(
        &mut self,
        f: lua_CFunction,
        n: i32,
    ) -> Result<(), LuaError> { ... }
    fn push_where(&mut self, level: i32) -> Result<(), LuaError> { ... }
    fn push_globals(&mut self) -> Result<(), LuaError> { ... }
    fn pop_bytes(&mut self) -> Vec<u8> ⓘ { ... }
    fn top(&mut self) -> i32 { ... }
    fn top_count(&mut self) -> i32 { ... }
    fn insert(&mut self, idx: i32) -> Result<(), LuaError> { ... }
    fn remove(&mut self, idx: i32) -> Result<(), LuaError> { ... }
    fn replace(&mut self, idx: i32) -> Result<(), LuaError> { ... }
    fn rotate(&mut self, idx: i32, n: i32) -> Result<(), LuaError> { ... }
    fn copy_value(&mut self, from: i32, to: i32) -> Result<(), LuaError> { ... }
    fn abs_index(&mut self, idx: i32) -> i32 { ... }
    fn ensure_stack<S: AsRef<[u8]> + ?Sized>(
        &mut self,
        n: i32,
        msg: &S,
    ) -> Result<(), LuaError> { ... }
    fn check_stack_space(&mut self, n: i32) -> bool { ... }
    fn type_at(&mut self, idx: i32) -> LuaType { ... }
    fn type_name(&mut self, t: LuaType) -> &'static [u8] ⓘ { ... }
    fn type_name_at(&mut self, idx: i32) -> &'static [u8] ⓘ { ... }
    fn value_at(&mut self, idx: i32) -> LuaValue { ... }
    fn is_none_or_nil(&mut self, idx: i32) -> bool { ... }
    fn is_integer(&mut self, idx: i32) -> bool { ... }
    fn is_number(&mut self, idx: i32) -> bool { ... }
    fn to_lua_string(&mut self, idx: i32) -> Option<GcRef<LuaString>> { ... }
    fn to_lua_string_bytes(&mut self, idx: i32) -> Option<Vec<u8>> { ... }
    fn to_lua_string_len(&mut self, idx: i32) -> Option<usize> { ... }
    fn to_integer_x(&mut self, idx: i32) -> Option<i64> { ... }
    fn to_number_x(&mut self, idx: i32) -> Option<f64> { ... }
    fn to_boolean(&mut self, idx: i32) -> bool { ... }
    fn to_userdata(&mut self, idx: i32) -> Option<GcRef<LuaUserData>> { ... }
    fn to_display_string(&mut self, idx: i32) -> Result<Vec<u8>, LuaError> { ... }
    fn check_arg_any(&mut self, arg: i32) -> Result<(), LuaError> { ... }
    fn check_arg_integer(&mut self, arg: i32) -> Result<i64, LuaError> { ... }
    fn check_arg_string(&mut self, arg: i32) -> Result<Vec<u8>, LuaError> { ... }
    fn check_arg_type(&mut self, arg: i32, t: LuaType) -> Result<(), LuaError> { ... }
    fn check_arg_option(
        &mut self,
        arg: i32,
        def: Option<&[u8]>,
        lst: &[&[u8]],
    ) -> Result<usize, LuaError> { ... }
    fn opt_arg_integer(&mut self, arg: i32, def: i64) -> Result<i64, LuaError> { ... }
    fn opt_arg_string_bytes(&mut self, arg: i32) -> Result<Vec<u8>, LuaError> { ... }
    fn opt_arg_string(
        &mut self,
        arg: i32,
        def: &[u8],
    ) -> Result<Vec<u8>, LuaError> { ... }
    fn arg_to_bool(&mut self, arg: i32) -> bool { ... }
    fn get_field(&mut self, idx: i32, k: &[u8]) -> Result<LuaType, LuaError> { ... }
    fn set_field(&mut self, idx: i32, k: &[u8]) -> Result<(), LuaError> { ... }
    fn raw_get(&mut self, idx: i32) -> Result<LuaType, LuaError> { ... }
    fn raw_set(&mut self, idx: i32) -> Result<(), LuaError> { ... }
    fn raw_get_i(&mut self, idx: i32, n: i64) -> Result<LuaType, LuaError> { ... }
    fn raw_set_i(&mut self, idx: i32, n: i64) -> Result<(), LuaError> { ... }
    fn raw_equal(&mut self, idx1: i32, idx2: i32) -> Result<bool, LuaError> { ... }
    fn raw_len(&mut self, idx: i32) -> i64 { ... }
    fn get_i(&mut self, idx: i32, n: i64) -> Result<LuaType, LuaError> { ... }
    fn get_metafield(
        &mut self,
        idx: i32,
        name: &[u8],
    ) -> Result<LuaType, LuaError> { ... }
    fn get_meta_field(
        &mut self,
        idx: i32,
        name: &[u8],
    ) -> Result<bool, LuaError> { ... }
    fn get_metatable(&mut self, idx: i32) -> Result<bool, LuaError> { ... }
    fn set_metatable(&mut self, idx: i32) -> Result<(), LuaError> { ... }
    fn table_next(&mut self, idx: i32) -> Result<bool, LuaError> { ... }
    fn create_table(&mut self, narr: i32, nrec: i32) -> Result<(), LuaError> { ... }
    fn gc_control_simple(&mut self, op: i32) -> Result<i32, LuaError> { ... }
    fn gc_count(&mut self) -> Result<i32, LuaError> { ... }
    fn gc_count_b(&mut self) -> Result<i32, LuaError> { ... }
    fn gc_step(&mut self, data: i32) -> Result<i32, LuaError> { ... }
    fn gc_set_param(&mut self, op: i32, value: i32) -> Result<i32, LuaError> { ... }
    fn gc_is_running(&mut self) -> Result<bool, LuaError> { ... }
    fn gc_gen(
        &mut self,
        minor_mul: i32,
        major_mul: i32,
    ) -> Result<i32, LuaError> { ... }
    fn gc_inc(
        &mut self,
        pause: i32,
        step_mul: i32,
        step_size: i32,
    ) -> Result<i32, LuaError> { ... }
    fn call(&mut self, nargs: i32, nresults: i32) -> Result<(), LuaError> { ... }
    fn call_k(
        &mut self,
        nargs: i32,
        nresults: i32,
        ctx: isize,
        k: Option<fn(&mut LuaState, i32, isize) -> Result<usize, LuaError>>,
    ) -> Result<(), LuaError> { ... }
    fn protected_call(
        &mut self,
        nargs: i32,
        nresults: i32,
        msgh: i32,
    ) -> Result<(), LuaError> { ... }
    fn protected_call_k(
        &mut self,
        nargs: i32,
        nresults: i32,
        msgh: i32,
        ctx: isize,
        k: Option<fn(&mut LuaState, i32, isize) -> Result<usize, LuaError>>,
    ) -> Result<(), LuaError> { ... }
    fn len_op(&mut self, idx: i32) -> Result<(), LuaError> { ... }
    fn arith(&mut self, op: ArithOp) -> Result<(), LuaError> { ... }
    fn load(
        &mut self,
        chunk: &[u8],
        name: &[u8],
        mode: Option<&[u8]>,
    ) -> Result<bool, LuaError> { ... }
    fn load_buffer_ex<M>(
        &mut self,
        buf: &[u8],
        name: &[u8],
        mode: &M,
    ) -> Result<bool, LuaError>
       where M: AsRef<[u8]> + ?Sized { ... }
    fn load_file(&mut self, path: Option<&[u8]>) -> Result<bool, LuaError> { ... }
    fn load_file_ex(
        &mut self,
        path: Option<&[u8]>,
        mode: Option<&[u8]>,
    ) -> Result<bool, LuaError> { ... }
    fn load_with_reader<F, M>(
        &mut self,
        reader: F,
        name: &[u8],
        mode: &M,
    ) -> Result<bool, LuaError>
       where F: FnMut(&mut LuaState) -> Result<Option<Vec<u8>>, LuaError>,
             M: AsRef<[u8]> + ?Sized { ... }
    fn dump_function(&mut self, strip: bool) -> Result<Vec<u8>, LuaError> { ... }
    fn warning(&mut self, msg: &[u8], to_cont: bool) -> Result<(), LuaError> { ... }
    fn write_output(&mut self, msg: &[u8]) -> Result<(), LuaError> { ... }
    fn set_warn_fn(
        &mut self,
        f: Option<lua_CFunction>,
        ud: Option<LuaValue>,
    ) -> Result<(), LuaError> { ... }
    fn set_funcs(
        &mut self,
        funcs: &[(&[u8], lua_CFunction)],
        nup: i32,
    ) -> Result<(), LuaError> { ... }
    fn set_global(&mut self, name: &[u8]) -> Result<(), LuaError> { ... }
    fn set_upvalue(
        &mut self,
        fidx: i32,
        n: i32,
    ) -> Result<Option<Vec<u8>>, LuaError> { ... }
    fn get_info(
        &mut self,
        what: &[u8],
        ar: &mut LuaDebug,
    ) -> Result<(), LuaError> { ... }
    fn get_stack(&mut self, level: i32, ar: &mut LuaDebug) -> bool { ... }
    fn lua_version(&mut self) -> f64 { ... }
    fn string_to_number(&mut self, idx: i32) -> Option<usize> { ... }
    fn string_to_number_push<S: AsRef<[u8]> + ?Sized>(
        &mut self,
        s: &S,
    ) -> Result<usize, LuaError> { ... }
    fn require_lib(
        &mut self,
        name: &[u8],
        openf: lua_CFunction,
        glb: bool,
    ) -> Result<(), LuaError> { ... }
    fn peek_bytes(&mut self, idx: i32) -> Option<Vec<u8>> { ... }
    fn check_number(&mut self, arg: i32) -> Result<f64, LuaError> { ... }
    fn check_integer(&mut self, arg: i32) -> Result<i64, LuaError> { ... }
    fn check_any(&mut self, arg: i32) -> Result<(), LuaError> { ... }
    fn check_arg_number(&mut self, arg: i32) -> Result<f64, LuaError> { ... }
    fn check_arg_userdata(
        &mut self,
        arg: i32,
        name: &[u8],
    ) -> Result<GcRef<LuaUserData>, LuaError> { ... }
    fn check_stack_growth(&mut self, n: i32) -> bool { ... }
    fn opt_integer(&mut self, arg: i32, def: i64) -> Result<i64, LuaError> { ... }
    fn opt_number(&mut self, arg: i32, def: f64) -> Result<f64, LuaError> { ... }
    fn opt_arg_lstring(
        &mut self,
        arg: i32,
        def: Option<&[u8]>,
    ) -> Result<Option<Vec<u8>>, LuaError> { ... }
    fn table_get_i(&mut self, idx: i32, n: i64) -> Result<LuaType, LuaError> { ... }
    fn table_set_i(&mut self, idx: i32, n: i64) -> Result<(), LuaError> { ... }
    fn table_get_i_value(
        &mut self,
        t: &LuaValue,
        n: i64,
    ) -> Result<LuaType, LuaError> { ... }
    fn table_set_i_value(
        &mut self,
        t: &LuaValue,
        n: i64,
    ) -> Result<(), LuaError> { ... }
    fn get_table(&mut self, idx: i32) -> Result<LuaType, LuaError> { ... }
    fn raw_geti(&mut self, idx: i32, n: i64) -> Result<LuaType, LuaError> { ... }
    fn raw_seti(&mut self, idx: i32, n: i64) -> Result<(), LuaError> { ... }
    fn len_at(&mut self, idx: i32) -> i64 { ... }
    fn length_at(&mut self, idx: i32) -> Result<i64, LuaError> { ... }
    fn stack_top(&mut self) -> i32 { ... }
    fn get_top(&mut self) -> i32 { ... }
    fn push_value_at(&mut self, idx: i32) -> Result<(), LuaError> { ... }
    fn push_fail(&mut self) -> Result<(), LuaError> { ... }
    fn push_lstring(&mut self, s: &[u8]) -> Result<(), LuaError> { ... }
    fn push_thread(&mut self) -> Result<bool, LuaError> { ... }
    fn push_cclosure(
        &mut self,
        f: lua_CFunction,
        n: i32,
    ) -> Result<(), LuaError> { ... }
    fn push_upvalue(&mut self, idx: i32) -> Result<(), LuaError> { ... }
    fn push_registry(&mut self) -> Result<(), LuaError> { ... }
    fn to_integer(&mut self, idx: i32) -> Option<i64> { ... }
    fn to_integer_opt(&mut self, idx: i32) -> Option<i64> { ... }
    fn to_number(&mut self, idx: i32) -> Option<f64> { ... }
    fn to_bytes(&mut self, idx: i32) -> Option<Vec<u8>> { ... }
    fn to_bytes_at(&mut self, idx: i32) -> Option<Vec<u8>> { ... }
    fn to_string_coerced(&mut self, idx: i32) -> Option<Vec<u8>> { ... }
    fn to_light_userdata(&mut self, idx: i32) -> Option<*mut c_void> { ... }
    fn to_thread(&mut self, idx: i32) -> Option<GcRef<LuaThread>> { ... }
    fn to_thread_at(&mut self, idx: i32) -> Option<GcRef<LuaThread>> { ... }
    fn type_name_str_at(&mut self, idx: i32) -> &'static [u8] ⓘ { ... }
    fn is_c_function_at(&mut self, idx: i32) -> bool { ... }
    fn compare(
        &mut self,
        idx1: i32,
        idx2: i32,
        op: CompareOp,
    ) -> Result<bool, LuaError> { ... }
    fn compare_lt(&mut self, idx1: i32, idx2: i32) -> Result<bool, LuaError> { ... }
    fn get_field_registry(&mut self, name: &[u8]) -> Result<LuaType, LuaError> { ... }
    fn get_registry_field(&mut self, name: &[u8]) -> Result<LuaType, LuaError> { ... }
    fn get_subtable_registry(&mut self, name: &[u8]) -> Result<bool, LuaError> { ... }
    fn get_or_create_registry_subtable(
        &mut self,
        name: &[u8],
    ) -> Result<bool, LuaError> { ... }
    fn registry_get(&mut self, key: &[u8]) -> Result<LuaType, LuaError> { ... }
    fn registry_set(&mut self, key: &[u8]) -> Result<(), LuaError> { ... }
    fn new_lib<F: Copy>(&mut self, funcs: &[(&[u8], F)]) -> Result<(), LuaError> { ... }
    fn new_lib_table<F: Copy>(
        &mut self,
        funcs: &[(&[u8], F)],
    ) -> Result<(), LuaError> { ... }
    fn new_metatable(&mut self, name: &[u8]) -> Result<bool, LuaError> { ... }
    fn set_metatable_by_name(&mut self, name: &[u8]) -> Result<(), LuaError> { ... }
    fn register_funcs<F: Copy>(
        &mut self,
        funcs: &[(&[u8], F)],
    ) -> Result<(), LuaError> { ... }
    fn register_lib<F: Copy>(
        &mut self,
        name: &[u8],
        funcs: &[(&[u8], F)],
    ) -> Result<(), LuaError> { ... }
    fn set_funcs_with_upvalues<F: Copy>(
        &mut self,
        funcs: &[(&[u8], F)],
        nup: i32,
    ) -> Result<(), LuaError> { ... }
    fn new_userdata_typed(
        &mut self,
        name: &[u8],
        size: usize,
        nuvalue: i32,
    ) -> Result<GcRef<LuaUserData>, LuaError> { ... }
    fn get_iuservalue(&mut self, idx: i32, n: i32) -> Result<LuaType, LuaError> { ... }
    fn set_iuservalue(&mut self, idx: i32, n: i32) -> Result<bool, LuaError> { ... }
    fn test_arg_userdata(
        &mut self,
        arg: i32,
        name: &[u8],
    ) -> Option<GcRef<LuaUserData>> { ... }
    fn get_upvalue(
        &mut self,
        fidx: i32,
        n: i32,
    ) -> Result<Option<Vec<u8>>, LuaError> { ... }
    fn upvalue_id(&mut self, fidx: i32, n: i32) -> Result<*mut c_void, LuaError> { ... }
    fn join_upvalues(
        &mut self,
        fidx1: i32,
        n1: i32,
        fidx2: i32,
        n2: i32,
    ) -> Result<(), LuaError> { ... }
    fn upvalue_index(&mut self, i: i32) -> i32 { ... }
    fn close(&mut self) { ... }
    fn set_hook_full(
        &mut self,
        f: Option<lua_CFunction>,
        mask: u32,
        count: i32,
    ) -> Result<(), LuaError> { ... }
    fn get_local_at(
        &mut self,
        ar: &LuaDebug,
        n: i32,
    ) -> Result<Option<Vec<u8>>, LuaError> { ... }
    fn set_local_at(
        &mut self,
        ar: &LuaDebug,
        n: i32,
    ) -> Result<Option<Vec<u8>>, LuaError> { ... }
    fn get_param_name(
        &mut self,
        fidx: i32,
        n: i32,
    ) -> Result<Option<Vec<u8>>, LuaError> { ... }
    fn get_debug_info(
        &mut self,
        what: &[u8],
        ar: &mut LuaDebug,
    ) -> Result<(), LuaError> { ... }
    fn get_stack_level(&mut self, level: i32, ar: &mut LuaDebug) -> bool { ... }
    fn has_frames(&mut self) -> bool { ... }
    fn lua_traceback(
        &mut self,
        other: &mut LuaState,
        msg: Option<&[u8]>,
        level: i32,
    ) -> Result<(), LuaError> { ... }
    fn get_hook_count(&mut self) -> i32 { ... }
    fn get_hook_mask(&mut self) -> u32 { ... }
    fn hook_is_set(&mut self) -> bool { ... }
    fn hook_is_internal_lua_hook(&mut self) -> bool { ... }
    fn set_c_stack_limit(&mut self, limit: i32) -> Result<i32, LuaError> { ... }
    fn new_thread(
        &mut self,
        initial_body: Option<LuaValue>,
    ) -> Result<GcRef<LuaThread>, LuaError> { ... }
    fn is_same_thread(&mut self, other: &LuaState) -> bool { ... }
    fn thread_status(&mut self) -> LuaStatus { ... }
    fn load_buffer(
        &mut self,
        buf: &[u8],
        name: &[u8],
        mode: Option<&[u8]>,
    ) -> Result<LuaStatus, LuaError> { ... }
    fn where_error(&mut self, level: i32, msg: &[u8]) -> LuaError { ... }
    fn arg(&mut self, n: i32) -> LuaValue { ... }
    fn as_bytes_or_coerce(&mut self, idx: i32) -> Option<Vec<u8>> { ... }
    fn as_bytes(&mut self, idx: i32) -> Option<Vec<u8>> { ... }
}

Expand description

Extension trait wiring every Phase-A stub method onto the canonical LuaState. Bodies are todo!("phase-b-reconcile: …"). When the canonical type already defines a method with the same name, Rust’s inherent-first resolution makes this trait method unreachable (the inherent one wins) — the trait is then only providing the missing methods. Conflicting call-sites whose shape no longer matches the inherent signature are patched in their respective stdlib modules.