mlua_extras/typed/class/
wrapped.rs

1use mlua::{AnyUserData, FromLua, FromLuaMulti, IntoLua, IntoLuaMulti, Lua, MetaMethod, UserData, UserDataFields, UserDataMethods};
2
3use crate::{typed::generator::FunctionBuilder, MaybeSend};
4
5use super::{Typed, TypedDataFields, TypedDataMethods, TypedMultiValue};
6
7/// Wrapper around a [`UserDataFields`] and [`UserDataMethods`]
8/// to allow [`TypedUserData`] implementations to be used for [`UserData`]
9/// implementations
10pub struct WrappedBuilder<'ctx, U>(&'ctx mut U);
11impl<'ctx, U> WrappedBuilder<'ctx, U> {
12    pub fn new(u: &'ctx mut U) -> Self {
13        WrappedBuilder(u)
14    }
15}
16
17impl<'lua, 'ctx, T: UserData, U: UserDataFields<'lua, T>> TypedDataFields<'lua, T>
18    for WrappedBuilder<'ctx, U>
19{
20    fn document(&mut self, _doc: &str) -> &mut Self {
21        self
22    }
23
24    fn add_field<V>(&mut self, name: impl AsRef<str>, value: V)
25    where
26        V: IntoLua<'lua> + Clone + 'static + Typed,
27    {
28        self.0.add_field(name, value)
29    }
30
31    fn add_field_function_set<S, A, F>(&mut self, name: &S, function: F)
32    where
33        S: AsRef<str> + ?Sized,
34        A: FromLua<'lua> + Typed,
35        F: 'static + MaybeSend + FnMut(&'lua Lua, AnyUserData<'lua>, A) -> mlua::Result<()>,
36    {
37        self.0.add_field_function_set(name, function)
38    }
39
40    fn add_field_function_get<S, R, F>(&mut self, name: &S, function: F)
41    where
42        S: AsRef<str> + ?Sized,
43        R: IntoLua<'lua> + Typed,
44        F: 'static + MaybeSend + Fn(&'lua Lua, AnyUserData<'lua>) -> mlua::Result<R>,
45    {
46        self.0.add_field_function_get(name, function)
47    }
48
49    fn add_field_function_get_set<S, R, A, GET, SET>(&mut self, name: &S, get: GET, set: SET)
50    where
51        S: AsRef<str> + ?Sized,
52        R: IntoLua<'lua> + Typed,
53        A: FromLua<'lua> + Typed,
54        GET: 'static + MaybeSend + Fn(&'lua Lua, AnyUserData<'lua>) -> mlua::Result<R>,
55        SET: 'static + MaybeSend + Fn(&'lua Lua, AnyUserData<'lua>, A) -> mlua::Result<()>,
56    {
57        self.0.add_field_function_get(name, get);
58        self.0.add_field_function_set(name, set);
59    }
60
61    fn add_field_method_set<S, A, M>(&mut self, name: &S, method: M)
62    where
63        S: AsRef<str> + ?Sized,
64        A: FromLua<'lua> + Typed,
65        M: 'static + MaybeSend + FnMut(&'lua Lua, &mut T, A) -> mlua::Result<()>,
66    {
67        self.0.add_field_method_set(name, method)
68    }
69
70    fn add_field_method_get<S, R, M>(&mut self, name: &S, method: M)
71    where
72        S: AsRef<str> + ?Sized,
73        R: IntoLua<'lua> + Typed,
74        M: 'static + MaybeSend + Fn(&'lua Lua, &T) -> mlua::Result<R>,
75    {
76        self.0.add_field_method_get(name, method)
77    }
78
79    fn add_field_method_get_set<S, R, A, GET, SET>(&mut self, name: &S, get: GET, set: SET)
80    where
81        S: AsRef<str> + ?Sized,
82        R: IntoLua<'lua> + Typed,
83        A: FromLua<'lua> + Typed,
84        GET: 'static + MaybeSend + Fn(&'lua Lua, &T) -> mlua::Result<R>,
85        SET: 'static + MaybeSend + Fn(&'lua Lua, &mut T, A) -> mlua::Result<()>,
86    {
87        self.0.add_field_method_get(name, get);
88        self.0.add_field_method_set(name, set);
89    }
90
91    fn add_meta_field<R, F>(&mut self, meta: MetaMethod, f: F)
92    where
93        F: 'static + MaybeSend + Fn(&'lua Lua) -> mlua::Result<R>,
94        R: IntoLua<'lua>,
95    {
96        self.0.add_meta_field_with(meta, f)
97    }
98}
99
100impl<'lua, 'ctx, T: UserData, U: UserDataMethods<'lua, T>> TypedDataMethods<'lua, T>
101    for WrappedBuilder<'ctx, U>
102{
103    fn document(&mut self, _documentation: &str) -> &mut Self {
104        self
105    }
106
107    fn add_method<S, A, R, M>(&mut self, name: &S, method: M)
108    where
109        S: ?Sized + AsRef<str>,
110        A: FromLuaMulti<'lua> + TypedMultiValue,
111        R: IntoLuaMulti<'lua> + TypedMultiValue,
112        M: 'static + MaybeSend + Fn(&'lua Lua, &T, A) -> mlua::Result<R>,
113    {
114        self.0.add_method(name, method)
115    }
116
117    fn add_method_with<S, A, R, M, G>(&mut self, name: &S, method: M, _generator: G)
118        where
119            S: ?Sized + AsRef<str>,
120            A: FromLuaMulti<'lua> + TypedMultiValue,
121            R: IntoLuaMulti<'lua> + TypedMultiValue,
122            M: 'static + MaybeSend + Fn(&'lua Lua, &T, A) -> mlua::Result<R>,
123            G: Fn(&mut FunctionBuilder<A, R>) {
124        self.0.add_method(name, method)
125    }
126
127    fn add_function<S, A, R, F>(&mut self, name: &S, function: F)
128    where
129        S: ?Sized + AsRef<str>,
130        A: FromLuaMulti<'lua> + TypedMultiValue,
131        R: IntoLuaMulti<'lua> + TypedMultiValue,
132        F: 'static + MaybeSend + Fn(&'lua Lua, A) -> mlua::Result<R>,
133    {
134        self.0.add_function(name, function)
135    }
136
137    fn add_function_with<S, A, R, F, G>(&mut self, name: &S, function: F, _generator: G)
138        where
139            S: ?Sized + AsRef<str>,
140            A: FromLuaMulti<'lua> + TypedMultiValue,
141            R: IntoLuaMulti<'lua> + TypedMultiValue,
142            F: 'static + MaybeSend + Fn(&'lua Lua, A) -> mlua::Result<R>,
143            G: Fn(&mut FunctionBuilder<A, R>) {
144        self.0.add_function(name, function)
145    }
146
147    fn add_method_mut<S, A, R, M>(&mut self, name: &S, method: M)
148    where
149        S: ?Sized + AsRef<str>,
150        A: FromLuaMulti<'lua> + TypedMultiValue,
151        R: IntoLuaMulti<'lua> + TypedMultiValue,
152        M: 'static + MaybeSend + FnMut(&'lua Lua, &mut T, A) -> mlua::Result<R>,
153    {
154        self.0.add_method_mut(name, method)
155    }
156
157    fn add_method_mut_with<S, A, R, M, G>(&mut self, name: &S, method: M, _generator: G)
158        where
159            S: ?Sized + AsRef<str>,
160            A: FromLuaMulti<'lua> + TypedMultiValue,
161            R: IntoLuaMulti<'lua> + TypedMultiValue,
162            M: 'static + MaybeSend + FnMut(&'lua Lua, &mut T, A) -> mlua::Result<R>,
163            G: Fn(&mut FunctionBuilder<A, R>) {
164        self.0.add_method_mut(name, method)
165    }
166
167    fn add_meta_method<A, R, M>(&mut self, meta: MetaMethod, method: M)
168    where
169        A: FromLuaMulti<'lua> + TypedMultiValue,
170        R: IntoLuaMulti<'lua> + TypedMultiValue,
171        M: 'static + MaybeSend + Fn(&'lua Lua, &T, A) -> mlua::Result<R>,
172    {
173        self.0.add_meta_method(meta, method)
174    }
175
176    fn add_meta_method_with<A, R, M, G>(&mut self, meta: MetaMethod, method: M, _generator: G)
177        where
178            A: FromLuaMulti<'lua> + TypedMultiValue,
179            R: IntoLuaMulti<'lua> + TypedMultiValue,
180            M: 'static + MaybeSend + Fn(&'lua Lua, &T, A) -> mlua::Result<R>,
181            G: Fn(&mut FunctionBuilder<A, R>) {
182        self.0.add_meta_method(meta, method)
183    }
184
185    #[cfg(feature = "async")]
186    fn add_async_method<'s, S: ?Sized + AsRef<str>, A, R, M, MR>(&mut self, name: &S, method: M)
187    where
188        'lua: 's,
189        T: 'static,
190        M: Fn(&'lua Lua, &'s T, A) -> MR + MaybeSend + 'static,
191        A: FromLuaMulti<'lua> + TypedMultiValue,
192        MR: std::future::Future<Output = mlua::Result<R>> + 's,
193        R: IntoLuaMulti<'lua>,
194    {
195        self.0.add_async_method(name, method)
196    }
197
198    #[cfg(feature = "async")]
199    fn add_async_method_with<'s, S: ?Sized + AsRef<str>, A, R, M, MR, G>(&mut self, name: &S, method: M, _generator: G)
200        where
201            'lua: 's,
202            T: 'static,
203            M: Fn(&'lua Lua, &'s T, A) -> MR + MaybeSend + 'static,
204            A: FromLuaMulti<'lua> + TypedMultiValue,
205            MR: std::future::Future<Output = mlua::Result<R>> + 's,
206            R: IntoLuaMulti<'lua> + TypedMultiValue,
207            G: Fn(&mut FunctionBuilder<A, R>) {
208        self.0.add_async_method(name, method)
209    }
210
211    #[cfg(feature = "async")]
212    fn add_async_method_mut<'s, S: ?Sized + AsRef<str>, A, R, M, MR>(&mut self, name: &S, method: M)
213    where
214        'lua: 's,
215        T: 'static,
216        M: Fn(&'lua Lua, &'s mut T, A) -> MR + MaybeSend + 'static,
217        A: FromLuaMulti<'lua> + TypedMultiValue,
218        MR: std::future::Future<Output = mlua::Result<R>> + 's,
219        R: IntoLuaMulti<'lua>,
220    {
221        self.0.add_async_method_mut(name, method)
222    }
223
224    #[cfg(feature = "async")]
225    fn add_async_method_mut_with<'s, S: ?Sized + AsRef<str>, A, R, M, MR, G>(&mut self, name: &S, method: M, _generator: G)
226        where
227            'lua: 's,
228            T: 'static,
229            M: Fn(&'lua Lua, &'s mut T, A) -> MR + MaybeSend + 'static,
230            A: FromLuaMulti<'lua> + TypedMultiValue,
231            MR: std::future::Future<Output = mlua::Result<R>> + 's,
232            R: IntoLuaMulti<'lua> + TypedMultiValue,
233            G: Fn(&mut FunctionBuilder<A, R>) {
234        self.0.add_async_method_mut(name, method)
235    }
236
237    fn add_function_mut<S, A, R, F>(&mut self, name: &S, function: F)
238    where
239        S: ?Sized + AsRef<str>,
240        A: FromLuaMulti<'lua> + TypedMultiValue,
241        R: IntoLuaMulti<'lua> + TypedMultiValue,
242        F: 'static + MaybeSend + FnMut(&'lua Lua, A) -> mlua::Result<R>,
243    {
244        self.0.add_function_mut(name, function)
245    }
246
247    fn add_function_mut_with<S, A, R, F, G>(&mut self, name: &S, function: F, _generator: G)
248        where
249            S: ?Sized + AsRef<str>,
250            A: FromLuaMulti<'lua> + TypedMultiValue,
251            R: IntoLuaMulti<'lua> + TypedMultiValue,
252            F: 'static + MaybeSend + FnMut(&'lua Lua, A) -> mlua::Result<R>,
253            G: Fn(&mut FunctionBuilder<A, R>) {
254        self.0.add_function_mut(name, function)
255    }
256
257    fn add_meta_function<A, R, F>(&mut self, meta: MetaMethod, function: F)
258    where
259        A: FromLuaMulti<'lua> + TypedMultiValue,
260        R: IntoLuaMulti<'lua> + TypedMultiValue,
261        F: 'static + MaybeSend + Fn(&'lua Lua, A) -> mlua::Result<R>,
262    {
263        self.0.add_meta_function(meta, function)
264    }
265
266    fn add_meta_function_with<A, R, F, G>(&mut self, meta: MetaMethod, function: F, _generator: G)
267        where
268            A: FromLuaMulti<'lua> + TypedMultiValue,
269            R: IntoLuaMulti<'lua> + TypedMultiValue,
270            F: 'static + MaybeSend + Fn(&'lua Lua, A) -> mlua::Result<R>,
271            G: Fn(&mut FunctionBuilder<A, R>) {
272        self.0.add_meta_function(meta, function)
273    }
274
275    #[cfg(feature = "async")]
276    fn add_async_function<S: ?Sized, A, R, F, FR>(&mut self, name: &S, function: F)
277    where
278        S: AsRef<str>,
279        A: FromLuaMulti<'lua> + TypedMultiValue,
280        R: IntoLuaMulti<'lua> + TypedMultiValue,
281        F: 'static + MaybeSend + Fn(&'lua Lua, A) -> FR,
282        FR: 'lua + std::future::Future<Output = mlua::Result<R>>,
283    {
284        self.0.add_async_function(name, function)
285    }
286
287    #[cfg(feature = "async")]
288    fn add_async_function_with<S: ?Sized, A, R, F, FR, G>(&mut self, name: &S, function: F, _generator: G)
289        where
290            S: AsRef<str>,
291            A: FromLuaMulti<'lua> + TypedMultiValue,
292            R: IntoLuaMulti<'lua> + TypedMultiValue,
293            F: 'static + MaybeSend + Fn(&'lua Lua, A) -> FR,
294            FR: 'lua + std::future::Future<Output = mlua::Result<R>>,
295            G: Fn(&mut FunctionBuilder<A, R>) {
296        self.0.add_async_function(name, function)
297    }
298
299    fn add_meta_method_mut<A, R, M>(&mut self, meta: MetaMethod, method: M)
300    where
301        A: FromLuaMulti<'lua> + TypedMultiValue,
302        R: IntoLuaMulti<'lua> + TypedMultiValue,
303        M: 'static + MaybeSend + FnMut(&'lua Lua, &mut T, A) -> mlua::Result<R>,
304    {
305        self.0.add_meta_method_mut(meta, method)
306    }
307
308    fn add_meta_method_mut_with<A, R, M, G>(&mut self, meta: MetaMethod, method: M, _generator: G)
309        where
310            A: FromLuaMulti<'lua> + TypedMultiValue,
311            R: IntoLuaMulti<'lua> + TypedMultiValue,
312            M: 'static + MaybeSend + FnMut(&'lua Lua, &mut T, A) -> mlua::Result<R>,
313            G: Fn(&mut FunctionBuilder<A, R>) {
314        self.0.add_meta_method_mut(meta, method)
315    }
316
317    fn add_meta_function_mut<A, R, F>(&mut self, meta: MetaMethod, function: F)
318    where
319        A: FromLuaMulti<'lua> + TypedMultiValue,
320        R: IntoLuaMulti<'lua> + TypedMultiValue,
321        F: 'static + MaybeSend + FnMut(&'lua Lua, A) -> mlua::Result<R>,
322    {
323        self.0.add_meta_function_mut(meta, function)
324    }
325
326    fn add_meta_function_mut_with<A, R, F, G>(&mut self, meta: MetaMethod, function: F, _generator: G)
327        where
328            A: FromLuaMulti<'lua> + TypedMultiValue,
329            R: IntoLuaMulti<'lua> + TypedMultiValue,
330            F: 'static + MaybeSend + FnMut(&'lua Lua, A) -> mlua::Result<R>,
331            G: Fn(&mut FunctionBuilder<A, R>) {
332        self.0.add_meta_function_mut(meta, function)
333    }
334}
mlua_extras/typed/class/wrapped.rs

mlua_extras/typed/class/
wrapped.rs
