1#[cfg(feature = "moon_sharp-interpreter-userdata-types")]
4mod __types {
5 #[allow(unused_imports)] use ::unity::prelude::*;
6
7 use super::*;
8 use crate::{
9 moon_sharp::interpreter::refidobject::{IRefIdObject, RefIdObject},
10 system::object::{IObject, Object},
11 };
12
13 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/moon_sharp/interpreter/userdata/UserData.md"))]
14 #[::unity::class(namespace = "MoonSharp.Interpreter", name = "UserData")]
15 #[parent(crate::moon_sharp::interpreter::refidobject::RefIdObject)]
16 pub struct UserData {}
17}
18
19#[cfg(feature = "moon_sharp-interpreter-userdata-types")]
20pub use __types::*;
21
22#[cfg(feature = "moon_sharp-interpreter-userdata")]
23#[doc(hidden)]
24#[allow(non_snake_case, non_camel_case_types, clippy::too_many_arguments)]
25mod __UserData_unity_raw {
26 use super::*;
27 #[doc(hidden)]
28 #[allow(non_snake_case)]
29 pub mod __lookup_ctor {
30 use super::*;
31 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
32 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
33 ::unity::lookup::method_info_on_class_with_signature(<UserData as ::unity::ClassIdentity>::class(), ".ctor", 0, param_types, false)
34 });
35 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
36 match &*METHOD {
37 ::core::result::Result::Ok(mi) => *mi,
38 ::core::result::Result::Err(e) => {
39 panic!(
40 "method lookup failed: {}
41::{}
42: {}
43",
44 <UserData as ::unity::ClassIdentity>::NAME,
45 ".ctor",
46 e
47 )
48 },
49 }
50 }
51 }
52 #[doc(hidden)]
53 #[allow(non_snake_case)]
54 pub mod __lookup_get_user_value {
55 use super::*;
56 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
57 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
58 ::unity::lookup::method_info_on_class_with_signature(
59 <UserData as ::unity::ClassIdentity>::class(),
60 "get_UserValue",
61 0,
62 param_types,
63 false,
64 )
65 });
66 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
67 match &*METHOD {
68 ::core::result::Result::Ok(mi) => *mi,
69 ::core::result::Result::Err(e) => {
70 panic!(
71 "method lookup failed: {}
72::{}
73: {}
74",
75 <UserData as ::unity::ClassIdentity>::NAME,
76 "get_UserValue",
77 e
78 )
79 },
80 }
81 }
82 }
83 #[doc(hidden)]
84 #[allow(non_snake_case)]
85 pub mod __lookup_set_user_value {
86 use super::*;
87 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
88 let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
89 &[<crate::moon_sharp::interpreter::dynvalue::DynValue as ::unity::IlType>::il_type()];
90 ::unity::lookup::method_info_on_class_with_signature(
91 <UserData as ::unity::ClassIdentity>::class(),
92 "set_UserValue",
93 1,
94 param_types,
95 false,
96 )
97 });
98 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
99 match &*METHOD {
100 ::core::result::Result::Ok(mi) => *mi,
101 ::core::result::Result::Err(e) => {
102 panic!(
103 "method lookup failed: {}
104::{}
105: {}
106",
107 <UserData as ::unity::ClassIdentity>::NAME,
108 "set_UserValue",
109 e
110 )
111 },
112 }
113 }
114 }
115 #[doc(hidden)]
116 #[allow(non_snake_case)]
117 pub mod __lookup_get_object {
118 use super::*;
119 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
120 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
121 ::unity::lookup::method_info_on_class_with_signature(<UserData as ::unity::ClassIdentity>::class(), "get_Object", 0, param_types, false)
122 });
123 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
124 match &*METHOD {
125 ::core::result::Result::Ok(mi) => *mi,
126 ::core::result::Result::Err(e) => {
127 panic!(
128 "method lookup failed: {}
129::{}
130: {}
131",
132 <UserData as ::unity::ClassIdentity>::NAME,
133 "get_Object",
134 e
135 )
136 },
137 }
138 }
139 }
140 #[doc(hidden)]
141 #[allow(non_snake_case)]
142 pub mod __lookup_set_object {
143 use super::*;
144 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
145 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[<crate::system::object::Object as ::unity::IlType>::il_type()];
146 ::unity::lookup::method_info_on_class_with_signature(<UserData as ::unity::ClassIdentity>::class(), "set_Object", 1, param_types, false)
147 });
148 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
149 match &*METHOD {
150 ::core::result::Result::Ok(mi) => *mi,
151 ::core::result::Result::Err(e) => {
152 panic!(
153 "method lookup failed: {}
154::{}
155: {}
156",
157 <UserData as ::unity::ClassIdentity>::NAME,
158 "set_Object",
159 e
160 )
161 },
162 }
163 }
164 }
165 #[doc(hidden)]
166 #[allow(non_snake_case)]
167 pub mod __lookup_get_descriptor {
168 use super::*;
169 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
170 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
171 ::unity::lookup::method_info_on_class_with_signature(
172 <UserData as ::unity::ClassIdentity>::class(),
173 "get_Descriptor",
174 0,
175 param_types,
176 false,
177 )
178 });
179 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
180 match &*METHOD {
181 ::core::result::Result::Ok(mi) => *mi,
182 ::core::result::Result::Err(e) => {
183 panic!(
184 "method lookup failed: {}
185::{}
186: {}
187",
188 <UserData as ::unity::ClassIdentity>::NAME,
189 "get_Descriptor",
190 e
191 )
192 },
193 }
194 }
195 }
196 #[doc(hidden)]
197 #[allow(non_snake_case)]
198 pub mod __lookup_set_descriptor {
199 use super::*;
200 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
201 let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
202 &[<crate::moon_sharp::interpreter::interop::iuserdatadescriptor::IUserDataDescriptor as ::unity::IlType>::il_type()];
203 ::unity::lookup::method_info_on_class_with_signature(
204 <UserData as ::unity::ClassIdentity>::class(),
205 "set_Descriptor",
206 1,
207 param_types,
208 false,
209 )
210 });
211 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
212 match &*METHOD {
213 ::core::result::Result::Ok(mi) => *mi,
214 ::core::result::Result::Err(e) => {
215 panic!(
216 "method lookup failed: {}
217::{}
218: {}
219",
220 <UserData as ::unity::ClassIdentity>::NAME,
221 "set_Descriptor",
222 e
223 )
224 },
225 }
226 }
227 }
228 #[doc(hidden)]
229 #[allow(non_snake_case)]
230 pub mod __lookup_cctor {
231 use super::*;
232 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
233 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
234 ::unity::lookup::method_info_on_class_with_signature(<UserData as ::unity::ClassIdentity>::class(), ".cctor", 0, param_types, true)
235 });
236 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
237 match &*METHOD {
238 ::core::result::Result::Ok(mi) => *mi,
239 ::core::result::Result::Err(e) => {
240 panic!(
241 "method lookup failed: {}
242::{}
243: {}
244",
245 <UserData as ::unity::ClassIdentity>::NAME,
246 ".cctor",
247 e
248 )
249 },
250 }
251 }
252 }
253 #[doc(hidden)]
254 #[allow(non_snake_case)]
255 pub mod __lookup_register_type_2 {
256 use super::*;
257 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
258 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
259 <::unity::SystemType as ::unity::IlType>::il_type(),
260 <crate::moon_sharp::interpreter::interopaccessmode::InteropAccessMode as ::unity::IlType>::il_type(),
261 <::unity::Il2CppString as ::unity::IlType>::il_type(),
262 ];
263 ::unity::lookup::method_info_on_class_with_signature(<UserData as ::unity::ClassIdentity>::class(), "RegisterType", 3, param_types, true)
264 });
265 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
266 match &*METHOD {
267 ::core::result::Result::Ok(mi) => *mi,
268 ::core::result::Result::Err(e) => {
269 panic!(
270 "method lookup failed: {}
271::{}
272: {}
273",
274 <UserData as ::unity::ClassIdentity>::NAME,
275 "RegisterType",
276 e
277 )
278 },
279 }
280 }
281 }
282 #[doc(hidden)]
283 #[allow(non_snake_case)]
284 pub mod __lookup_register_proxy_type {
285 use super::*;
286 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
287 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
288 <crate::moon_sharp::interpreter::interop::iproxyfactory::IProxyFactory as ::unity::IlType>::il_type(),
289 <crate::moon_sharp::interpreter::interopaccessmode::InteropAccessMode as ::unity::IlType>::il_type(),
290 <::unity::Il2CppString as ::unity::IlType>::il_type(),
291 ];
292 ::unity::lookup::method_info_on_class_with_signature(
293 <UserData as ::unity::ClassIdentity>::class(),
294 "RegisterProxyType",
295 3,
296 param_types,
297 true,
298 )
299 });
300 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
301 match &*METHOD {
302 ::core::result::Result::Ok(mi) => *mi,
303 ::core::result::Result::Err(e) => {
304 panic!(
305 "method lookup failed: {}
306::{}
307: {}
308",
309 <UserData as ::unity::ClassIdentity>::NAME,
310 "RegisterProxyType",
311 e
312 )
313 },
314 }
315 }
316 }
317 #[doc(hidden)]
318 #[allow(non_snake_case)]
319 pub mod __lookup_register_type_4 {
320 use super::*;
321 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
322 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
323 <::unity::SystemType as ::unity::IlType>::il_type(),
324 <crate::moon_sharp::interpreter::interop::iuserdatadescriptor::IUserDataDescriptor as ::unity::IlType>::il_type(),
325 ];
326 ::unity::lookup::method_info_on_class_with_signature(<UserData as ::unity::ClassIdentity>::class(), "RegisterType", 2, param_types, true)
327 });
328 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
329 match &*METHOD {
330 ::core::result::Result::Ok(mi) => *mi,
331 ::core::result::Result::Err(e) => {
332 panic!(
333 "method lookup failed: {}
334::{}
335: {}
336",
337 <UserData as ::unity::ClassIdentity>::NAME,
338 "RegisterType",
339 e
340 )
341 },
342 }
343 }
344 }
345 #[doc(hidden)]
346 #[allow(non_snake_case)]
347 pub mod __lookup_register_assembly {
348 use super::*;
349 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
350 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
351 <crate::system::reflection::assembly::Assembly as ::unity::IlType>::il_type(),
352 <bool as ::unity::IlType>::il_type(),
353 ];
354 ::unity::lookup::method_info_on_class_with_signature(
355 <UserData as ::unity::ClassIdentity>::class(),
356 "RegisterAssembly",
357 2,
358 param_types,
359 true,
360 )
361 });
362 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
363 match &*METHOD {
364 ::core::result::Result::Ok(mi) => *mi,
365 ::core::result::Result::Err(e) => {
366 panic!(
367 "method lookup failed: {}
368::{}
369: {}
370",
371 <UserData as ::unity::ClassIdentity>::NAME,
372 "RegisterAssembly",
373 e
374 )
375 },
376 }
377 }
378 }
379 #[doc(hidden)]
380 #[allow(non_snake_case)]
381 pub mod __lookup_is_type_registered {
382 use super::*;
383 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
384 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[<::unity::SystemType as ::unity::IlType>::il_type()];
385 ::unity::lookup::method_info_on_class_with_signature(
386 <UserData as ::unity::ClassIdentity>::class(),
387 "IsTypeRegistered",
388 1,
389 param_types,
390 true,
391 )
392 });
393 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
394 match &*METHOD {
395 ::core::result::Result::Ok(mi) => *mi,
396 ::core::result::Result::Err(e) => {
397 panic!(
398 "method lookup failed: {}
399::{}
400: {}
401",
402 <UserData as ::unity::ClassIdentity>::NAME,
403 "IsTypeRegistered",
404 e
405 )
406 },
407 }
408 }
409 }
410 #[doc(hidden)]
411 #[allow(non_snake_case)]
412 pub mod __lookup_unregister_type_2 {
413 use super::*;
414 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
415 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[<::unity::SystemType as ::unity::IlType>::il_type()];
416 ::unity::lookup::method_info_on_class_with_signature(
417 <UserData as ::unity::ClassIdentity>::class(),
418 "UnregisterType",
419 1,
420 param_types,
421 true,
422 )
423 });
424 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
425 match &*METHOD {
426 ::core::result::Result::Ok(mi) => *mi,
427 ::core::result::Result::Err(e) => {
428 panic!(
429 "method lookup failed: {}
430::{}
431: {}
432",
433 <UserData as ::unity::ClassIdentity>::NAME,
434 "UnregisterType",
435 e
436 )
437 },
438 }
439 }
440 }
441 #[doc(hidden)]
442 #[allow(non_snake_case)]
443 pub mod __lookup_create {
444 use super::*;
445 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
446 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
447 <crate::system::object::Object as ::unity::IlType>::il_type(),
448 <crate::moon_sharp::interpreter::interop::iuserdatadescriptor::IUserDataDescriptor as ::unity::IlType>::il_type(),
449 ];
450 ::unity::lookup::method_info_on_class_with_signature(<UserData as ::unity::ClassIdentity>::class(), "Create", 2, param_types, true)
451 });
452 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
453 match &*METHOD {
454 ::core::result::Result::Ok(mi) => *mi,
455 ::core::result::Result::Err(e) => {
456 panic!(
457 "method lookup failed: {}
458::{}
459: {}
460",
461 <UserData as ::unity::ClassIdentity>::NAME,
462 "Create",
463 e
464 )
465 },
466 }
467 }
468 }
469 #[doc(hidden)]
470 #[allow(non_snake_case)]
471 pub mod __lookup_create_2 {
472 use super::*;
473 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
474 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[<crate::system::object::Object as ::unity::IlType>::il_type()];
475 ::unity::lookup::method_info_on_class_with_signature(<UserData as ::unity::ClassIdentity>::class(), "Create", 1, param_types, true)
476 });
477 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
478 match &*METHOD {
479 ::core::result::Result::Ok(mi) => *mi,
480 ::core::result::Result::Err(e) => {
481 panic!(
482 "method lookup failed: {}
483::{}
484: {}
485",
486 <UserData as ::unity::ClassIdentity>::NAME,
487 "Create",
488 e
489 )
490 },
491 }
492 }
493 }
494 #[doc(hidden)]
495 #[allow(non_snake_case)]
496 pub mod __lookup_create_static {
497 use super::*;
498 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
499 let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
500 &[<crate::moon_sharp::interpreter::interop::iuserdatadescriptor::IUserDataDescriptor as ::unity::IlType>::il_type()];
501 ::unity::lookup::method_info_on_class_with_signature(<UserData as ::unity::ClassIdentity>::class(), "CreateStatic", 1, param_types, true)
502 });
503 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
504 match &*METHOD {
505 ::core::result::Result::Ok(mi) => *mi,
506 ::core::result::Result::Err(e) => {
507 panic!(
508 "method lookup failed: {}
509::{}
510: {}
511",
512 <UserData as ::unity::ClassIdentity>::NAME,
513 "CreateStatic",
514 e
515 )
516 },
517 }
518 }
519 }
520 #[doc(hidden)]
521 #[allow(non_snake_case)]
522 pub mod __lookup_create_static_2 {
523 use super::*;
524 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
525 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[<::unity::SystemType as ::unity::IlType>::il_type()];
526 ::unity::lookup::method_info_on_class_with_signature(<UserData as ::unity::ClassIdentity>::class(), "CreateStatic", 1, param_types, true)
527 });
528 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
529 match &*METHOD {
530 ::core::result::Result::Ok(mi) => *mi,
531 ::core::result::Result::Err(e) => {
532 panic!(
533 "method lookup failed: {}
534::{}
535: {}
536",
537 <UserData as ::unity::ClassIdentity>::NAME,
538 "CreateStatic",
539 e
540 )
541 },
542 }
543 }
544 }
545 #[doc(hidden)]
546 #[allow(non_snake_case)]
547 pub mod __lookup_get_registration_policy {
548 use super::*;
549 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
550 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
551 ::unity::lookup::method_info_on_class_with_signature(
552 <UserData as ::unity::ClassIdentity>::class(),
553 "get_RegistrationPolicy",
554 0,
555 param_types,
556 true,
557 )
558 });
559 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
560 match &*METHOD {
561 ::core::result::Result::Ok(mi) => *mi,
562 ::core::result::Result::Err(e) => {
563 panic!(
564 "method lookup failed: {}
565::{}
566: {}
567",
568 <UserData as ::unity::ClassIdentity>::NAME,
569 "get_RegistrationPolicy",
570 e
571 )
572 },
573 }
574 }
575 }
576 #[doc(hidden)]
577 #[allow(non_snake_case)]
578 pub mod __lookup_set_registration_policy {
579 use super::*;
580 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
581 let param_types: &[& 'static::unity::il2cpp::Il2CppType]= &[<crate::moon_sharp::interpreter::interop::registration_policies::iregistrationpolicy::IRegistrationPolicy as::unity::IlType> ::il_type()];
582 ::unity::lookup::method_info_on_class_with_signature(
583 <UserData as ::unity::ClassIdentity>::class(),
584 "set_RegistrationPolicy",
585 1,
586 param_types,
587 true,
588 )
589 });
590 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
591 match &*METHOD {
592 ::core::result::Result::Ok(mi) => *mi,
593 ::core::result::Result::Err(e) => {
594 panic!(
595 "method lookup failed: {}
596::{}
597: {}
598",
599 <UserData as ::unity::ClassIdentity>::NAME,
600 "set_RegistrationPolicy",
601 e
602 )
603 },
604 }
605 }
606 }
607 #[doc(hidden)]
608 #[allow(non_snake_case)]
609 pub mod __lookup_get_default_access_mode {
610 use super::*;
611 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
612 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
613 ::unity::lookup::method_info_on_class_with_signature(
614 <UserData as ::unity::ClassIdentity>::class(),
615 "get_DefaultAccessMode",
616 0,
617 param_types,
618 true,
619 )
620 });
621 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
622 match &*METHOD {
623 ::core::result::Result::Ok(mi) => *mi,
624 ::core::result::Result::Err(e) => {
625 panic!(
626 "method lookup failed: {}
627::{}
628: {}
629",
630 <UserData as ::unity::ClassIdentity>::NAME,
631 "get_DefaultAccessMode",
632 e
633 )
634 },
635 }
636 }
637 }
638 #[doc(hidden)]
639 #[allow(non_snake_case)]
640 pub mod __lookup_set_default_access_mode {
641 use super::*;
642 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
643 let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
644 &[<crate::moon_sharp::interpreter::interopaccessmode::InteropAccessMode as ::unity::IlType>::il_type()];
645 ::unity::lookup::method_info_on_class_with_signature(
646 <UserData as ::unity::ClassIdentity>::class(),
647 "set_DefaultAccessMode",
648 1,
649 param_types,
650 true,
651 )
652 });
653 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
654 match &*METHOD {
655 ::core::result::Result::Ok(mi) => *mi,
656 ::core::result::Result::Err(e) => {
657 panic!(
658 "method lookup failed: {}
659::{}
660: {}
661",
662 <UserData as ::unity::ClassIdentity>::NAME,
663 "set_DefaultAccessMode",
664 e
665 )
666 },
667 }
668 }
669 }
670 #[doc(hidden)]
671 #[allow(non_snake_case)]
672 pub mod __lookup_register_extension_type {
673 use super::*;
674 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
675 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
676 <::unity::SystemType as ::unity::IlType>::il_type(),
677 <crate::moon_sharp::interpreter::interopaccessmode::InteropAccessMode as ::unity::IlType>::il_type(),
678 ];
679 ::unity::lookup::method_info_on_class_with_signature(
680 <UserData as ::unity::ClassIdentity>::class(),
681 "RegisterExtensionType",
682 2,
683 param_types,
684 true,
685 )
686 });
687 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
688 match &*METHOD {
689 ::core::result::Result::Ok(mi) => *mi,
690 ::core::result::Result::Err(e) => {
691 panic!(
692 "method lookup failed: {}
693::{}
694: {}
695",
696 <UserData as ::unity::ClassIdentity>::NAME,
697 "RegisterExtensionType",
698 e
699 )
700 },
701 }
702 }
703 }
704 #[doc(hidden)]
705 #[allow(non_snake_case)]
706 pub mod __lookup_get_extension_methods_by_name_and_type {
707 use super::*;
708 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
709 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
710 <::unity::Il2CppString as ::unity::IlType>::il_type(),
711 <::unity::SystemType as ::unity::IlType>::il_type(),
712 ];
713 ::unity::lookup::method_info_on_class_with_signature(
714 <UserData as ::unity::ClassIdentity>::class(),
715 "GetExtensionMethodsByNameAndType",
716 2,
717 param_types,
718 true,
719 )
720 });
721 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
722 match &*METHOD {
723 ::core::result::Result::Ok(mi) => *mi,
724 ::core::result::Result::Err(e) => {
725 panic!(
726 "method lookup failed: {}
727::{}
728: {}
729",
730 <UserData as ::unity::ClassIdentity>::NAME,
731 "GetExtensionMethodsByNameAndType",
732 e
733 )
734 },
735 }
736 }
737 }
738 #[doc(hidden)]
739 #[allow(non_snake_case)]
740 pub mod __lookup_get_extension_methods_change_version {
741 use super::*;
742 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
743 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
744 ::unity::lookup::method_info_on_class_with_signature(
745 <UserData as ::unity::ClassIdentity>::class(),
746 "GetExtensionMethodsChangeVersion",
747 0,
748 param_types,
749 true,
750 )
751 });
752 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
753 match &*METHOD {
754 ::core::result::Result::Ok(mi) => *mi,
755 ::core::result::Result::Err(e) => {
756 panic!(
757 "method lookup failed: {}
758::{}
759: {}
760",
761 <UserData as ::unity::ClassIdentity>::NAME,
762 "GetExtensionMethodsChangeVersion",
763 e
764 )
765 },
766 }
767 }
768 }
769 #[doc(hidden)]
770 #[allow(non_snake_case)]
771 pub mod __lookup_get_descriptor_for_type_2 {
772 use super::*;
773 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
774 let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
775 &[<::unity::SystemType as ::unity::IlType>::il_type(), <bool as ::unity::IlType>::il_type()];
776 ::unity::lookup::method_info_on_class_with_signature(
777 <UserData as ::unity::ClassIdentity>::class(),
778 "GetDescriptorForType",
779 2,
780 param_types,
781 true,
782 )
783 });
784 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
785 match &*METHOD {
786 ::core::result::Result::Ok(mi) => *mi,
787 ::core::result::Result::Err(e) => {
788 panic!(
789 "method lookup failed: {}
790::{}
791: {}
792",
793 <UserData as ::unity::ClassIdentity>::NAME,
794 "GetDescriptorForType",
795 e
796 )
797 },
798 }
799 }
800 }
801 #[doc(hidden)]
802 #[allow(non_snake_case)]
803 pub mod __lookup_get_descriptor_for_object {
804 use super::*;
805 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
806 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[<crate::system::object::Object as ::unity::IlType>::il_type()];
807 ::unity::lookup::method_info_on_class_with_signature(
808 <UserData as ::unity::ClassIdentity>::class(),
809 "GetDescriptorForObject",
810 1,
811 param_types,
812 true,
813 )
814 });
815 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
816 match &*METHOD {
817 ::core::result::Result::Ok(mi) => *mi,
818 ::core::result::Result::Err(e) => {
819 panic!(
820 "method lookup failed: {}
821::{}
822: {}
823",
824 <UserData as ::unity::ClassIdentity>::NAME,
825 "GetDescriptorForObject",
826 e
827 )
828 },
829 }
830 }
831 }
832 #[doc(hidden)]
833 #[allow(non_snake_case)]
834 pub mod __lookup_get_description_of_registered_types {
835 use super::*;
836 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
837 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[<bool as ::unity::IlType>::il_type()];
838 ::unity::lookup::method_info_on_class_with_signature(
839 <UserData as ::unity::ClassIdentity>::class(),
840 "GetDescriptionOfRegisteredTypes",
841 1,
842 param_types,
843 true,
844 )
845 });
846 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
847 match &*METHOD {
848 ::core::result::Result::Ok(mi) => *mi,
849 ::core::result::Result::Err(e) => {
850 panic!(
851 "method lookup failed: {}
852::{}
853: {}
854",
855 <UserData as ::unity::ClassIdentity>::NAME,
856 "GetDescriptionOfRegisteredTypes",
857 e
858 )
859 },
860 }
861 }
862 }
863 #[doc(hidden)]
864 #[allow(non_snake_case)]
865 pub mod __lookup_get_registered_types {
866 use super::*;
867 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
868 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[<bool as ::unity::IlType>::il_type()];
869 ::unity::lookup::method_info_on_class_with_signature(
870 <UserData as ::unity::ClassIdentity>::class(),
871 "GetRegisteredTypes",
872 1,
873 param_types,
874 true,
875 )
876 });
877 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
878 match &*METHOD {
879 ::core::result::Result::Ok(mi) => *mi,
880 ::core::result::Result::Err(e) => {
881 panic!(
882 "method lookup failed: {}
883::{}
884: {}
885",
886 <UserData as ::unity::ClassIdentity>::NAME,
887 "GetRegisteredTypes",
888 e
889 )
890 },
891 }
892 }
893 }
894}
895
896#[cfg(feature = "moon_sharp-interpreter-userdata")]
897impl UserData {
898 #[doc = "`.cctor()` overload"]
899 pub fn cctor() -> () {
900 unsafe {
901 ::unity::il2cpp_call!(__UserData_unity_raw::__lookup_cctor::get_method_info().method_ptr,();
902 )
903 }
904 }
905
906 pub fn register_type<M0: ::unity::IlType + ::core::marker::Copy + ::unity::ClassIdentity>(
907 access_mode: impl ::core::convert::Into<crate::moon_sharp::interpreter::interopaccessmode::InteropAccessMode>,
908 friendly_name: impl ::core::convert::Into<::unity::Il2CppString>,
909 ) -> crate::moon_sharp::interpreter::interop::iuserdatadescriptor::IUserDataDescriptor {
910 static OPEN: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> =
911 ::std::sync::LazyLock::new(|| ::unity::lookup::method_info_on_class(<UserData as ::unity::ClassIdentity>::class(), "RegisterType", 2));
912 #[allow(clippy::type_complexity)]
913 static CACHE: ::std::sync::OnceLock<::std::sync::Mutex<::std::collections::HashMap<usize, &'static ::unity::il2cpp::MethodInfo>>> =
914 ::std::sync::OnceLock::new();
915 let _ = true;
916 let __open: &'static ::unity::il2cpp::MethodInfo = match &*OPEN {
917 ::core::result::Result::Ok(mi) => *mi,
918 ::core::result::Result::Err(e) => {
919 panic!(
920 "method lookup failed: {}
921::{}
922: {}
923",
924 <UserData as ::unity::ClassIdentity>::NAME,
925 "RegisterType",
926 e
927 )
928 },
929 };
930 let __cache = CACHE.get_or_init(|| ::std::sync::Mutex::new(::std::collections::HashMap::new()));
931 let __key: usize = <M0 as ::unity::IlType>::il_type() as *const _ as usize;
932 let __inflated: &'static ::unity::il2cpp::MethodInfo = {
933 let mut __guard = __cache.lock().unwrap();
934 *__guard
935 .entry(__key)
936 .or_insert_with(|| ::unity::il2cpp::generic::create_generic_method_info(__open, &[<M0 as ::unity::IlType>::il_type()]))
937 };
938 unsafe {
939 let __f: extern "C" fn(
940 crate::moon_sharp::interpreter::interopaccessmode::InteropAccessMode,
941 ::unity::Il2CppString,
942 ::unity::OptionalMethod,
943 ) -> crate::moon_sharp::interpreter::interop::iuserdatadescriptor::IUserDataDescriptor = ::core::mem::transmute(__inflated.method_ptr);
944 let __mi_opaque: &'static () = &*(__inflated as *const _ as *const ());
945 __f(
946 ::core::convert::Into::into(access_mode),
947 ::core::convert::Into::into(friendly_name),
948 ::core::option::Option::Some(__mi_opaque),
949 )
950 }
951 }
952
953 #[doc = "`RegisterType(::unity::SystemType, crate::moon_sharp::interpreter::interopaccessmode::InteropAccessMode, ::unity::Il2CppString)` overload"]
954 pub fn register_type_2(
955 r#type: impl ::core::convert::Into<::unity::SystemType>,
956 access_mode: impl ::core::convert::Into<crate::moon_sharp::interpreter::interopaccessmode::InteropAccessMode>,
957 friendly_name: impl ::core::convert::Into<::unity::Il2CppString>,
958 ) -> crate::moon_sharp::interpreter::interop::iuserdatadescriptor::IUserDataDescriptor {
959 unsafe {
960 ::unity::il2cpp_call!(__UserData_unity_raw::__lookup_register_type_2::get_method_info().method_ptr,crate::moon_sharp::interpreter::interop::iuserdatadescriptor::IUserDataDescriptor;
961(::unity::SystemType)::core::convert::Into::into(r#type),(crate::moon_sharp::interpreter::interopaccessmode::InteropAccessMode)::core::convert::Into::into(access_mode),(::unity::Il2CppString)::core::convert::Into::into(friendly_name))
962 }
963 }
964
965 #[doc = "`RegisterProxyType(crate::moon_sharp::interpreter::interop::iproxyfactory::IProxyFactory, crate::moon_sharp::interpreter::interopaccessmode::InteropAccessMode, ::unity::Il2CppString)` overload"]
966 pub fn register_proxy_type(
967 proxy_factory: impl ::core::convert::Into<crate::moon_sharp::interpreter::interop::iproxyfactory::IProxyFactory>,
968 access_mode: impl ::core::convert::Into<crate::moon_sharp::interpreter::interopaccessmode::InteropAccessMode>,
969 friendly_name: impl ::core::convert::Into<::unity::Il2CppString>,
970 ) -> crate::moon_sharp::interpreter::interop::iuserdatadescriptor::IUserDataDescriptor {
971 unsafe {
972 ::unity::il2cpp_call!(__UserData_unity_raw::__lookup_register_proxy_type::get_method_info().method_ptr,crate::moon_sharp::interpreter::interop::iuserdatadescriptor::IUserDataDescriptor;
973(crate::moon_sharp::interpreter::interop::iproxyfactory::IProxyFactory)::core::convert::Into::into(proxy_factory),(crate::moon_sharp::interpreter::interopaccessmode::InteropAccessMode)::core::convert::Into::into(access_mode),(::unity::Il2CppString)::core::convert::Into::into(friendly_name))
974 }
975 }
976
977 pub fn register_proxy_type_2<
978 M0: ::unity::IlType + ::core::marker::Copy + ::unity::ClassIdentity,
979 M1: ::unity::IlType + ::core::marker::Copy + ::unity::ClassIdentity,
980 >(
981 wrap_delegate: impl ::core::convert::Into<crate::system::func_2::Func_2<M1, M0>>,
982 access_mode: impl ::core::convert::Into<crate::moon_sharp::interpreter::interopaccessmode::InteropAccessMode>,
983 friendly_name: impl ::core::convert::Into<::unity::Il2CppString>,
984 ) -> crate::moon_sharp::interpreter::interop::iuserdatadescriptor::IUserDataDescriptor {
985 static OPEN: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
986 ::unity::lookup::method_info_on_class(<UserData as ::unity::ClassIdentity>::class(), "RegisterProxyType", 3)
987 });
988 #[allow(clippy::type_complexity)]
989 static CACHE: ::std::sync::OnceLock<::std::sync::Mutex<::std::collections::HashMap<usize, &'static ::unity::il2cpp::MethodInfo>>> =
990 ::std::sync::OnceLock::new();
991 let _ = true;
992 let __open: &'static ::unity::il2cpp::MethodInfo = match &*OPEN {
993 ::core::result::Result::Ok(mi) => *mi,
994 ::core::result::Result::Err(e) => {
995 panic!(
996 "method lookup failed: {}
997::{}
998: {}
999",
1000 <UserData as ::unity::ClassIdentity>::NAME,
1001 "RegisterProxyType",
1002 e
1003 )
1004 },
1005 };
1006 let __cache = CACHE.get_or_init(|| ::std::sync::Mutex::new(::std::collections::HashMap::new()));
1007 let __key: usize = (<M0 as ::unity::IlType>::il_type() as *const _ as usize) ^ (<M1 as ::unity::IlType>::il_type() as *const _ as usize);
1008 let __inflated: &'static ::unity::il2cpp::MethodInfo = {
1009 let mut __guard = __cache.lock().unwrap();
1010 *__guard.entry(__key).or_insert_with(|| {
1011 ::unity::il2cpp::generic::create_generic_method_info(__open, &[
1012 <M0 as ::unity::IlType>::il_type(),
1013 <M1 as ::unity::IlType>::il_type(),
1014 ])
1015 })
1016 };
1017 unsafe {
1018 let __f: extern "C" fn(
1019 crate::system::func_2::Func_2<M1, M0>,
1020 crate::moon_sharp::interpreter::interopaccessmode::InteropAccessMode,
1021 ::unity::Il2CppString,
1022 ::unity::OptionalMethod,
1023 ) -> crate::moon_sharp::interpreter::interop::iuserdatadescriptor::IUserDataDescriptor = ::core::mem::transmute(__inflated.method_ptr);
1024 let __mi_opaque: &'static () = &*(__inflated as *const _ as *const ());
1025 __f(
1026 ::core::convert::Into::into(wrap_delegate),
1027 ::core::convert::Into::into(access_mode),
1028 ::core::convert::Into::into(friendly_name),
1029 ::core::option::Option::Some(__mi_opaque),
1030 )
1031 }
1032 }
1033
1034 pub fn register_type_3<M0: ::unity::IlType + ::core::marker::Copy + ::unity::ClassIdentity>(
1035 custom_descriptor: impl ::core::convert::Into<crate::moon_sharp::interpreter::interop::iuserdatadescriptor::IUserDataDescriptor>,
1036 ) -> crate::moon_sharp::interpreter::interop::iuserdatadescriptor::IUserDataDescriptor {
1037 static OPEN: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> =
1038 ::std::sync::LazyLock::new(|| ::unity::lookup::method_info_on_class(<UserData as ::unity::ClassIdentity>::class(), "RegisterType", 1));
1039 #[allow(clippy::type_complexity)]
1040 static CACHE: ::std::sync::OnceLock<::std::sync::Mutex<::std::collections::HashMap<usize, &'static ::unity::il2cpp::MethodInfo>>> =
1041 ::std::sync::OnceLock::new();
1042 let _ = true;
1043 let __open: &'static ::unity::il2cpp::MethodInfo = match &*OPEN {
1044 ::core::result::Result::Ok(mi) => *mi,
1045 ::core::result::Result::Err(e) => {
1046 panic!(
1047 "method lookup failed: {}
1048::{}
1049: {}
1050",
1051 <UserData as ::unity::ClassIdentity>::NAME,
1052 "RegisterType",
1053 e
1054 )
1055 },
1056 };
1057 let __cache = CACHE.get_or_init(|| ::std::sync::Mutex::new(::std::collections::HashMap::new()));
1058 let __key: usize = <M0 as ::unity::IlType>::il_type() as *const _ as usize;
1059 let __inflated: &'static ::unity::il2cpp::MethodInfo = {
1060 let mut __guard = __cache.lock().unwrap();
1061 *__guard
1062 .entry(__key)
1063 .or_insert_with(|| ::unity::il2cpp::generic::create_generic_method_info(__open, &[<M0 as ::unity::IlType>::il_type()]))
1064 };
1065 unsafe {
1066 let __f: extern "C" fn(
1067 crate::moon_sharp::interpreter::interop::iuserdatadescriptor::IUserDataDescriptor,
1068 ::unity::OptionalMethod,
1069 ) -> crate::moon_sharp::interpreter::interop::iuserdatadescriptor::IUserDataDescriptor = ::core::mem::transmute(__inflated.method_ptr);
1070 let __mi_opaque: &'static () = &*(__inflated as *const _ as *const ());
1071 __f(::core::convert::Into::into(custom_descriptor), ::core::option::Option::Some(__mi_opaque))
1072 }
1073 }
1074
1075 #[doc = "`RegisterType(::unity::SystemType, crate::moon_sharp::interpreter::interop::iuserdatadescriptor::IUserDataDescriptor)` overload"]
1076 pub fn register_type_4(
1077 r#type: impl ::core::convert::Into<::unity::SystemType>,
1078 custom_descriptor: impl ::core::convert::Into<crate::moon_sharp::interpreter::interop::iuserdatadescriptor::IUserDataDescriptor>,
1079 ) -> crate::moon_sharp::interpreter::interop::iuserdatadescriptor::IUserDataDescriptor {
1080 unsafe {
1081 ::unity::il2cpp_call!(__UserData_unity_raw::__lookup_register_type_4::get_method_info().method_ptr,crate::moon_sharp::interpreter::interop::iuserdatadescriptor::IUserDataDescriptor;
1082(::unity::SystemType)::core::convert::Into::into(r#type),(crate::moon_sharp::interpreter::interop::iuserdatadescriptor::IUserDataDescriptor)::core::convert::Into::into(custom_descriptor))
1083 }
1084 }
1085
1086 #[doc = "`RegisterAssembly(crate::system::reflection::assembly::Assembly, bool)` overload"]
1087 pub fn register_assembly(
1088 asm: impl ::core::convert::Into<crate::system::reflection::assembly::Assembly>,
1089 include_extension_types: impl ::core::convert::Into<bool>,
1090 ) -> () {
1091 unsafe {
1092 ::unity::il2cpp_call!(__UserData_unity_raw::__lookup_register_assembly::get_method_info().method_ptr,();
1093(crate::system::reflection::assembly::Assembly)::core::convert::Into::into(asm),(bool)::core::convert::Into::into(include_extension_types))
1094 }
1095 }
1096
1097 #[doc = "`IsTypeRegistered(::unity::SystemType)` overload"]
1098 pub fn is_type_registered(t: impl ::core::convert::Into<::unity::SystemType>) -> bool {
1099 unsafe {
1100 ::unity::il2cpp_call!(__UserData_unity_raw::__lookup_is_type_registered::get_method_info().method_ptr,bool;
1101(::unity::SystemType)::core::convert::Into::into(t))
1102 }
1103 }
1104
1105 pub fn is_type_registered_2<M0: ::unity::IlType + ::core::marker::Copy + ::unity::ClassIdentity>() -> bool {
1106 static OPEN: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1107 ::unity::lookup::method_info_on_class(<UserData as ::unity::ClassIdentity>::class(), "IsTypeRegistered", 0)
1108 });
1109 #[allow(clippy::type_complexity)]
1110 static CACHE: ::std::sync::OnceLock<::std::sync::Mutex<::std::collections::HashMap<usize, &'static ::unity::il2cpp::MethodInfo>>> =
1111 ::std::sync::OnceLock::new();
1112 let _ = true;
1113 let __open: &'static ::unity::il2cpp::MethodInfo = match &*OPEN {
1114 ::core::result::Result::Ok(mi) => *mi,
1115 ::core::result::Result::Err(e) => {
1116 panic!(
1117 "method lookup failed: {}
1118::{}
1119: {}
1120",
1121 <UserData as ::unity::ClassIdentity>::NAME,
1122 "IsTypeRegistered",
1123 e
1124 )
1125 },
1126 };
1127 let __cache = CACHE.get_or_init(|| ::std::sync::Mutex::new(::std::collections::HashMap::new()));
1128 let __key: usize = <M0 as ::unity::IlType>::il_type() as *const _ as usize;
1129 let __inflated: &'static ::unity::il2cpp::MethodInfo = {
1130 let mut __guard = __cache.lock().unwrap();
1131 *__guard
1132 .entry(__key)
1133 .or_insert_with(|| ::unity::il2cpp::generic::create_generic_method_info(__open, &[<M0 as ::unity::IlType>::il_type()]))
1134 };
1135 unsafe {
1136 let __f: extern "C" fn(::unity::OptionalMethod) -> bool = ::core::mem::transmute(__inflated.method_ptr);
1137 let __mi_opaque: &'static () = &*(__inflated as *const _ as *const ());
1138 __f(::core::option::Option::Some(__mi_opaque))
1139 }
1140 }
1141
1142 pub fn unregister_type<M0: ::unity::IlType + ::core::marker::Copy + ::unity::ClassIdentity>() -> () {
1143 static OPEN: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> =
1144 ::std::sync::LazyLock::new(|| ::unity::lookup::method_info_on_class(<UserData as ::unity::ClassIdentity>::class(), "UnregisterType", 0));
1145 #[allow(clippy::type_complexity)]
1146 static CACHE: ::std::sync::OnceLock<::std::sync::Mutex<::std::collections::HashMap<usize, &'static ::unity::il2cpp::MethodInfo>>> =
1147 ::std::sync::OnceLock::new();
1148 let _ = true;
1149 let __open: &'static ::unity::il2cpp::MethodInfo = match &*OPEN {
1150 ::core::result::Result::Ok(mi) => *mi,
1151 ::core::result::Result::Err(e) => {
1152 panic!(
1153 "method lookup failed: {}
1154::{}
1155: {}
1156",
1157 <UserData as ::unity::ClassIdentity>::NAME,
1158 "UnregisterType",
1159 e
1160 )
1161 },
1162 };
1163 let __cache = CACHE.get_or_init(|| ::std::sync::Mutex::new(::std::collections::HashMap::new()));
1164 let __key: usize = <M0 as ::unity::IlType>::il_type() as *const _ as usize;
1165 let __inflated: &'static ::unity::il2cpp::MethodInfo = {
1166 let mut __guard = __cache.lock().unwrap();
1167 *__guard
1168 .entry(__key)
1169 .or_insert_with(|| ::unity::il2cpp::generic::create_generic_method_info(__open, &[<M0 as ::unity::IlType>::il_type()]))
1170 };
1171 unsafe {
1172 let __f: extern "C" fn(::unity::OptionalMethod) -> () = ::core::mem::transmute(__inflated.method_ptr);
1173 let __mi_opaque: &'static () = &*(__inflated as *const _ as *const ());
1174 __f(::core::option::Option::Some(__mi_opaque))
1175 }
1176 }
1177
1178 #[doc = "`UnregisterType(::unity::SystemType)` overload"]
1179 pub fn unregister_type_2(t: impl ::core::convert::Into<::unity::SystemType>) -> () {
1180 unsafe {
1181 ::unity::il2cpp_call!(__UserData_unity_raw::__lookup_unregister_type_2::get_method_info().method_ptr,();
1182(::unity::SystemType)::core::convert::Into::into(t))
1183 }
1184 }
1185
1186 #[doc = "`Create(crate::system::object::Object, crate::moon_sharp::interpreter::interop::iuserdatadescriptor::IUserDataDescriptor)` overload"]
1187 pub fn create(
1188 o: impl ::core::convert::Into<crate::system::object::Object>,
1189 descr: impl ::core::convert::Into<crate::moon_sharp::interpreter::interop::iuserdatadescriptor::IUserDataDescriptor>,
1190 ) -> crate::moon_sharp::interpreter::dynvalue::DynValue {
1191 unsafe {
1192 ::unity::il2cpp_call!(__UserData_unity_raw::__lookup_create::get_method_info().method_ptr,crate::moon_sharp::interpreter::dynvalue::DynValue;
1193(crate::system::object::Object)::core::convert::Into::into(o),(crate::moon_sharp::interpreter::interop::iuserdatadescriptor::IUserDataDescriptor)::core::convert::Into::into(descr))
1194 }
1195 }
1196
1197 #[doc = "`Create(crate::system::object::Object)` overload"]
1198 pub fn create_2(o: impl ::core::convert::Into<crate::system::object::Object>) -> crate::moon_sharp::interpreter::dynvalue::DynValue {
1199 unsafe {
1200 ::unity::il2cpp_call!(__UserData_unity_raw::__lookup_create_2::get_method_info().method_ptr,crate::moon_sharp::interpreter::dynvalue::DynValue;
1201(crate::system::object::Object)::core::convert::Into::into(o))
1202 }
1203 }
1204
1205 #[doc = "`CreateStatic(crate::moon_sharp::interpreter::interop::iuserdatadescriptor::IUserDataDescriptor)` overload"]
1206 pub fn create_static(
1207 descr: impl ::core::convert::Into<crate::moon_sharp::interpreter::interop::iuserdatadescriptor::IUserDataDescriptor>,
1208 ) -> crate::moon_sharp::interpreter::dynvalue::DynValue {
1209 unsafe {
1210 ::unity::il2cpp_call!(__UserData_unity_raw::__lookup_create_static::get_method_info().method_ptr,crate::moon_sharp::interpreter::dynvalue::DynValue;
1211(crate::moon_sharp::interpreter::interop::iuserdatadescriptor::IUserDataDescriptor)::core::convert::Into::into(descr))
1212 }
1213 }
1214
1215 #[doc = "`CreateStatic(::unity::SystemType)` overload"]
1216 pub fn create_static_2(t: impl ::core::convert::Into<::unity::SystemType>) -> crate::moon_sharp::interpreter::dynvalue::DynValue {
1217 unsafe {
1218 ::unity::il2cpp_call!(__UserData_unity_raw::__lookup_create_static_2::get_method_info().method_ptr,crate::moon_sharp::interpreter::dynvalue::DynValue;
1219(::unity::SystemType)::core::convert::Into::into(t))
1220 }
1221 }
1222
1223 pub fn create_static_3<M0: ::unity::IlType + ::core::marker::Copy + ::unity::ClassIdentity>() -> crate::moon_sharp::interpreter::dynvalue::DynValue
1224 {
1225 static OPEN: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> =
1226 ::std::sync::LazyLock::new(|| ::unity::lookup::method_info_on_class(<UserData as ::unity::ClassIdentity>::class(), "CreateStatic", 0));
1227 #[allow(clippy::type_complexity)]
1228 static CACHE: ::std::sync::OnceLock<::std::sync::Mutex<::std::collections::HashMap<usize, &'static ::unity::il2cpp::MethodInfo>>> =
1229 ::std::sync::OnceLock::new();
1230 let _ = true;
1231 let __open: &'static ::unity::il2cpp::MethodInfo = match &*OPEN {
1232 ::core::result::Result::Ok(mi) => *mi,
1233 ::core::result::Result::Err(e) => {
1234 panic!(
1235 "method lookup failed: {}
1236::{}
1237: {}
1238",
1239 <UserData as ::unity::ClassIdentity>::NAME,
1240 "CreateStatic",
1241 e
1242 )
1243 },
1244 };
1245 let __cache = CACHE.get_or_init(|| ::std::sync::Mutex::new(::std::collections::HashMap::new()));
1246 let __key: usize = <M0 as ::unity::IlType>::il_type() as *const _ as usize;
1247 let __inflated: &'static ::unity::il2cpp::MethodInfo = {
1248 let mut __guard = __cache.lock().unwrap();
1249 *__guard
1250 .entry(__key)
1251 .or_insert_with(|| ::unity::il2cpp::generic::create_generic_method_info(__open, &[<M0 as ::unity::IlType>::il_type()]))
1252 };
1253 unsafe {
1254 let __f: extern "C" fn(::unity::OptionalMethod) -> crate::moon_sharp::interpreter::dynvalue::DynValue =
1255 ::core::mem::transmute(__inflated.method_ptr);
1256 let __mi_opaque: &'static () = &*(__inflated as *const _ as *const ());
1257 __f(::core::option::Option::Some(__mi_opaque))
1258 }
1259 }
1260
1261 #[doc = "`get_RegistrationPolicy()` overload"]
1262 pub fn get_registration_policy() -> crate::moon_sharp::interpreter::interop::registration_policies::iregistrationpolicy::IRegistrationPolicy {
1263 unsafe {
1264 ::unity::il2cpp_call!(__UserData_unity_raw::__lookup_get_registration_policy::get_method_info().method_ptr,crate::moon_sharp::interpreter::interop::registration_policies::iregistrationpolicy::IRegistrationPolicy;
1265 )
1266 }
1267 }
1268
1269 #[doc = "`set_RegistrationPolicy(crate::moon_sharp::interpreter::interop::registration_policies::iregistrationpolicy::IRegistrationPolicy)` overload"]
1270 pub fn set_registration_policy(
1271 value: impl ::core::convert::Into<crate::moon_sharp::interpreter::interop::registration_policies::iregistrationpolicy::IRegistrationPolicy>,
1272 ) -> () {
1273 unsafe {
1274 ::unity::il2cpp_call!(__UserData_unity_raw::__lookup_set_registration_policy::get_method_info().method_ptr,();
1275(crate::moon_sharp::interpreter::interop::registration_policies::iregistrationpolicy::IRegistrationPolicy)::core::convert::Into::into(value))
1276 }
1277 }
1278
1279 #[doc = "`get_DefaultAccessMode()` overload"]
1280 pub fn get_default_access_mode() -> crate::moon_sharp::interpreter::interopaccessmode::InteropAccessMode {
1281 unsafe {
1282 ::unity::il2cpp_call!(__UserData_unity_raw::__lookup_get_default_access_mode::get_method_info().method_ptr,crate::moon_sharp::interpreter::interopaccessmode::InteropAccessMode;
1283 )
1284 }
1285 }
1286
1287 #[doc = "`set_DefaultAccessMode(crate::moon_sharp::interpreter::interopaccessmode::InteropAccessMode)` overload"]
1288 pub fn set_default_access_mode(value: impl ::core::convert::Into<crate::moon_sharp::interpreter::interopaccessmode::InteropAccessMode>) -> () {
1289 unsafe {
1290 ::unity::il2cpp_call!(__UserData_unity_raw::__lookup_set_default_access_mode::get_method_info().method_ptr,();
1291(crate::moon_sharp::interpreter::interopaccessmode::InteropAccessMode)::core::convert::Into::into(value))
1292 }
1293 }
1294
1295 #[doc = "`RegisterExtensionType(::unity::SystemType, crate::moon_sharp::interpreter::interopaccessmode::InteropAccessMode)` overload"]
1296 pub fn register_extension_type(
1297 r#type: impl ::core::convert::Into<::unity::SystemType>,
1298 mode: impl ::core::convert::Into<crate::moon_sharp::interpreter::interopaccessmode::InteropAccessMode>,
1299 ) -> () {
1300 unsafe {
1301 ::unity::il2cpp_call!(__UserData_unity_raw::__lookup_register_extension_type::get_method_info().method_ptr,();
1302(::unity::SystemType)::core::convert::Into::into(r#type),(crate::moon_sharp::interpreter::interopaccessmode::InteropAccessMode)::core::convert::Into::into(mode))
1303 }
1304 }
1305
1306 #[doc = "`GetExtensionMethodsByNameAndType(::unity::Il2CppString, ::unity::SystemType)` overload"]
1307 pub fn get_extension_methods_by_name_and_type(
1308 name: impl ::core::convert::Into<::unity::Il2CppString>,
1309 extended_type: impl ::core::convert::Into<::unity::SystemType>,
1310 ) -> crate::system::collections::generic::list_1::List_1<
1311 crate::moon_sharp::interpreter::interop::basic_descriptors::ioverloadablememberdescriptor::IOverloadableMemberDescriptor,
1312 > {
1313 unsafe {
1314 ::unity::il2cpp_call!(__UserData_unity_raw::__lookup_get_extension_methods_by_name_and_type::get_method_info().method_ptr,crate::system::collections::generic::list_1::List_1<crate::moon_sharp::interpreter::interop::basic_descriptors::ioverloadablememberdescriptor::IOverloadableMemberDescriptor> ;
1315(::unity::Il2CppString)::core::convert::Into::into(name),(::unity::SystemType)::core::convert::Into::into(extended_type))
1316 }
1317 }
1318
1319 #[doc = "`GetExtensionMethodsChangeVersion()` overload"]
1320 pub fn get_extension_methods_change_version() -> i32 {
1321 unsafe {
1322 ::unity::il2cpp_call!(__UserData_unity_raw::__lookup_get_extension_methods_change_version::get_method_info().method_ptr,i32;
1323 )
1324 }
1325 }
1326
1327 pub fn get_descriptor_for_type<M0: ::unity::IlType + ::core::marker::Copy + ::unity::ClassIdentity>(
1328 search_interfaces: impl ::core::convert::Into<bool>,
1329 ) -> crate::moon_sharp::interpreter::interop::iuserdatadescriptor::IUserDataDescriptor {
1330 static OPEN: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1331 ::unity::lookup::method_info_on_class(<UserData as ::unity::ClassIdentity>::class(), "GetDescriptorForType", 1)
1332 });
1333 #[allow(clippy::type_complexity)]
1334 static CACHE: ::std::sync::OnceLock<::std::sync::Mutex<::std::collections::HashMap<usize, &'static ::unity::il2cpp::MethodInfo>>> =
1335 ::std::sync::OnceLock::new();
1336 let _ = true;
1337 let __open: &'static ::unity::il2cpp::MethodInfo = match &*OPEN {
1338 ::core::result::Result::Ok(mi) => *mi,
1339 ::core::result::Result::Err(e) => {
1340 panic!(
1341 "method lookup failed: {}
1342::{}
1343: {}
1344",
1345 <UserData as ::unity::ClassIdentity>::NAME,
1346 "GetDescriptorForType",
1347 e
1348 )
1349 },
1350 };
1351 let __cache = CACHE.get_or_init(|| ::std::sync::Mutex::new(::std::collections::HashMap::new()));
1352 let __key: usize = <M0 as ::unity::IlType>::il_type() as *const _ as usize;
1353 let __inflated: &'static ::unity::il2cpp::MethodInfo = {
1354 let mut __guard = __cache.lock().unwrap();
1355 *__guard
1356 .entry(__key)
1357 .or_insert_with(|| ::unity::il2cpp::generic::create_generic_method_info(__open, &[<M0 as ::unity::IlType>::il_type()]))
1358 };
1359 unsafe {
1360 let __f: extern "C" fn(
1361 bool,
1362 ::unity::OptionalMethod,
1363 ) -> crate::moon_sharp::interpreter::interop::iuserdatadescriptor::IUserDataDescriptor = ::core::mem::transmute(__inflated.method_ptr);
1364 let __mi_opaque: &'static () = &*(__inflated as *const _ as *const ());
1365 __f(::core::convert::Into::into(search_interfaces), ::core::option::Option::Some(__mi_opaque))
1366 }
1367 }
1368
1369 #[doc = "`GetDescriptorForType(::unity::SystemType, bool)` overload"]
1370 pub fn get_descriptor_for_type_2(
1371 r#type: impl ::core::convert::Into<::unity::SystemType>,
1372 search_interfaces: impl ::core::convert::Into<bool>,
1373 ) -> crate::moon_sharp::interpreter::interop::iuserdatadescriptor::IUserDataDescriptor {
1374 unsafe {
1375 ::unity::il2cpp_call!(__UserData_unity_raw::__lookup_get_descriptor_for_type_2::get_method_info().method_ptr,crate::moon_sharp::interpreter::interop::iuserdatadescriptor::IUserDataDescriptor;
1376(::unity::SystemType)::core::convert::Into::into(r#type),(bool)::core::convert::Into::into(search_interfaces))
1377 }
1378 }
1379
1380 #[doc = "`GetDescriptorForObject(crate::system::object::Object)` overload"]
1381 pub fn get_descriptor_for_object(
1382 o: impl ::core::convert::Into<crate::system::object::Object>,
1383 ) -> crate::moon_sharp::interpreter::interop::iuserdatadescriptor::IUserDataDescriptor {
1384 unsafe {
1385 ::unity::il2cpp_call!(__UserData_unity_raw::__lookup_get_descriptor_for_object::get_method_info().method_ptr,crate::moon_sharp::interpreter::interop::iuserdatadescriptor::IUserDataDescriptor;
1386(crate::system::object::Object)::core::convert::Into::into(o))
1387 }
1388 }
1389
1390 #[doc = "`GetDescriptionOfRegisteredTypes(bool)` overload"]
1391 pub fn get_description_of_registered_types(
1392 use_historical_data: impl ::core::convert::Into<bool>,
1393 ) -> crate::moon_sharp::interpreter::table::Table {
1394 unsafe {
1395 ::unity::il2cpp_call!(__UserData_unity_raw::__lookup_get_description_of_registered_types::get_method_info().method_ptr,crate::moon_sharp::interpreter::table::Table;
1396(bool)::core::convert::Into::into(use_historical_data))
1397 }
1398 }
1399
1400 #[doc = "`GetRegisteredTypes(bool)` overload"]
1401 pub fn get_registered_types(
1402 use_historical_data: impl ::core::convert::Into<bool>,
1403 ) -> crate::system::collections::generic::ienumerable_1::IEnumerable_1<::unity::SystemType> {
1404 unsafe {
1405 ::unity::il2cpp_call!(__UserData_unity_raw::__lookup_get_registered_types::get_method_info().method_ptr,crate::system::collections::generic::ienumerable_1::IEnumerable_1< ::unity::SystemType> ;
1406(bool)::core::convert::Into::into(use_historical_data))
1407 }
1408 }
1409}
1410
1411#[cfg(feature = "moon_sharp-interpreter-userdata")]
1412pub trait IUserDataMethods: IUserData {
1413 #[doc = "`.ctor()` overload"]
1414 fn ctor(self) -> () {
1415 unsafe {
1416 let __receiver = <UserData as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1417 ::unity::il2cpp_call!(__UserData_unity_raw::__lookup_ctor::get_method_info().method_ptr,();
1418(UserData)__receiver)
1419 }
1420 }
1421 #[doc = "`get_UserValue()` overload"]
1422 fn get_user_value(self) -> crate::moon_sharp::interpreter::dynvalue::DynValue {
1423 unsafe {
1424 let __receiver = <UserData as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1425 ::unity::il2cpp_call!(__UserData_unity_raw::__lookup_get_user_value::get_method_info().method_ptr,crate::moon_sharp::interpreter::dynvalue::DynValue;
1426(UserData)__receiver)
1427 }
1428 }
1429 #[doc = "`set_UserValue(crate::moon_sharp::interpreter::dynvalue::DynValue)` overload"]
1430 fn set_user_value(self, value: impl ::core::convert::Into<crate::moon_sharp::interpreter::dynvalue::DynValue>) -> () {
1431 unsafe {
1432 let __receiver = <UserData as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1433 ::unity::il2cpp_call!(__UserData_unity_raw::__lookup_set_user_value::get_method_info().method_ptr,();
1434(UserData)__receiver,(crate::moon_sharp::interpreter::dynvalue::DynValue)::core::convert::Into::into(value))
1435 }
1436 }
1437 #[doc = "`get_Object()` overload"]
1438 fn get_object(self) -> crate::system::object::Object {
1439 unsafe {
1440 let __receiver = <UserData as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1441 ::unity::il2cpp_call!(__UserData_unity_raw::__lookup_get_object::get_method_info().method_ptr,crate::system::object::Object;
1442(UserData)__receiver)
1443 }
1444 }
1445 #[doc = "`set_Object(crate::system::object::Object)` overload"]
1446 fn set_object(self, value: impl ::core::convert::Into<crate::system::object::Object>) -> () {
1447 unsafe {
1448 let __receiver = <UserData as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1449 ::unity::il2cpp_call!(__UserData_unity_raw::__lookup_set_object::get_method_info().method_ptr,();
1450(UserData)__receiver,(crate::system::object::Object)::core::convert::Into::into(value))
1451 }
1452 }
1453 #[doc = "`get_Descriptor()` overload"]
1454 fn get_descriptor(self) -> crate::moon_sharp::interpreter::interop::iuserdatadescriptor::IUserDataDescriptor {
1455 unsafe {
1456 let __receiver = <UserData as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1457 ::unity::il2cpp_call!(__UserData_unity_raw::__lookup_get_descriptor::get_method_info().method_ptr,crate::moon_sharp::interpreter::interop::iuserdatadescriptor::IUserDataDescriptor;
1458(UserData)__receiver)
1459 }
1460 }
1461 #[doc = "`set_Descriptor(crate::moon_sharp::interpreter::interop::iuserdatadescriptor::IUserDataDescriptor)` overload"]
1462 fn set_descriptor(
1463 self,
1464 value: impl ::core::convert::Into<crate::moon_sharp::interpreter::interop::iuserdatadescriptor::IUserDataDescriptor>,
1465 ) -> () {
1466 unsafe {
1467 let __receiver = <UserData as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1468 ::unity::il2cpp_call!(__UserData_unity_raw::__lookup_set_descriptor::get_method_info().method_ptr,();
1469(UserData)__receiver,(crate::moon_sharp::interpreter::interop::iuserdatadescriptor::IUserDataDescriptor)::core::convert::Into::into(value))
1470 }
1471 }
1472}
1473
1474#[cfg(feature = "moon_sharp-interpreter-userdata")]
1475impl<__T: IUserData> IUserDataMethods for __T {}
1476
1477#[cfg(feature = "moon_sharp-interpreter-userdata")]
1478impl UserData {
1479 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1480 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
1481 }
1482
1483 pub fn get_user_value_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1484 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
1485 }
1486
1487 pub fn set_user_value_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1488 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
1489 }
1490
1491 pub fn get_object_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1492 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
1493 }
1494
1495 pub fn set_object_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1496 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
1497 }
1498
1499 pub fn get_descriptor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1500 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
1501 }
1502
1503 pub fn set_descriptor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1504 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
1505 }
1506
1507 pub fn cctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1508 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
1509 }
1510
1511 pub fn register_type_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1512 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[9]
1513 }
1514
1515 pub fn register_proxy_type_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1516 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[10]
1517 }
1518
1519 pub fn register_type_4_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1520 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[13]
1521 }
1522
1523 pub fn register_assembly_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1524 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[15]
1525 }
1526
1527 pub fn is_type_registered_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1528 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[16]
1529 }
1530
1531 pub fn unregister_type_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1532 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[19]
1533 }
1534
1535 pub fn create_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1536 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[20]
1537 }
1538
1539 pub fn create_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1540 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[21]
1541 }
1542
1543 pub fn create_static_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1544 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[22]
1545 }
1546
1547 pub fn create_static_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1548 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[23]
1549 }
1550
1551 pub fn get_registration_policy_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1552 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[25]
1553 }
1554
1555 pub fn set_registration_policy_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1556 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[26]
1557 }
1558
1559 pub fn get_default_access_mode_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1560 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[27]
1561 }
1562
1563 pub fn set_default_access_mode_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1564 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[28]
1565 }
1566
1567 pub fn register_extension_type_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1568 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[29]
1569 }
1570
1571 pub fn get_extension_methods_by_name_and_type_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1572 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[30]
1573 }
1574
1575 pub fn get_extension_methods_change_version_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1576 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[31]
1577 }
1578
1579 pub fn get_descriptor_for_type_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1580 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[33]
1581 }
1582
1583 pub fn get_descriptor_for_object_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1584 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[34]
1585 }
1586
1587 pub fn get_description_of_registered_types_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1588 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[35]
1589 }
1590
1591 pub fn get_registered_types_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1592 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[36]
1593 }
1594}
1595
1596#[cfg(feature = "moon_sharp-interpreter-userdata")]
1597impl UserData {
1598 #[doc = "`.ctor()` — no args"]
1599 pub fn new() -> Self {
1600 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1601 panic!(
1602 "{}
1603::{}
1604 failed to instantiate",
1605 ::core::stringify!(UserData),
1606 ::core::stringify!(new),
1607 )
1608 });
1609 <Self as IUserDataMethods>::ctor(this);
1610 this
1611 }
1612}
1613
1614#[cfg(feature = "moon_sharp-interpreter-userdata")]
1615#[doc(hidden)]
1616pub mod prelude {
1617 pub use super::{IUserData, IUserDataMethods, UserData};
1618 #[cfg(feature = "moon_sharp-interpreter-refidobject")]
1619 pub use crate::moon_sharp::interpreter::refidobject::IRefIdObjectMethods;
1620 #[cfg(feature = "system-object")]
1621 pub use crate::system::object::IObjectMethods;
1622 pub use crate::{moon_sharp::interpreter::refidobject::IRefIdObject, system::object::IObject};
1623}