1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
use crate::{LuaState, ffi};
/// Number related functions.
impl LuaState {
/// Returns `true` if the value at the given acceptable `index` is a number, `false` otherwise.
#[inline]
#[must_use]
pub fn is_number(&self, index: i32) -> bool {
// SAFETY: self.0 is always valid.
unsafe { ffi::lua_isnumber(self.0, index) != 0 }
}
/// Converts the value at the given acceptable `index` to a number and returns it.
///
/// Only numbers or strings that can be converted into numbers are accepted. Anything else will return `0.0`.
///
/// This conversion *does not* affect the element in the stack itself (it stays as is).
#[inline]
#[must_use]
pub fn to_number(&self, index: i32) -> f64 {
// SAFETY: self.0 is always valid.
unsafe { ffi::lua_tonumber(self.0, index) }
}
/// Converts the value at the given acceptable `index` to a number and returns it.
///
/// Only numbers or strings that can be converted into numbers are accepted. Anything else will return `None`.
///
/// This conversion *does not* affect the element in the stack itself (it stays as is).
#[inline]
#[must_use]
pub fn to_number_x(&self, index: i32) -> Option<f64> {
// SAFETY: self.0 is always valid and is_num is initialized right before passing its pointer.
let mut is_num = 0;
let number = unsafe { ffi::lua_tonumberx(self.0, index, &raw mut is_num) };
(is_num != 0).then_some(number)
}
/// Converts the value at the given acceptable `index` to an integer and returns it.
///
/// Only numbers or strings that can be converted into numbers are accepted. Anything else will return `0`.
///
/// If the number is not an integer, it will be truncated in an unspecified way.
///
/// This conversion *does not* affect the element in the stack itself (it stays as is).
#[inline]
#[must_use]
pub fn to_integer(&self, index: i32) -> isize {
// SAFETY: self.0 is always valid.
unsafe { ffi::lua_tointeger(self.0, index) }
}
/// Converts the value at the given acceptable `index` to an integer and returns it.
///
/// Only numbers or strings that can be converted into numbers are accepted. Anything else will return `0`.
///
/// If the number is not an integer, it will be truncated in an unspecified way.
///
/// This conversion *does not* affect the element in the stack itself (it stays as is).
#[inline]
#[must_use]
pub fn to_integer_x(&self, index: i32) -> Option<isize> {
// SAFETY: self.0 is always valid.
let mut is_num = 0;
let integer = unsafe { ffi::lua_tointegerx(self.0, index, &raw mut is_num) };
(is_num != 0).then_some(integer)
}
/// Pushes the given `number` onto the stack.
#[inline]
pub fn push_number(&mut self, number: f64) {
// SAFETY: self.0 is always valid.
unsafe { ffi::lua_pushnumber(self.0, number); }
}
/// Pushes the given `integer` onto the stack.
#[inline]
pub fn push_integer(&mut self, integer: isize) {
// SAFETY: self.0 is always valid.
unsafe { ffi::lua_pushinteger(self.0, integer); }
}
/// Checks if there's a number at the given index `arg_n` and returns it.
///
/// If the check fails, `LuaState::type_error` is called using `arg_n`.
///
/// # Lua Errors
///
/// Intentionally errors if the check fails.
#[inline]
pub fn check_number(&self, arg_n: i32) -> f64 {
// SAFETY: self.0 is always valid.
unsafe { ffi::luaL_checknumber(self.0, arg_n) }
}
/// Checks if there's a number at the given index `arg_n` and returns it as an integer.
///
/// If the check fails, `LuaState::type_error` is called using `arg_n`.
///
/// # Lua Errors
///
/// Intentionally errors if the check fails.
#[inline]
pub fn check_integer(&self, arg_n: i32) -> isize {
// SAFETY: self.0 is always valid.
unsafe { ffi::luaL_checkinteger(self.0, arg_n) }
}
/// Behaves exactly as [`LuaState::check_number`],
/// but returns `default` instead of erroring when the element at the given index `arg_n` is `nil` (or non-existing).
#[inline]
pub fn opt_number(&self, arg_n: i32, default: f64) -> f64 {
// SAFETY: self.0 is always valid.
unsafe { ffi::luaL_optnumber(self.0, arg_n, default) }
}
/// Behaves exactly as [`LuaState::check_integer`],
/// but returns `default` instead of erroring when the element at the given index `arg_n` is `nil` (or non-existing).
#[inline]
pub fn opt_integer(&self, arg_n: i32, default: isize) -> isize {
// SAFETY: self.0 is always valid.
unsafe { ffi::luaL_optinteger(self.0, arg_n, default) }
}
}