1#[cfg(feature = "moon_sharp-interpreter-dynvalue-types")]
4mod __types {
5 #[allow(unused_imports)] use ::unity::prelude::*;
6
7 use super::*;
8 use crate::system::object::{IObject, Object};
9
10 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/moon_sharp/interpreter/dynvalue/DynValue.md"))]
11 #[::unity::class(namespace = "MoonSharp.Interpreter", name = "DynValue")]
12 #[parent(crate::system::object::Object)]
13 pub struct DynValue {
14 #[static_field]
15 #[rename(name = "s_RefIDCounter")]
16 pub s_ref_id_counter: i32,
17 #[offset(16)]
18 #[rename(name = "m_RefID")]
19 pub m_ref_id: i32,
20 #[offset(20)]
21 #[rename(name = "m_HashCode")]
22 pub m_hash_code: i32,
23 #[offset(24)]
24 #[rename(name = "m_ReadOnly")]
25 pub m_read_only: bool,
26 #[offset(32)]
27 #[rename(name = "m_Number")]
28 pub m_number: f64,
29 #[offset(40)]
30 #[rename(name = "m_Object")]
31 pub m_object: ::unity::IlInstance,
32 #[offset(48)]
33 #[rename(name = "m_Type")]
34 pub m_type: crate::moon_sharp::interpreter::datatype::DataType,
35 }
36}
37
38#[cfg(feature = "moon_sharp-interpreter-dynvalue-types")]
39pub use __types::*;
40
41#[cfg(feature = "moon_sharp-interpreter-dynvalue")]
42#[doc(hidden)]
43#[allow(non_snake_case, non_camel_case_types, clippy::too_many_arguments)]
44mod __DynValue_unity_raw {
45 use super::*;
46 #[doc(hidden)]
47 #[allow(non_snake_case)]
48 pub mod __lookup_get_reference_id {
49 use super::*;
50 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
51 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
52 ::unity::lookup::method_info_on_class_with_signature(
53 <DynValue as ::unity::ClassIdentity>::class(),
54 "get_ReferenceID",
55 0,
56 param_types,
57 false,
58 )
59 });
60 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
61 match &*METHOD {
62 ::core::result::Result::Ok(mi) => *mi,
63 ::core::result::Result::Err(e) => {
64 panic!(
65 "method lookup failed: {}
66::{}
67: {}
68",
69 <DynValue as ::unity::ClassIdentity>::NAME,
70 "get_ReferenceID",
71 e
72 )
73 },
74 }
75 }
76 }
77 #[doc(hidden)]
78 #[allow(non_snake_case)]
79 pub mod __lookup_get_type {
80 use super::*;
81 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
82 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
83 ::unity::lookup::method_info_on_class_with_signature(<DynValue as ::unity::ClassIdentity>::class(), "get_Type", 0, param_types, false)
84 });
85 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
86 match &*METHOD {
87 ::core::result::Result::Ok(mi) => *mi,
88 ::core::result::Result::Err(e) => {
89 panic!(
90 "method lookup failed: {}
91::{}
92: {}
93",
94 <DynValue as ::unity::ClassIdentity>::NAME,
95 "get_Type",
96 e
97 )
98 },
99 }
100 }
101 }
102 #[doc(hidden)]
103 #[allow(non_snake_case)]
104 pub mod __lookup_get_function {
105 use super::*;
106 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
107 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
108 ::unity::lookup::method_info_on_class_with_signature(<DynValue as ::unity::ClassIdentity>::class(), "get_Function", 0, param_types, false)
109 });
110 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
111 match &*METHOD {
112 ::core::result::Result::Ok(mi) => *mi,
113 ::core::result::Result::Err(e) => {
114 panic!(
115 "method lookup failed: {}
116::{}
117: {}
118",
119 <DynValue as ::unity::ClassIdentity>::NAME,
120 "get_Function",
121 e
122 )
123 },
124 }
125 }
126 }
127 #[doc(hidden)]
128 #[allow(non_snake_case)]
129 pub mod __lookup_get_number {
130 use super::*;
131 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
132 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
133 ::unity::lookup::method_info_on_class_with_signature(<DynValue as ::unity::ClassIdentity>::class(), "get_Number", 0, param_types, false)
134 });
135 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
136 match &*METHOD {
137 ::core::result::Result::Ok(mi) => *mi,
138 ::core::result::Result::Err(e) => {
139 panic!(
140 "method lookup failed: {}
141::{}
142: {}
143",
144 <DynValue as ::unity::ClassIdentity>::NAME,
145 "get_Number",
146 e
147 )
148 },
149 }
150 }
151 }
152 #[doc(hidden)]
153 #[allow(non_snake_case)]
154 pub mod __lookup_get_tuple {
155 use super::*;
156 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
157 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
158 ::unity::lookup::method_info_on_class_with_signature(<DynValue as ::unity::ClassIdentity>::class(), "get_Tuple", 0, param_types, false)
159 });
160 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
161 match &*METHOD {
162 ::core::result::Result::Ok(mi) => *mi,
163 ::core::result::Result::Err(e) => {
164 panic!(
165 "method lookup failed: {}
166::{}
167: {}
168",
169 <DynValue as ::unity::ClassIdentity>::NAME,
170 "get_Tuple",
171 e
172 )
173 },
174 }
175 }
176 }
177 #[doc(hidden)]
178 #[allow(non_snake_case)]
179 pub mod __lookup_get_coroutine {
180 use super::*;
181 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
182 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
183 ::unity::lookup::method_info_on_class_with_signature(
184 <DynValue as ::unity::ClassIdentity>::class(),
185 "get_Coroutine",
186 0,
187 param_types,
188 false,
189 )
190 });
191 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
192 match &*METHOD {
193 ::core::result::Result::Ok(mi) => *mi,
194 ::core::result::Result::Err(e) => {
195 panic!(
196 "method lookup failed: {}
197::{}
198: {}
199",
200 <DynValue as ::unity::ClassIdentity>::NAME,
201 "get_Coroutine",
202 e
203 )
204 },
205 }
206 }
207 }
208 #[doc(hidden)]
209 #[allow(non_snake_case)]
210 pub mod __lookup_get_table {
211 use super::*;
212 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
213 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
214 ::unity::lookup::method_info_on_class_with_signature(<DynValue as ::unity::ClassIdentity>::class(), "get_Table", 0, param_types, false)
215 });
216 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
217 match &*METHOD {
218 ::core::result::Result::Ok(mi) => *mi,
219 ::core::result::Result::Err(e) => {
220 panic!(
221 "method lookup failed: {}
222::{}
223: {}
224",
225 <DynValue as ::unity::ClassIdentity>::NAME,
226 "get_Table",
227 e
228 )
229 },
230 }
231 }
232 }
233 #[doc(hidden)]
234 #[allow(non_snake_case)]
235 pub mod __lookup_get_boolean {
236 use super::*;
237 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
238 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
239 ::unity::lookup::method_info_on_class_with_signature(<DynValue as ::unity::ClassIdentity>::class(), "get_Boolean", 0, param_types, false)
240 });
241 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
242 match &*METHOD {
243 ::core::result::Result::Ok(mi) => *mi,
244 ::core::result::Result::Err(e) => {
245 panic!(
246 "method lookup failed: {}
247::{}
248: {}
249",
250 <DynValue as ::unity::ClassIdentity>::NAME,
251 "get_Boolean",
252 e
253 )
254 },
255 }
256 }
257 }
258 #[doc(hidden)]
259 #[allow(non_snake_case)]
260 pub mod __lookup_get_string {
261 use super::*;
262 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
263 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
264 ::unity::lookup::method_info_on_class_with_signature(<DynValue as ::unity::ClassIdentity>::class(), "get_String", 0, param_types, false)
265 });
266 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
267 match &*METHOD {
268 ::core::result::Result::Ok(mi) => *mi,
269 ::core::result::Result::Err(e) => {
270 panic!(
271 "method lookup failed: {}
272::{}
273: {}
274",
275 <DynValue as ::unity::ClassIdentity>::NAME,
276 "get_String",
277 e
278 )
279 },
280 }
281 }
282 }
283 #[doc(hidden)]
284 #[allow(non_snake_case)]
285 pub mod __lookup_get_callback {
286 use super::*;
287 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
288 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
289 ::unity::lookup::method_info_on_class_with_signature(<DynValue as ::unity::ClassIdentity>::class(), "get_Callback", 0, param_types, false)
290 });
291 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
292 match &*METHOD {
293 ::core::result::Result::Ok(mi) => *mi,
294 ::core::result::Result::Err(e) => {
295 panic!(
296 "method lookup failed: {}
297::{}
298: {}
299",
300 <DynValue as ::unity::ClassIdentity>::NAME,
301 "get_Callback",
302 e
303 )
304 },
305 }
306 }
307 }
308 #[doc(hidden)]
309 #[allow(non_snake_case)]
310 pub mod __lookup_get_tail_call_data {
311 use super::*;
312 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
313 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
314 ::unity::lookup::method_info_on_class_with_signature(
315 <DynValue as ::unity::ClassIdentity>::class(),
316 "get_TailCallData",
317 0,
318 param_types,
319 false,
320 )
321 });
322 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
323 match &*METHOD {
324 ::core::result::Result::Ok(mi) => *mi,
325 ::core::result::Result::Err(e) => {
326 panic!(
327 "method lookup failed: {}
328::{}
329: {}
330",
331 <DynValue as ::unity::ClassIdentity>::NAME,
332 "get_TailCallData",
333 e
334 )
335 },
336 }
337 }
338 }
339 #[doc(hidden)]
340 #[allow(non_snake_case)]
341 pub mod __lookup_get_yield_request {
342 use super::*;
343 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
344 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
345 ::unity::lookup::method_info_on_class_with_signature(
346 <DynValue as ::unity::ClassIdentity>::class(),
347 "get_YieldRequest",
348 0,
349 param_types,
350 false,
351 )
352 });
353 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
354 match &*METHOD {
355 ::core::result::Result::Ok(mi) => *mi,
356 ::core::result::Result::Err(e) => {
357 panic!(
358 "method lookup failed: {}
359::{}
360: {}
361",
362 <DynValue as ::unity::ClassIdentity>::NAME,
363 "get_YieldRequest",
364 e
365 )
366 },
367 }
368 }
369 }
370 #[doc(hidden)]
371 #[allow(non_snake_case)]
372 pub mod __lookup_get_user_data {
373 use super::*;
374 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
375 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
376 ::unity::lookup::method_info_on_class_with_signature(<DynValue as ::unity::ClassIdentity>::class(), "get_UserData", 0, param_types, false)
377 });
378 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
379 match &*METHOD {
380 ::core::result::Result::Ok(mi) => *mi,
381 ::core::result::Result::Err(e) => {
382 panic!(
383 "method lookup failed: {}
384::{}
385: {}
386",
387 <DynValue as ::unity::ClassIdentity>::NAME,
388 "get_UserData",
389 e
390 )
391 },
392 }
393 }
394 }
395 #[doc(hidden)]
396 #[allow(non_snake_case)]
397 pub mod __lookup_get_read_only {
398 use super::*;
399 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
400 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
401 ::unity::lookup::method_info_on_class_with_signature(<DynValue as ::unity::ClassIdentity>::class(), "get_ReadOnly", 0, param_types, false)
402 });
403 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
404 match &*METHOD {
405 ::core::result::Result::Ok(mi) => *mi,
406 ::core::result::Result::Err(e) => {
407 panic!(
408 "method lookup failed: {}
409::{}
410: {}
411",
412 <DynValue as ::unity::ClassIdentity>::NAME,
413 "get_ReadOnly",
414 e
415 )
416 },
417 }
418 }
419 }
420 #[doc(hidden)]
421 #[allow(non_snake_case)]
422 pub mod __lookup_new_nil {
423 use super::*;
424 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
425 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
426 ::unity::lookup::method_info_on_class_with_signature(<DynValue as ::unity::ClassIdentity>::class(), "NewNil", 0, param_types, true)
427 });
428 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
429 match &*METHOD {
430 ::core::result::Result::Ok(mi) => *mi,
431 ::core::result::Result::Err(e) => {
432 panic!(
433 "method lookup failed: {}
434::{}
435: {}
436",
437 <DynValue as ::unity::ClassIdentity>::NAME,
438 "NewNil",
439 e
440 )
441 },
442 }
443 }
444 }
445 #[doc(hidden)]
446 #[allow(non_snake_case)]
447 pub mod __lookup_new_boolean {
448 use super::*;
449 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
450 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[<bool as ::unity::IlType>::il_type()];
451 ::unity::lookup::method_info_on_class_with_signature(<DynValue as ::unity::ClassIdentity>::class(), "NewBoolean", 1, param_types, true)
452 });
453 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
454 match &*METHOD {
455 ::core::result::Result::Ok(mi) => *mi,
456 ::core::result::Result::Err(e) => {
457 panic!(
458 "method lookup failed: {}
459::{}
460: {}
461",
462 <DynValue as ::unity::ClassIdentity>::NAME,
463 "NewBoolean",
464 e
465 )
466 },
467 }
468 }
469 }
470 #[doc(hidden)]
471 #[allow(non_snake_case)]
472 pub mod __lookup_new_number {
473 use super::*;
474 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
475 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[<f64 as ::unity::IlType>::il_type()];
476 ::unity::lookup::method_info_on_class_with_signature(<DynValue as ::unity::ClassIdentity>::class(), "NewNumber", 1, param_types, true)
477 });
478 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
479 match &*METHOD {
480 ::core::result::Result::Ok(mi) => *mi,
481 ::core::result::Result::Err(e) => {
482 panic!(
483 "method lookup failed: {}
484::{}
485: {}
486",
487 <DynValue as ::unity::ClassIdentity>::NAME,
488 "NewNumber",
489 e
490 )
491 },
492 }
493 }
494 }
495 #[doc(hidden)]
496 #[allow(non_snake_case)]
497 pub mod __lookup_new_string {
498 use super::*;
499 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
500 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[<::unity::Il2CppString as ::unity::IlType>::il_type()];
501 ::unity::lookup::method_info_on_class_with_signature(<DynValue as ::unity::ClassIdentity>::class(), "NewString", 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 <DynValue as ::unity::ClassIdentity>::NAME,
513 "NewString",
514 e
515 )
516 },
517 }
518 }
519 }
520 #[doc(hidden)]
521 #[allow(non_snake_case)]
522 pub mod __lookup_new_string_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] = &[
526 <::unity::Il2CppString as ::unity::IlType>::il_type(),
527 <::unity::Array<crate::system::object::Object> as ::unity::IlType>::il_type(),
528 ];
529 ::unity::lookup::method_info_on_class_with_signature(<DynValue as ::unity::ClassIdentity>::class(), "NewString", 2, param_types, true)
530 });
531 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
532 match &*METHOD {
533 ::core::result::Result::Ok(mi) => *mi,
534 ::core::result::Result::Err(e) => {
535 panic!(
536 "method lookup failed: {}
537::{}
538: {}
539",
540 <DynValue as ::unity::ClassIdentity>::NAME,
541 "NewString",
542 e
543 )
544 },
545 }
546 }
547 }
548 #[doc(hidden)]
549 #[allow(non_snake_case)]
550 pub mod __lookup_new_coroutine {
551 use super::*;
552 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
553 let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
554 &[<crate::moon_sharp::interpreter::coroutine_2::Coroutine_2 as ::unity::IlType>::il_type()];
555 ::unity::lookup::method_info_on_class_with_signature(<DynValue as ::unity::ClassIdentity>::class(), "NewCoroutine", 1, param_types, true)
556 });
557 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
558 match &*METHOD {
559 ::core::result::Result::Ok(mi) => *mi,
560 ::core::result::Result::Err(e) => {
561 panic!(
562 "method lookup failed: {}
563::{}
564: {}
565",
566 <DynValue as ::unity::ClassIdentity>::NAME,
567 "NewCoroutine",
568 e
569 )
570 },
571 }
572 }
573 }
574 #[doc(hidden)]
575 #[allow(non_snake_case)]
576 pub mod __lookup_new_closure {
577 use super::*;
578 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
579 let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
580 &[<crate::moon_sharp::interpreter::closure::Closure as ::unity::IlType>::il_type()];
581 ::unity::lookup::method_info_on_class_with_signature(<DynValue as ::unity::ClassIdentity>::class(), "NewClosure", 1, param_types, true)
582 });
583 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
584 match &*METHOD {
585 ::core::result::Result::Ok(mi) => *mi,
586 ::core::result::Result::Err(e) => {
587 panic!(
588 "method lookup failed: {}
589::{}
590: {}
591",
592 <DynValue as ::unity::ClassIdentity>::NAME,
593 "NewClosure",
594 e
595 )
596 },
597 }
598 }
599 }
600 #[doc(hidden)]
601 #[allow(non_snake_case)]
602 pub mod __lookup_new_callback {
603 use super::*;
604 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
605 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
606 <crate::system::func_3::Func_3<
607 crate::moon_sharp::interpreter::scriptexecutioncontext::ScriptExecutionContext,
608 crate::moon_sharp::interpreter::callbackarguments::CallbackArguments,
609 crate::moon_sharp::interpreter::dynvalue::DynValue,
610 > as ::unity::IlType>::il_type(),
611 <::unity::Il2CppString as ::unity::IlType>::il_type(),
612 ];
613 ::unity::lookup::method_info_on_class_with_signature(<DynValue as ::unity::ClassIdentity>::class(), "NewCallback", 2, param_types, true)
614 });
615 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
616 match &*METHOD {
617 ::core::result::Result::Ok(mi) => *mi,
618 ::core::result::Result::Err(e) => {
619 panic!(
620 "method lookup failed: {}
621::{}
622: {}
623",
624 <DynValue as ::unity::ClassIdentity>::NAME,
625 "NewCallback",
626 e
627 )
628 },
629 }
630 }
631 }
632 #[doc(hidden)]
633 #[allow(non_snake_case)]
634 pub mod __lookup_new_callback_2 {
635 use super::*;
636 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
637 let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
638 &[<crate::moon_sharp::interpreter::callbackfunction::CallbackFunction as ::unity::IlType>::il_type()];
639 ::unity::lookup::method_info_on_class_with_signature(<DynValue as ::unity::ClassIdentity>::class(), "NewCallback", 1, param_types, true)
640 });
641 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
642 match &*METHOD {
643 ::core::result::Result::Ok(mi) => *mi,
644 ::core::result::Result::Err(e) => {
645 panic!(
646 "method lookup failed: {}
647::{}
648: {}
649",
650 <DynValue as ::unity::ClassIdentity>::NAME,
651 "NewCallback",
652 e
653 )
654 },
655 }
656 }
657 }
658 #[doc(hidden)]
659 #[allow(non_snake_case)]
660 pub mod __lookup_new_table {
661 use super::*;
662 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
663 let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
664 &[<crate::moon_sharp::interpreter::table::Table as ::unity::IlType>::il_type()];
665 ::unity::lookup::method_info_on_class_with_signature(<DynValue as ::unity::ClassIdentity>::class(), "NewTable", 1, param_types, true)
666 });
667 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
668 match &*METHOD {
669 ::core::result::Result::Ok(mi) => *mi,
670 ::core::result::Result::Err(e) => {
671 panic!(
672 "method lookup failed: {}
673::{}
674: {}
675",
676 <DynValue as ::unity::ClassIdentity>::NAME,
677 "NewTable",
678 e
679 )
680 },
681 }
682 }
683 }
684 #[doc(hidden)]
685 #[allow(non_snake_case)]
686 pub mod __lookup_new_prime_table {
687 use super::*;
688 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
689 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
690 ::unity::lookup::method_info_on_class_with_signature(<DynValue as ::unity::ClassIdentity>::class(), "NewPrimeTable", 0, param_types, true)
691 });
692 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
693 match &*METHOD {
694 ::core::result::Result::Ok(mi) => *mi,
695 ::core::result::Result::Err(e) => {
696 panic!(
697 "method lookup failed: {}
698::{}
699: {}
700",
701 <DynValue as ::unity::ClassIdentity>::NAME,
702 "NewPrimeTable",
703 e
704 )
705 },
706 }
707 }
708 }
709 #[doc(hidden)]
710 #[allow(non_snake_case)]
711 pub mod __lookup_new_table_2 {
712 use super::*;
713 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
714 let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
715 &[<crate::moon_sharp::interpreter::script::Script as ::unity::IlType>::il_type()];
716 ::unity::lookup::method_info_on_class_with_signature(<DynValue as ::unity::ClassIdentity>::class(), "NewTable", 1, param_types, true)
717 });
718 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
719 match &*METHOD {
720 ::core::result::Result::Ok(mi) => *mi,
721 ::core::result::Result::Err(e) => {
722 panic!(
723 "method lookup failed: {}
724::{}
725: {}
726",
727 <DynValue as ::unity::ClassIdentity>::NAME,
728 "NewTable",
729 e
730 )
731 },
732 }
733 }
734 }
735 #[doc(hidden)]
736 #[allow(non_snake_case)]
737 pub mod __lookup_new_table_3 {
738 use super::*;
739 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
740 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
741 <crate::moon_sharp::interpreter::script::Script as ::unity::IlType>::il_type(),
742 <::unity::Array<crate::moon_sharp::interpreter::dynvalue::DynValue> as ::unity::IlType>::il_type(),
743 ];
744 ::unity::lookup::method_info_on_class_with_signature(<DynValue as ::unity::ClassIdentity>::class(), "NewTable", 2, param_types, true)
745 });
746 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
747 match &*METHOD {
748 ::core::result::Result::Ok(mi) => *mi,
749 ::core::result::Result::Err(e) => {
750 panic!(
751 "method lookup failed: {}
752::{}
753: {}
754",
755 <DynValue as ::unity::ClassIdentity>::NAME,
756 "NewTable",
757 e
758 )
759 },
760 }
761 }
762 }
763 #[doc(hidden)]
764 #[allow(non_snake_case)]
765 pub mod __lookup_new_tail_call_req {
766 use super::*;
767 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
768 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
769 <crate::moon_sharp::interpreter::dynvalue::DynValue as ::unity::IlType>::il_type(),
770 <::unity::Array<crate::moon_sharp::interpreter::dynvalue::DynValue> as ::unity::IlType>::il_type(),
771 ];
772 ::unity::lookup::method_info_on_class_with_signature(
773 <DynValue as ::unity::ClassIdentity>::class(),
774 "NewTailCallReq",
775 2,
776 param_types,
777 true,
778 )
779 });
780 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
781 match &*METHOD {
782 ::core::result::Result::Ok(mi) => *mi,
783 ::core::result::Result::Err(e) => {
784 panic!(
785 "method lookup failed: {}
786::{}
787: {}
788",
789 <DynValue as ::unity::ClassIdentity>::NAME,
790 "NewTailCallReq",
791 e
792 )
793 },
794 }
795 }
796 }
797 #[doc(hidden)]
798 #[allow(non_snake_case)]
799 pub mod __lookup_new_tail_call_req_2 {
800 use super::*;
801 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
802 let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
803 &[<crate::moon_sharp::interpreter::tailcalldata::TailCallData as ::unity::IlType>::il_type()];
804 ::unity::lookup::method_info_on_class_with_signature(
805 <DynValue as ::unity::ClassIdentity>::class(),
806 "NewTailCallReq",
807 1,
808 param_types,
809 true,
810 )
811 });
812 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
813 match &*METHOD {
814 ::core::result::Result::Ok(mi) => *mi,
815 ::core::result::Result::Err(e) => {
816 panic!(
817 "method lookup failed: {}
818::{}
819: {}
820",
821 <DynValue as ::unity::ClassIdentity>::NAME,
822 "NewTailCallReq",
823 e
824 )
825 },
826 }
827 }
828 }
829 #[doc(hidden)]
830 #[allow(non_snake_case)]
831 pub mod __lookup_new_yield_req {
832 use super::*;
833 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
834 let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
835 &[<::unity::Array<crate::moon_sharp::interpreter::dynvalue::DynValue> as ::unity::IlType>::il_type()];
836 ::unity::lookup::method_info_on_class_with_signature(<DynValue as ::unity::ClassIdentity>::class(), "NewYieldReq", 1, param_types, true)
837 });
838 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
839 match &*METHOD {
840 ::core::result::Result::Ok(mi) => *mi,
841 ::core::result::Result::Err(e) => {
842 panic!(
843 "method lookup failed: {}
844::{}
845: {}
846",
847 <DynValue as ::unity::ClassIdentity>::NAME,
848 "NewYieldReq",
849 e
850 )
851 },
852 }
853 }
854 }
855 #[doc(hidden)]
856 #[allow(non_snake_case)]
857 pub mod __lookup_new_forced_yield_req {
858 use super::*;
859 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
860 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
861 ::unity::lookup::method_info_on_class_with_signature(
862 <DynValue as ::unity::ClassIdentity>::class(),
863 "NewForcedYieldReq",
864 0,
865 param_types,
866 true,
867 )
868 });
869 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
870 match &*METHOD {
871 ::core::result::Result::Ok(mi) => *mi,
872 ::core::result::Result::Err(e) => {
873 panic!(
874 "method lookup failed: {}
875::{}
876: {}
877",
878 <DynValue as ::unity::ClassIdentity>::NAME,
879 "NewForcedYieldReq",
880 e
881 )
882 },
883 }
884 }
885 }
886 #[doc(hidden)]
887 #[allow(non_snake_case)]
888 pub mod __lookup_new_tuple {
889 use super::*;
890 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
891 let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
892 &[<::unity::Array<crate::moon_sharp::interpreter::dynvalue::DynValue> as ::unity::IlType>::il_type()];
893 ::unity::lookup::method_info_on_class_with_signature(<DynValue as ::unity::ClassIdentity>::class(), "NewTuple", 1, param_types, true)
894 });
895 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
896 match &*METHOD {
897 ::core::result::Result::Ok(mi) => *mi,
898 ::core::result::Result::Err(e) => {
899 panic!(
900 "method lookup failed: {}
901::{}
902: {}
903",
904 <DynValue as ::unity::ClassIdentity>::NAME,
905 "NewTuple",
906 e
907 )
908 },
909 }
910 }
911 }
912 #[doc(hidden)]
913 #[allow(non_snake_case)]
914 pub mod __lookup_new_tuple_nested {
915 use super::*;
916 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
917 let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
918 &[<::unity::Array<crate::moon_sharp::interpreter::dynvalue::DynValue> as ::unity::IlType>::il_type()];
919 ::unity::lookup::method_info_on_class_with_signature(
920 <DynValue as ::unity::ClassIdentity>::class(),
921 "NewTupleNested",
922 1,
923 param_types,
924 true,
925 )
926 });
927 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
928 match &*METHOD {
929 ::core::result::Result::Ok(mi) => *mi,
930 ::core::result::Result::Err(e) => {
931 panic!(
932 "method lookup failed: {}
933::{}
934: {}
935",
936 <DynValue as ::unity::ClassIdentity>::NAME,
937 "NewTupleNested",
938 e
939 )
940 },
941 }
942 }
943 }
944 #[doc(hidden)]
945 #[allow(non_snake_case)]
946 pub mod __lookup_new_user_data {
947 use super::*;
948 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
949 let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
950 &[<crate::moon_sharp::interpreter::userdata::UserData as ::unity::IlType>::il_type()];
951 ::unity::lookup::method_info_on_class_with_signature(<DynValue as ::unity::ClassIdentity>::class(), "NewUserData", 1, param_types, true)
952 });
953 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
954 match &*METHOD {
955 ::core::result::Result::Ok(mi) => *mi,
956 ::core::result::Result::Err(e) => {
957 panic!(
958 "method lookup failed: {}
959::{}
960: {}
961",
962 <DynValue as ::unity::ClassIdentity>::NAME,
963 "NewUserData",
964 e
965 )
966 },
967 }
968 }
969 }
970 #[doc(hidden)]
971 #[allow(non_snake_case)]
972 pub mod __lookup_as_read_only {
973 use super::*;
974 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
975 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
976 ::unity::lookup::method_info_on_class_with_signature(<DynValue as ::unity::ClassIdentity>::class(), "AsReadOnly", 0, param_types, false)
977 });
978 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
979 match &*METHOD {
980 ::core::result::Result::Ok(mi) => *mi,
981 ::core::result::Result::Err(e) => {
982 panic!(
983 "method lookup failed: {}
984::{}
985: {}
986",
987 <DynValue as ::unity::ClassIdentity>::NAME,
988 "AsReadOnly",
989 e
990 )
991 },
992 }
993 }
994 }
995 #[doc(hidden)]
996 #[allow(non_snake_case)]
997 pub mod __lookup_clone {
998 use super::*;
999 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1000 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
1001 ::unity::lookup::method_info_on_class_with_signature(<DynValue as ::unity::ClassIdentity>::class(), "Clone", 0, param_types, false)
1002 });
1003 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1004 match &*METHOD {
1005 ::core::result::Result::Ok(mi) => *mi,
1006 ::core::result::Result::Err(e) => {
1007 panic!(
1008 "method lookup failed: {}
1009::{}
1010: {}
1011",
1012 <DynValue as ::unity::ClassIdentity>::NAME,
1013 "Clone",
1014 e
1015 )
1016 },
1017 }
1018 }
1019 }
1020 #[doc(hidden)]
1021 #[allow(non_snake_case)]
1022 pub mod __lookup_clone_2 {
1023 use super::*;
1024 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1025 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[<bool as ::unity::IlType>::il_type()];
1026 ::unity::lookup::method_info_on_class_with_signature(<DynValue as ::unity::ClassIdentity>::class(), "Clone", 1, param_types, false)
1027 });
1028 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1029 match &*METHOD {
1030 ::core::result::Result::Ok(mi) => *mi,
1031 ::core::result::Result::Err(e) => {
1032 panic!(
1033 "method lookup failed: {}
1034::{}
1035: {}
1036",
1037 <DynValue as ::unity::ClassIdentity>::NAME,
1038 "Clone",
1039 e
1040 )
1041 },
1042 }
1043 }
1044 }
1045 #[doc(hidden)]
1046 #[allow(non_snake_case)]
1047 pub mod __lookup_clone_as_writable {
1048 use super::*;
1049 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1050 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
1051 ::unity::lookup::method_info_on_class_with_signature(
1052 <DynValue as ::unity::ClassIdentity>::class(),
1053 "CloneAsWritable",
1054 0,
1055 param_types,
1056 false,
1057 )
1058 });
1059 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1060 match &*METHOD {
1061 ::core::result::Result::Ok(mi) => *mi,
1062 ::core::result::Result::Err(e) => {
1063 panic!(
1064 "method lookup failed: {}
1065::{}
1066: {}
1067",
1068 <DynValue as ::unity::ClassIdentity>::NAME,
1069 "CloneAsWritable",
1070 e
1071 )
1072 },
1073 }
1074 }
1075 }
1076 #[doc(hidden)]
1077 #[allow(non_snake_case)]
1078 pub mod __lookup_get_void {
1079 use super::*;
1080 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1081 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
1082 ::unity::lookup::method_info_on_class_with_signature(<DynValue as ::unity::ClassIdentity>::class(), "get_Void", 0, param_types, true)
1083 });
1084 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1085 match &*METHOD {
1086 ::core::result::Result::Ok(mi) => *mi,
1087 ::core::result::Result::Err(e) => {
1088 panic!(
1089 "method lookup failed: {}
1090::{}
1091: {}
1092",
1093 <DynValue as ::unity::ClassIdentity>::NAME,
1094 "get_Void",
1095 e
1096 )
1097 },
1098 }
1099 }
1100 }
1101 #[doc(hidden)]
1102 #[allow(non_snake_case)]
1103 pub mod __lookup_set_void {
1104 use super::*;
1105 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1106 let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
1107 &[<crate::moon_sharp::interpreter::dynvalue::DynValue as ::unity::IlType>::il_type()];
1108 ::unity::lookup::method_info_on_class_with_signature(<DynValue as ::unity::ClassIdentity>::class(), "set_Void", 1, param_types, true)
1109 });
1110 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1111 match &*METHOD {
1112 ::core::result::Result::Ok(mi) => *mi,
1113 ::core::result::Result::Err(e) => {
1114 panic!(
1115 "method lookup failed: {}
1116::{}
1117: {}
1118",
1119 <DynValue as ::unity::ClassIdentity>::NAME,
1120 "set_Void",
1121 e
1122 )
1123 },
1124 }
1125 }
1126 }
1127 #[doc(hidden)]
1128 #[allow(non_snake_case)]
1129 pub mod __lookup_get_nil {
1130 use super::*;
1131 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1132 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
1133 ::unity::lookup::method_info_on_class_with_signature(<DynValue as ::unity::ClassIdentity>::class(), "get_Nil", 0, param_types, true)
1134 });
1135 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1136 match &*METHOD {
1137 ::core::result::Result::Ok(mi) => *mi,
1138 ::core::result::Result::Err(e) => {
1139 panic!(
1140 "method lookup failed: {}
1141::{}
1142: {}
1143",
1144 <DynValue as ::unity::ClassIdentity>::NAME,
1145 "get_Nil",
1146 e
1147 )
1148 },
1149 }
1150 }
1151 }
1152 #[doc(hidden)]
1153 #[allow(non_snake_case)]
1154 pub mod __lookup_set_nil {
1155 use super::*;
1156 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1157 let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
1158 &[<crate::moon_sharp::interpreter::dynvalue::DynValue as ::unity::IlType>::il_type()];
1159 ::unity::lookup::method_info_on_class_with_signature(<DynValue as ::unity::ClassIdentity>::class(), "set_Nil", 1, param_types, true)
1160 });
1161 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1162 match &*METHOD {
1163 ::core::result::Result::Ok(mi) => *mi,
1164 ::core::result::Result::Err(e) => {
1165 panic!(
1166 "method lookup failed: {}
1167::{}
1168: {}
1169",
1170 <DynValue as ::unity::ClassIdentity>::NAME,
1171 "set_Nil",
1172 e
1173 )
1174 },
1175 }
1176 }
1177 }
1178 #[doc(hidden)]
1179 #[allow(non_snake_case)]
1180 pub mod __lookup_get_true {
1181 use super::*;
1182 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1183 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
1184 ::unity::lookup::method_info_on_class_with_signature(<DynValue as ::unity::ClassIdentity>::class(), "get_True", 0, param_types, true)
1185 });
1186 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1187 match &*METHOD {
1188 ::core::result::Result::Ok(mi) => *mi,
1189 ::core::result::Result::Err(e) => {
1190 panic!(
1191 "method lookup failed: {}
1192::{}
1193: {}
1194",
1195 <DynValue as ::unity::ClassIdentity>::NAME,
1196 "get_True",
1197 e
1198 )
1199 },
1200 }
1201 }
1202 }
1203 #[doc(hidden)]
1204 #[allow(non_snake_case)]
1205 pub mod __lookup_set_true {
1206 use super::*;
1207 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1208 let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
1209 &[<crate::moon_sharp::interpreter::dynvalue::DynValue as ::unity::IlType>::il_type()];
1210 ::unity::lookup::method_info_on_class_with_signature(<DynValue as ::unity::ClassIdentity>::class(), "set_True", 1, param_types, true)
1211 });
1212 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1213 match &*METHOD {
1214 ::core::result::Result::Ok(mi) => *mi,
1215 ::core::result::Result::Err(e) => {
1216 panic!(
1217 "method lookup failed: {}
1218::{}
1219: {}
1220",
1221 <DynValue as ::unity::ClassIdentity>::NAME,
1222 "set_True",
1223 e
1224 )
1225 },
1226 }
1227 }
1228 }
1229 #[doc(hidden)]
1230 #[allow(non_snake_case)]
1231 pub mod __lookup_get_false {
1232 use super::*;
1233 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1234 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
1235 ::unity::lookup::method_info_on_class_with_signature(<DynValue as ::unity::ClassIdentity>::class(), "get_False", 0, param_types, true)
1236 });
1237 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1238 match &*METHOD {
1239 ::core::result::Result::Ok(mi) => *mi,
1240 ::core::result::Result::Err(e) => {
1241 panic!(
1242 "method lookup failed: {}
1243::{}
1244: {}
1245",
1246 <DynValue as ::unity::ClassIdentity>::NAME,
1247 "get_False",
1248 e
1249 )
1250 },
1251 }
1252 }
1253 }
1254 #[doc(hidden)]
1255 #[allow(non_snake_case)]
1256 pub mod __lookup_set_false {
1257 use super::*;
1258 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1259 let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
1260 &[<crate::moon_sharp::interpreter::dynvalue::DynValue as ::unity::IlType>::il_type()];
1261 ::unity::lookup::method_info_on_class_with_signature(<DynValue as ::unity::ClassIdentity>::class(), "set_False", 1, param_types, true)
1262 });
1263 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1264 match &*METHOD {
1265 ::core::result::Result::Ok(mi) => *mi,
1266 ::core::result::Result::Err(e) => {
1267 panic!(
1268 "method lookup failed: {}
1269::{}
1270: {}
1271",
1272 <DynValue as ::unity::ClassIdentity>::NAME,
1273 "set_False",
1274 e
1275 )
1276 },
1277 }
1278 }
1279 }
1280 #[doc(hidden)]
1281 #[allow(non_snake_case)]
1282 pub mod __lookup_cctor {
1283 use super::*;
1284 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1285 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
1286 ::unity::lookup::method_info_on_class_with_signature(<DynValue as ::unity::ClassIdentity>::class(), ".cctor", 0, param_types, true)
1287 });
1288 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1289 match &*METHOD {
1290 ::core::result::Result::Ok(mi) => *mi,
1291 ::core::result::Result::Err(e) => {
1292 panic!(
1293 "method lookup failed: {}
1294::{}
1295: {}
1296",
1297 <DynValue as ::unity::ClassIdentity>::NAME,
1298 ".cctor",
1299 e
1300 )
1301 },
1302 }
1303 }
1304 }
1305 #[doc(hidden)]
1306 #[allow(non_snake_case)]
1307 pub mod __lookup_to_print_string {
1308 use super::*;
1309 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1310 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
1311 ::unity::lookup::method_info_on_class_with_signature(
1312 <DynValue as ::unity::ClassIdentity>::class(),
1313 "ToPrintString",
1314 0,
1315 param_types,
1316 false,
1317 )
1318 });
1319 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1320 match &*METHOD {
1321 ::core::result::Result::Ok(mi) => *mi,
1322 ::core::result::Result::Err(e) => {
1323 panic!(
1324 "method lookup failed: {}
1325::{}
1326: {}
1327",
1328 <DynValue as ::unity::ClassIdentity>::NAME,
1329 "ToPrintString",
1330 e
1331 )
1332 },
1333 }
1334 }
1335 }
1336 #[doc(hidden)]
1337 #[allow(non_snake_case)]
1338 pub mod __lookup_to_debug_print_string {
1339 use super::*;
1340 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1341 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
1342 ::unity::lookup::method_info_on_class_with_signature(
1343 <DynValue as ::unity::ClassIdentity>::class(),
1344 "ToDebugPrintString",
1345 0,
1346 param_types,
1347 false,
1348 )
1349 });
1350 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1351 match &*METHOD {
1352 ::core::result::Result::Ok(mi) => *mi,
1353 ::core::result::Result::Err(e) => {
1354 panic!(
1355 "method lookup failed: {}
1356::{}
1357: {}
1358",
1359 <DynValue as ::unity::ClassIdentity>::NAME,
1360 "ToDebugPrintString",
1361 e
1362 )
1363 },
1364 }
1365 }
1366 }
1367 #[doc(hidden)]
1368 #[allow(non_snake_case)]
1369 pub mod __lookup_cast_to_string {
1370 use super::*;
1371 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1372 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
1373 ::unity::lookup::method_info_on_class_with_signature(<DynValue as ::unity::ClassIdentity>::class(), "CastToString", 0, param_types, false)
1374 });
1375 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1376 match &*METHOD {
1377 ::core::result::Result::Ok(mi) => *mi,
1378 ::core::result::Result::Err(e) => {
1379 panic!(
1380 "method lookup failed: {}
1381::{}
1382: {}
1383",
1384 <DynValue as ::unity::ClassIdentity>::NAME,
1385 "CastToString",
1386 e
1387 )
1388 },
1389 }
1390 }
1391 }
1392 #[doc(hidden)]
1393 #[allow(non_snake_case)]
1394 pub mod __lookup_cast_to_bool {
1395 use super::*;
1396 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1397 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
1398 ::unity::lookup::method_info_on_class_with_signature(<DynValue as ::unity::ClassIdentity>::class(), "CastToBool", 0, param_types, false)
1399 });
1400 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1401 match &*METHOD {
1402 ::core::result::Result::Ok(mi) => *mi,
1403 ::core::result::Result::Err(e) => {
1404 panic!(
1405 "method lookup failed: {}
1406::{}
1407: {}
1408",
1409 <DynValue as ::unity::ClassIdentity>::NAME,
1410 "CastToBool",
1411 e
1412 )
1413 },
1414 }
1415 }
1416 }
1417 #[doc(hidden)]
1418 #[allow(non_snake_case)]
1419 pub mod __lookup_get_as_private_resource {
1420 use super::*;
1421 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1422 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
1423 ::unity::lookup::method_info_on_class_with_signature(
1424 <DynValue as ::unity::ClassIdentity>::class(),
1425 "GetAsPrivateResource",
1426 0,
1427 param_types,
1428 false,
1429 )
1430 });
1431 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1432 match &*METHOD {
1433 ::core::result::Result::Ok(mi) => *mi,
1434 ::core::result::Result::Err(e) => {
1435 panic!(
1436 "method lookup failed: {}
1437::{}
1438: {}
1439",
1440 <DynValue as ::unity::ClassIdentity>::NAME,
1441 "GetAsPrivateResource",
1442 e
1443 )
1444 },
1445 }
1446 }
1447 }
1448 #[doc(hidden)]
1449 #[allow(non_snake_case)]
1450 pub mod __lookup_to_scalar {
1451 use super::*;
1452 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1453 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
1454 ::unity::lookup::method_info_on_class_with_signature(<DynValue as ::unity::ClassIdentity>::class(), "ToScalar", 0, param_types, false)
1455 });
1456 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1457 match &*METHOD {
1458 ::core::result::Result::Ok(mi) => *mi,
1459 ::core::result::Result::Err(e) => {
1460 panic!(
1461 "method lookup failed: {}
1462::{}
1463: {}
1464",
1465 <DynValue as ::unity::ClassIdentity>::NAME,
1466 "ToScalar",
1467 e
1468 )
1469 },
1470 }
1471 }
1472 }
1473 #[doc(hidden)]
1474 #[allow(non_snake_case)]
1475 pub mod __lookup_assign {
1476 use super::*;
1477 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1478 let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
1479 &[<crate::moon_sharp::interpreter::dynvalue::DynValue as ::unity::IlType>::il_type()];
1480 ::unity::lookup::method_info_on_class_with_signature(<DynValue as ::unity::ClassIdentity>::class(), "Assign", 1, param_types, false)
1481 });
1482 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1483 match &*METHOD {
1484 ::core::result::Result::Ok(mi) => *mi,
1485 ::core::result::Result::Err(e) => {
1486 panic!(
1487 "method lookup failed: {}
1488::{}
1489: {}
1490",
1491 <DynValue as ::unity::ClassIdentity>::NAME,
1492 "Assign",
1493 e
1494 )
1495 },
1496 }
1497 }
1498 }
1499 #[doc(hidden)]
1500 #[allow(non_snake_case)]
1501 pub mod __lookup_get_length {
1502 use super::*;
1503 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1504 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
1505 ::unity::lookup::method_info_on_class_with_signature(<DynValue as ::unity::ClassIdentity>::class(), "GetLength", 0, param_types, false)
1506 });
1507 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1508 match &*METHOD {
1509 ::core::result::Result::Ok(mi) => *mi,
1510 ::core::result::Result::Err(e) => {
1511 panic!(
1512 "method lookup failed: {}
1513::{}
1514: {}
1515",
1516 <DynValue as ::unity::ClassIdentity>::NAME,
1517 "GetLength",
1518 e
1519 )
1520 },
1521 }
1522 }
1523 }
1524 #[doc(hidden)]
1525 #[allow(non_snake_case)]
1526 pub mod __lookup_is_nil {
1527 use super::*;
1528 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1529 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
1530 ::unity::lookup::method_info_on_class_with_signature(<DynValue as ::unity::ClassIdentity>::class(), "IsNil", 0, param_types, false)
1531 });
1532 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1533 match &*METHOD {
1534 ::core::result::Result::Ok(mi) => *mi,
1535 ::core::result::Result::Err(e) => {
1536 panic!(
1537 "method lookup failed: {}
1538::{}
1539: {}
1540",
1541 <DynValue as ::unity::ClassIdentity>::NAME,
1542 "IsNil",
1543 e
1544 )
1545 },
1546 }
1547 }
1548 }
1549 #[doc(hidden)]
1550 #[allow(non_snake_case)]
1551 pub mod __lookup_is_not_nil {
1552 use super::*;
1553 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1554 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
1555 ::unity::lookup::method_info_on_class_with_signature(<DynValue as ::unity::ClassIdentity>::class(), "IsNotNil", 0, param_types, false)
1556 });
1557 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1558 match &*METHOD {
1559 ::core::result::Result::Ok(mi) => *mi,
1560 ::core::result::Result::Err(e) => {
1561 panic!(
1562 "method lookup failed: {}
1563::{}
1564: {}
1565",
1566 <DynValue as ::unity::ClassIdentity>::NAME,
1567 "IsNotNil",
1568 e
1569 )
1570 },
1571 }
1572 }
1573 }
1574 #[doc(hidden)]
1575 #[allow(non_snake_case)]
1576 pub mod __lookup_is_void {
1577 use super::*;
1578 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1579 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
1580 ::unity::lookup::method_info_on_class_with_signature(<DynValue as ::unity::ClassIdentity>::class(), "IsVoid", 0, param_types, false)
1581 });
1582 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1583 match &*METHOD {
1584 ::core::result::Result::Ok(mi) => *mi,
1585 ::core::result::Result::Err(e) => {
1586 panic!(
1587 "method lookup failed: {}
1588::{}
1589: {}
1590",
1591 <DynValue as ::unity::ClassIdentity>::NAME,
1592 "IsVoid",
1593 e
1594 )
1595 },
1596 }
1597 }
1598 }
1599 #[doc(hidden)]
1600 #[allow(non_snake_case)]
1601 pub mod __lookup_is_not_void {
1602 use super::*;
1603 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1604 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
1605 ::unity::lookup::method_info_on_class_with_signature(<DynValue as ::unity::ClassIdentity>::class(), "IsNotVoid", 0, param_types, false)
1606 });
1607 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1608 match &*METHOD {
1609 ::core::result::Result::Ok(mi) => *mi,
1610 ::core::result::Result::Err(e) => {
1611 panic!(
1612 "method lookup failed: {}
1613::{}
1614: {}
1615",
1616 <DynValue as ::unity::ClassIdentity>::NAME,
1617 "IsNotVoid",
1618 e
1619 )
1620 },
1621 }
1622 }
1623 }
1624 #[doc(hidden)]
1625 #[allow(non_snake_case)]
1626 pub mod __lookup_is_nil_or_nan {
1627 use super::*;
1628 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1629 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
1630 ::unity::lookup::method_info_on_class_with_signature(<DynValue as ::unity::ClassIdentity>::class(), "IsNilOrNan", 0, param_types, false)
1631 });
1632 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1633 match &*METHOD {
1634 ::core::result::Result::Ok(mi) => *mi,
1635 ::core::result::Result::Err(e) => {
1636 panic!(
1637 "method lookup failed: {}
1638::{}
1639: {}
1640",
1641 <DynValue as ::unity::ClassIdentity>::NAME,
1642 "IsNilOrNan",
1643 e
1644 )
1645 },
1646 }
1647 }
1648 }
1649 #[doc(hidden)]
1650 #[allow(non_snake_case)]
1651 pub mod __lookup_assign_number {
1652 use super::*;
1653 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1654 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[<f64 as ::unity::IlType>::il_type()];
1655 ::unity::lookup::method_info_on_class_with_signature(<DynValue as ::unity::ClassIdentity>::class(), "AssignNumber", 1, param_types, false)
1656 });
1657 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1658 match &*METHOD {
1659 ::core::result::Result::Ok(mi) => *mi,
1660 ::core::result::Result::Err(e) => {
1661 panic!(
1662 "method lookup failed: {}
1663::{}
1664: {}
1665",
1666 <DynValue as ::unity::ClassIdentity>::NAME,
1667 "AssignNumber",
1668 e
1669 )
1670 },
1671 }
1672 }
1673 }
1674 #[doc(hidden)]
1675 #[allow(non_snake_case)]
1676 pub mod __lookup_from_object {
1677 use super::*;
1678 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1679 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
1680 <crate::moon_sharp::interpreter::script::Script as ::unity::IlType>::il_type(),
1681 <crate::system::object::Object as ::unity::IlType>::il_type(),
1682 ];
1683 ::unity::lookup::method_info_on_class_with_signature(<DynValue as ::unity::ClassIdentity>::class(), "FromObject", 2, param_types, true)
1684 });
1685 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1686 match &*METHOD {
1687 ::core::result::Result::Ok(mi) => *mi,
1688 ::core::result::Result::Err(e) => {
1689 panic!(
1690 "method lookup failed: {}
1691::{}
1692: {}
1693",
1694 <DynValue as ::unity::ClassIdentity>::NAME,
1695 "FromObject",
1696 e
1697 )
1698 },
1699 }
1700 }
1701 }
1702 #[doc(hidden)]
1703 #[allow(non_snake_case)]
1704 pub mod __lookup_to_object {
1705 use super::*;
1706 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1707 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
1708 ::unity::lookup::method_info_on_class_with_signature(<DynValue as ::unity::ClassIdentity>::class(), "ToObject", 0, param_types, false)
1709 });
1710 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1711 match &*METHOD {
1712 ::core::result::Result::Ok(mi) => *mi,
1713 ::core::result::Result::Err(e) => {
1714 panic!(
1715 "method lookup failed: {}
1716::{}
1717: {}
1718",
1719 <DynValue as ::unity::ClassIdentity>::NAME,
1720 "ToObject",
1721 e
1722 )
1723 },
1724 }
1725 }
1726 }
1727 #[doc(hidden)]
1728 #[allow(non_snake_case)]
1729 pub mod __lookup_to_object_2 {
1730 use super::*;
1731 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1732 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[<::unity::SystemType as ::unity::IlType>::il_type()];
1733 ::unity::lookup::method_info_on_class_with_signature(<DynValue as ::unity::ClassIdentity>::class(), "ToObject", 1, param_types, false)
1734 });
1735 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1736 match &*METHOD {
1737 ::core::result::Result::Ok(mi) => *mi,
1738 ::core::result::Result::Err(e) => {
1739 panic!(
1740 "method lookup failed: {}
1741::{}
1742: {}
1743",
1744 <DynValue as ::unity::ClassIdentity>::NAME,
1745 "ToObject",
1746 e
1747 )
1748 },
1749 }
1750 }
1751 }
1752 #[doc(hidden)]
1753 #[allow(non_snake_case)]
1754 pub mod __lookup_check_type {
1755 use super::*;
1756 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1757 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
1758 <::unity::Il2CppString as ::unity::IlType>::il_type(),
1759 <crate::moon_sharp::interpreter::datatype::DataType as ::unity::IlType>::il_type(),
1760 <i32 as ::unity::IlType>::il_type(),
1761 <crate::moon_sharp::interpreter::typevalidationflags::TypeValidationFlags as ::unity::IlType>::il_type(),
1762 ];
1763 ::unity::lookup::method_info_on_class_with_signature(<DynValue as ::unity::ClassIdentity>::class(), "CheckType", 4, param_types, false)
1764 });
1765 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1766 match &*METHOD {
1767 ::core::result::Result::Ok(mi) => *mi,
1768 ::core::result::Result::Err(e) => {
1769 panic!(
1770 "method lookup failed: {}
1771::{}
1772: {}
1773",
1774 <DynValue as ::unity::ClassIdentity>::NAME,
1775 "CheckType",
1776 e
1777 )
1778 },
1779 }
1780 }
1781 }
1782 #[doc(hidden)]
1783 #[allow(non_snake_case)]
1784 pub mod __lookup_ctor {
1785 use super::*;
1786 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1787 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
1788 ::unity::lookup::method_info_on_class_with_signature(<DynValue as ::unity::ClassIdentity>::class(), ".ctor", 0, param_types, false)
1789 });
1790 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1791 match &*METHOD {
1792 ::core::result::Result::Ok(mi) => *mi,
1793 ::core::result::Result::Err(e) => {
1794 panic!(
1795 "method lookup failed: {}
1796::{}
1797: {}
1798",
1799 <DynValue as ::unity::ClassIdentity>::NAME,
1800 ".ctor",
1801 e
1802 )
1803 },
1804 }
1805 }
1806 }
1807}
1808
1809#[cfg(feature = "moon_sharp-interpreter-dynvalue")]
1810impl DynValue {
1811 #[doc = "`NewNil()` overload"]
1812 pub fn new_nil() -> crate::moon_sharp::interpreter::dynvalue::DynValue {
1813 unsafe {
1814 ::unity::il2cpp_call!(__DynValue_unity_raw::__lookup_new_nil::get_method_info().method_ptr,crate::moon_sharp::interpreter::dynvalue::DynValue;
1815 )
1816 }
1817 }
1818
1819 #[doc = "`NewBoolean(bool)` overload"]
1820 pub fn new_boolean(v: impl ::core::convert::Into<bool>) -> crate::moon_sharp::interpreter::dynvalue::DynValue {
1821 unsafe {
1822 ::unity::il2cpp_call!(__DynValue_unity_raw::__lookup_new_boolean::get_method_info().method_ptr,crate::moon_sharp::interpreter::dynvalue::DynValue;
1823(bool)::core::convert::Into::into(v))
1824 }
1825 }
1826
1827 #[doc = "`NewNumber(f64)` overload"]
1828 pub fn new_number(num: impl ::core::convert::Into<f64>) -> crate::moon_sharp::interpreter::dynvalue::DynValue {
1829 unsafe {
1830 ::unity::il2cpp_call!(__DynValue_unity_raw::__lookup_new_number::get_method_info().method_ptr,crate::moon_sharp::interpreter::dynvalue::DynValue;
1831(f64)::core::convert::Into::into(num))
1832 }
1833 }
1834
1835 #[doc = "`NewString(::unity::Il2CppString)` overload"]
1836 pub fn new_string(str: impl ::core::convert::Into<::unity::Il2CppString>) -> crate::moon_sharp::interpreter::dynvalue::DynValue {
1837 unsafe {
1838 ::unity::il2cpp_call!(__DynValue_unity_raw::__lookup_new_string::get_method_info().method_ptr,crate::moon_sharp::interpreter::dynvalue::DynValue;
1839(::unity::Il2CppString)::core::convert::Into::into(str))
1840 }
1841 }
1842
1843 #[doc = "`NewString(::unity::Il2CppString, ::unity::Array<crate::system::object::Object>)` overload"]
1844 pub fn new_string_2(
1845 format: impl ::core::convert::Into<::unity::Il2CppString>,
1846 args: impl ::core::convert::Into<::unity::Array<crate::system::object::Object>>,
1847 ) -> crate::moon_sharp::interpreter::dynvalue::DynValue {
1848 unsafe {
1849 ::unity::il2cpp_call!(__DynValue_unity_raw::__lookup_new_string_2::get_method_info().method_ptr,crate::moon_sharp::interpreter::dynvalue::DynValue;
1850(::unity::Il2CppString)::core::convert::Into::into(format),(::unity::Array<crate::system::object::Object>)::core::convert::Into::into(args))
1851 }
1852 }
1853
1854 #[doc = "`NewCoroutine(crate::moon_sharp::interpreter::coroutine_2::Coroutine_2)` overload"]
1855 pub fn new_coroutine(
1856 coroutine: impl ::core::convert::Into<crate::moon_sharp::interpreter::coroutine_2::Coroutine_2>,
1857 ) -> crate::moon_sharp::interpreter::dynvalue::DynValue {
1858 unsafe {
1859 ::unity::il2cpp_call!(__DynValue_unity_raw::__lookup_new_coroutine::get_method_info().method_ptr,crate::moon_sharp::interpreter::dynvalue::DynValue;
1860(crate::moon_sharp::interpreter::coroutine_2::Coroutine_2)::core::convert::Into::into(coroutine))
1861 }
1862 }
1863
1864 #[doc = "`NewClosure(crate::moon_sharp::interpreter::closure::Closure)` overload"]
1865 pub fn new_closure(
1866 function: impl ::core::convert::Into<crate::moon_sharp::interpreter::closure::Closure>,
1867 ) -> crate::moon_sharp::interpreter::dynvalue::DynValue {
1868 unsafe {
1869 ::unity::il2cpp_call!(__DynValue_unity_raw::__lookup_new_closure::get_method_info().method_ptr,crate::moon_sharp::interpreter::dynvalue::DynValue;
1870(crate::moon_sharp::interpreter::closure::Closure)::core::convert::Into::into(function))
1871 }
1872 }
1873
1874 #[doc = "`NewCallback(crate::system::func_3::Func_3<crate::moon_sharp::interpreter::scriptexecutioncontext::ScriptExecutionContext,crate::moon_sharp::interpreter::callbackarguments::CallbackArguments,crate::moon_sharp::interpreter::dynvalue::DynValue>, ::unity::Il2CppString)` overload"]
1875 pub fn new_callback(
1876 call_back: impl ::core::convert::Into<
1877 crate::system::func_3::Func_3<
1878 crate::moon_sharp::interpreter::scriptexecutioncontext::ScriptExecutionContext,
1879 crate::moon_sharp::interpreter::callbackarguments::CallbackArguments,
1880 crate::moon_sharp::interpreter::dynvalue::DynValue,
1881 >,
1882 >,
1883 name: impl ::core::convert::Into<::unity::Il2CppString>,
1884 ) -> crate::moon_sharp::interpreter::dynvalue::DynValue {
1885 unsafe {
1886 ::unity::il2cpp_call!(__DynValue_unity_raw::__lookup_new_callback::get_method_info().method_ptr,crate::moon_sharp::interpreter::dynvalue::DynValue;
1887(crate::system::func_3::Func_3<crate::moon_sharp::interpreter::scriptexecutioncontext::ScriptExecutionContext,crate::moon_sharp::interpreter::callbackarguments::CallbackArguments,crate::moon_sharp::interpreter::dynvalue::DynValue>)::core::convert::Into::into(call_back),(::unity::Il2CppString)::core::convert::Into::into(name))
1888 }
1889 }
1890
1891 #[doc = "`NewCallback(crate::moon_sharp::interpreter::callbackfunction::CallbackFunction)` overload"]
1892 pub fn new_callback_2(
1893 function: impl ::core::convert::Into<crate::moon_sharp::interpreter::callbackfunction::CallbackFunction>,
1894 ) -> crate::moon_sharp::interpreter::dynvalue::DynValue {
1895 unsafe {
1896 ::unity::il2cpp_call!(__DynValue_unity_raw::__lookup_new_callback_2::get_method_info().method_ptr,crate::moon_sharp::interpreter::dynvalue::DynValue;
1897(crate::moon_sharp::interpreter::callbackfunction::CallbackFunction)::core::convert::Into::into(function))
1898 }
1899 }
1900
1901 #[doc = "`NewTable(crate::moon_sharp::interpreter::table::Table)` overload"]
1902 pub fn new_table(
1903 table: impl ::core::convert::Into<crate::moon_sharp::interpreter::table::Table>,
1904 ) -> crate::moon_sharp::interpreter::dynvalue::DynValue {
1905 unsafe {
1906 ::unity::il2cpp_call!(__DynValue_unity_raw::__lookup_new_table::get_method_info().method_ptr,crate::moon_sharp::interpreter::dynvalue::DynValue;
1907(crate::moon_sharp::interpreter::table::Table)::core::convert::Into::into(table))
1908 }
1909 }
1910
1911 #[doc = "`NewPrimeTable()` overload"]
1912 pub fn new_prime_table() -> crate::moon_sharp::interpreter::dynvalue::DynValue {
1913 unsafe {
1914 ::unity::il2cpp_call!(__DynValue_unity_raw::__lookup_new_prime_table::get_method_info().method_ptr,crate::moon_sharp::interpreter::dynvalue::DynValue;
1915 )
1916 }
1917 }
1918
1919 #[doc = "`NewTable(crate::moon_sharp::interpreter::script::Script)` overload"]
1920 pub fn new_table_2(
1921 script: impl ::core::convert::Into<crate::moon_sharp::interpreter::script::Script>,
1922 ) -> crate::moon_sharp::interpreter::dynvalue::DynValue {
1923 unsafe {
1924 ::unity::il2cpp_call!(__DynValue_unity_raw::__lookup_new_table_2::get_method_info().method_ptr,crate::moon_sharp::interpreter::dynvalue::DynValue;
1925(crate::moon_sharp::interpreter::script::Script)::core::convert::Into::into(script))
1926 }
1927 }
1928
1929 #[doc = "`NewTable(crate::moon_sharp::interpreter::script::Script, ::unity::Array<crate::moon_sharp::interpreter::dynvalue::DynValue>)` overload"]
1930 pub fn new_table_3(
1931 script: impl ::core::convert::Into<crate::moon_sharp::interpreter::script::Script>,
1932 array_values: impl ::core::convert::Into<::unity::Array<crate::moon_sharp::interpreter::dynvalue::DynValue>>,
1933 ) -> crate::moon_sharp::interpreter::dynvalue::DynValue {
1934 unsafe {
1935 ::unity::il2cpp_call!(__DynValue_unity_raw::__lookup_new_table_3::get_method_info().method_ptr,crate::moon_sharp::interpreter::dynvalue::DynValue;
1936(crate::moon_sharp::interpreter::script::Script)::core::convert::Into::into(script),(::unity::Array<crate::moon_sharp::interpreter::dynvalue::DynValue>)::core::convert::Into::into(array_values))
1937 }
1938 }
1939
1940 #[doc = "`NewTailCallReq(crate::moon_sharp::interpreter::dynvalue::DynValue, ::unity::Array<crate::moon_sharp::interpreter::dynvalue::DynValue>)` overload"]
1941 pub fn new_tail_call_req(
1942 tail_fn: impl ::core::convert::Into<crate::moon_sharp::interpreter::dynvalue::DynValue>,
1943 args: impl ::core::convert::Into<::unity::Array<crate::moon_sharp::interpreter::dynvalue::DynValue>>,
1944 ) -> crate::moon_sharp::interpreter::dynvalue::DynValue {
1945 unsafe {
1946 ::unity::il2cpp_call!(__DynValue_unity_raw::__lookup_new_tail_call_req::get_method_info().method_ptr,crate::moon_sharp::interpreter::dynvalue::DynValue;
1947(crate::moon_sharp::interpreter::dynvalue::DynValue)::core::convert::Into::into(tail_fn),(::unity::Array<crate::moon_sharp::interpreter::dynvalue::DynValue>)::core::convert::Into::into(args))
1948 }
1949 }
1950
1951 #[doc = "`NewTailCallReq(crate::moon_sharp::interpreter::tailcalldata::TailCallData)` overload"]
1952 pub fn new_tail_call_req_2(
1953 tail_call_data: impl ::core::convert::Into<crate::moon_sharp::interpreter::tailcalldata::TailCallData>,
1954 ) -> crate::moon_sharp::interpreter::dynvalue::DynValue {
1955 unsafe {
1956 ::unity::il2cpp_call!(__DynValue_unity_raw::__lookup_new_tail_call_req_2::get_method_info().method_ptr,crate::moon_sharp::interpreter::dynvalue::DynValue;
1957(crate::moon_sharp::interpreter::tailcalldata::TailCallData)::core::convert::Into::into(tail_call_data))
1958 }
1959 }
1960
1961 #[doc = "`NewYieldReq(::unity::Array<crate::moon_sharp::interpreter::dynvalue::DynValue>)` overload"]
1962 pub fn new_yield_req(
1963 args: impl ::core::convert::Into<::unity::Array<crate::moon_sharp::interpreter::dynvalue::DynValue>>,
1964 ) -> crate::moon_sharp::interpreter::dynvalue::DynValue {
1965 unsafe {
1966 ::unity::il2cpp_call!(__DynValue_unity_raw::__lookup_new_yield_req::get_method_info().method_ptr,crate::moon_sharp::interpreter::dynvalue::DynValue;
1967(::unity::Array<crate::moon_sharp::interpreter::dynvalue::DynValue>)::core::convert::Into::into(args))
1968 }
1969 }
1970
1971 #[doc = "`NewForcedYieldReq()` overload"]
1972 pub fn new_forced_yield_req() -> crate::moon_sharp::interpreter::dynvalue::DynValue {
1973 unsafe {
1974 ::unity::il2cpp_call!(__DynValue_unity_raw::__lookup_new_forced_yield_req::get_method_info().method_ptr,crate::moon_sharp::interpreter::dynvalue::DynValue;
1975 )
1976 }
1977 }
1978
1979 #[doc = "`NewTuple(::unity::Array<crate::moon_sharp::interpreter::dynvalue::DynValue>)` overload"]
1980 pub fn new_tuple(
1981 values: impl ::core::convert::Into<::unity::Array<crate::moon_sharp::interpreter::dynvalue::DynValue>>,
1982 ) -> crate::moon_sharp::interpreter::dynvalue::DynValue {
1983 unsafe {
1984 ::unity::il2cpp_call!(__DynValue_unity_raw::__lookup_new_tuple::get_method_info().method_ptr,crate::moon_sharp::interpreter::dynvalue::DynValue;
1985(::unity::Array<crate::moon_sharp::interpreter::dynvalue::DynValue>)::core::convert::Into::into(values))
1986 }
1987 }
1988
1989 #[doc = "`NewTupleNested(::unity::Array<crate::moon_sharp::interpreter::dynvalue::DynValue>)` overload"]
1990 pub fn new_tuple_nested(
1991 values: impl ::core::convert::Into<::unity::Array<crate::moon_sharp::interpreter::dynvalue::DynValue>>,
1992 ) -> crate::moon_sharp::interpreter::dynvalue::DynValue {
1993 unsafe {
1994 ::unity::il2cpp_call!(__DynValue_unity_raw::__lookup_new_tuple_nested::get_method_info().method_ptr,crate::moon_sharp::interpreter::dynvalue::DynValue;
1995(::unity::Array<crate::moon_sharp::interpreter::dynvalue::DynValue>)::core::convert::Into::into(values))
1996 }
1997 }
1998
1999 #[doc = "`NewUserData(crate::moon_sharp::interpreter::userdata::UserData)` overload"]
2000 pub fn new_user_data(
2001 user_data: impl ::core::convert::Into<crate::moon_sharp::interpreter::userdata::UserData>,
2002 ) -> crate::moon_sharp::interpreter::dynvalue::DynValue {
2003 unsafe {
2004 ::unity::il2cpp_call!(__DynValue_unity_raw::__lookup_new_user_data::get_method_info().method_ptr,crate::moon_sharp::interpreter::dynvalue::DynValue;
2005(crate::moon_sharp::interpreter::userdata::UserData)::core::convert::Into::into(user_data))
2006 }
2007 }
2008
2009 #[doc = "`get_Void()` overload"]
2010 pub fn get_void() -> crate::moon_sharp::interpreter::dynvalue::DynValue {
2011 unsafe {
2012 ::unity::il2cpp_call!(__DynValue_unity_raw::__lookup_get_void::get_method_info().method_ptr,crate::moon_sharp::interpreter::dynvalue::DynValue;
2013 )
2014 }
2015 }
2016
2017 #[doc = "`set_Void(crate::moon_sharp::interpreter::dynvalue::DynValue)` overload"]
2018 pub fn set_void(value: impl ::core::convert::Into<crate::moon_sharp::interpreter::dynvalue::DynValue>) -> () {
2019 unsafe {
2020 ::unity::il2cpp_call!(__DynValue_unity_raw::__lookup_set_void::get_method_info().method_ptr,();
2021(crate::moon_sharp::interpreter::dynvalue::DynValue)::core::convert::Into::into(value))
2022 }
2023 }
2024
2025 #[doc = "`get_Nil()` overload"]
2026 pub fn get_nil() -> crate::moon_sharp::interpreter::dynvalue::DynValue {
2027 unsafe {
2028 ::unity::il2cpp_call!(__DynValue_unity_raw::__lookup_get_nil::get_method_info().method_ptr,crate::moon_sharp::interpreter::dynvalue::DynValue;
2029 )
2030 }
2031 }
2032
2033 #[doc = "`set_Nil(crate::moon_sharp::interpreter::dynvalue::DynValue)` overload"]
2034 pub fn set_nil(value: impl ::core::convert::Into<crate::moon_sharp::interpreter::dynvalue::DynValue>) -> () {
2035 unsafe {
2036 ::unity::il2cpp_call!(__DynValue_unity_raw::__lookup_set_nil::get_method_info().method_ptr,();
2037(crate::moon_sharp::interpreter::dynvalue::DynValue)::core::convert::Into::into(value))
2038 }
2039 }
2040
2041 #[doc = "`get_True()` overload"]
2042 pub fn get_true() -> crate::moon_sharp::interpreter::dynvalue::DynValue {
2043 unsafe {
2044 ::unity::il2cpp_call!(__DynValue_unity_raw::__lookup_get_true::get_method_info().method_ptr,crate::moon_sharp::interpreter::dynvalue::DynValue;
2045 )
2046 }
2047 }
2048
2049 #[doc = "`set_True(crate::moon_sharp::interpreter::dynvalue::DynValue)` overload"]
2050 pub fn set_true(value: impl ::core::convert::Into<crate::moon_sharp::interpreter::dynvalue::DynValue>) -> () {
2051 unsafe {
2052 ::unity::il2cpp_call!(__DynValue_unity_raw::__lookup_set_true::get_method_info().method_ptr,();
2053(crate::moon_sharp::interpreter::dynvalue::DynValue)::core::convert::Into::into(value))
2054 }
2055 }
2056
2057 #[doc = "`get_False()` overload"]
2058 pub fn get_false() -> crate::moon_sharp::interpreter::dynvalue::DynValue {
2059 unsafe {
2060 ::unity::il2cpp_call!(__DynValue_unity_raw::__lookup_get_false::get_method_info().method_ptr,crate::moon_sharp::interpreter::dynvalue::DynValue;
2061 )
2062 }
2063 }
2064
2065 #[doc = "`set_False(crate::moon_sharp::interpreter::dynvalue::DynValue)` overload"]
2066 pub fn set_false(value: impl ::core::convert::Into<crate::moon_sharp::interpreter::dynvalue::DynValue>) -> () {
2067 unsafe {
2068 ::unity::il2cpp_call!(__DynValue_unity_raw::__lookup_set_false::get_method_info().method_ptr,();
2069(crate::moon_sharp::interpreter::dynvalue::DynValue)::core::convert::Into::into(value))
2070 }
2071 }
2072
2073 #[doc = "`.cctor()` overload"]
2074 pub fn cctor() -> () {
2075 unsafe {
2076 ::unity::il2cpp_call!(__DynValue_unity_raw::__lookup_cctor::get_method_info().method_ptr,();
2077 )
2078 }
2079 }
2080
2081 #[doc = "`FromObject(crate::moon_sharp::interpreter::script::Script, crate::system::object::Object)` overload"]
2082 pub fn from_object(
2083 script: impl ::core::convert::Into<crate::moon_sharp::interpreter::script::Script>,
2084 obj: impl ::core::convert::Into<crate::system::object::Object>,
2085 ) -> crate::moon_sharp::interpreter::dynvalue::DynValue {
2086 unsafe {
2087 ::unity::il2cpp_call!(__DynValue_unity_raw::__lookup_from_object::get_method_info().method_ptr,crate::moon_sharp::interpreter::dynvalue::DynValue;
2088(crate::moon_sharp::interpreter::script::Script)::core::convert::Into::into(script),(crate::system::object::Object)::core::convert::Into::into(obj))
2089 }
2090 }
2091}
2092
2093#[cfg(feature = "moon_sharp-interpreter-dynvalue")]
2094pub trait IDynValueMethods: IDynValue {
2095 #[doc = "`get_ReferenceID()` overload"]
2096 fn get_reference_id(self) -> i32 {
2097 unsafe {
2098 let __receiver = <DynValue as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2099 ::unity::il2cpp_call!(__DynValue_unity_raw::__lookup_get_reference_id::get_method_info().method_ptr,i32;
2100(DynValue)__receiver)
2101 }
2102 }
2103 #[doc = "`get_Type()` overload"]
2104 fn get_type(self) -> crate::moon_sharp::interpreter::datatype::DataType {
2105 unsafe {
2106 let __receiver = <DynValue as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2107 ::unity::il2cpp_call!(__DynValue_unity_raw::__lookup_get_type::get_method_info().method_ptr,crate::moon_sharp::interpreter::datatype::DataType;
2108(DynValue)__receiver)
2109 }
2110 }
2111 #[doc = "`get_Function()` overload"]
2112 fn get_function(self) -> crate::moon_sharp::interpreter::closure::Closure {
2113 unsafe {
2114 let __receiver = <DynValue as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2115 ::unity::il2cpp_call!(__DynValue_unity_raw::__lookup_get_function::get_method_info().method_ptr,crate::moon_sharp::interpreter::closure::Closure;
2116(DynValue)__receiver)
2117 }
2118 }
2119 #[doc = "`get_Number()` overload"]
2120 fn get_number(self) -> f64 {
2121 unsafe {
2122 let __receiver = <DynValue as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2123 ::unity::il2cpp_call!(__DynValue_unity_raw::__lookup_get_number::get_method_info().method_ptr,f64;
2124(DynValue)__receiver)
2125 }
2126 }
2127 #[doc = "`get_Tuple()` overload"]
2128 fn get_tuple(self) -> ::unity::Array<crate::moon_sharp::interpreter::dynvalue::DynValue> {
2129 unsafe {
2130 let __receiver = <DynValue as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2131 ::unity::il2cpp_call!(__DynValue_unity_raw::__lookup_get_tuple::get_method_info().method_ptr, ::unity::Array<crate::moon_sharp::interpreter::dynvalue::DynValue> ;
2132(DynValue)__receiver)
2133 }
2134 }
2135 #[doc = "`get_Coroutine()` overload"]
2136 fn get_coroutine(self) -> crate::moon_sharp::interpreter::coroutine_2::Coroutine_2 {
2137 unsafe {
2138 let __receiver = <DynValue as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2139 ::unity::il2cpp_call!(__DynValue_unity_raw::__lookup_get_coroutine::get_method_info().method_ptr,crate::moon_sharp::interpreter::coroutine_2::Coroutine_2;
2140(DynValue)__receiver)
2141 }
2142 }
2143 #[doc = "`get_Table()` overload"]
2144 fn get_table(self) -> crate::moon_sharp::interpreter::table::Table {
2145 unsafe {
2146 let __receiver = <DynValue as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2147 ::unity::il2cpp_call!(__DynValue_unity_raw::__lookup_get_table::get_method_info().method_ptr,crate::moon_sharp::interpreter::table::Table;
2148(DynValue)__receiver)
2149 }
2150 }
2151 #[doc = "`get_Boolean()` overload"]
2152 fn get_boolean(self) -> bool {
2153 unsafe {
2154 let __receiver = <DynValue as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2155 ::unity::il2cpp_call!(__DynValue_unity_raw::__lookup_get_boolean::get_method_info().method_ptr,bool;
2156(DynValue)__receiver)
2157 }
2158 }
2159 #[doc = "`get_String()` overload"]
2160 fn get_string(self) -> ::unity::Il2CppString {
2161 unsafe {
2162 let __receiver = <DynValue as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2163 ::unity::il2cpp_call!(__DynValue_unity_raw::__lookup_get_string::get_method_info().method_ptr, ::unity::Il2CppString;
2164(DynValue)__receiver)
2165 }
2166 }
2167 #[doc = "`get_Callback()` overload"]
2168 fn get_callback(self) -> crate::moon_sharp::interpreter::callbackfunction::CallbackFunction {
2169 unsafe {
2170 let __receiver = <DynValue as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2171 ::unity::il2cpp_call!(__DynValue_unity_raw::__lookup_get_callback::get_method_info().method_ptr,crate::moon_sharp::interpreter::callbackfunction::CallbackFunction;
2172(DynValue)__receiver)
2173 }
2174 }
2175 #[doc = "`get_TailCallData()` overload"]
2176 fn get_tail_call_data(self) -> crate::moon_sharp::interpreter::tailcalldata::TailCallData {
2177 unsafe {
2178 let __receiver = <DynValue as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2179 ::unity::il2cpp_call!(__DynValue_unity_raw::__lookup_get_tail_call_data::get_method_info().method_ptr,crate::moon_sharp::interpreter::tailcalldata::TailCallData;
2180(DynValue)__receiver)
2181 }
2182 }
2183 #[doc = "`get_YieldRequest()` overload"]
2184 fn get_yield_request(self) -> crate::moon_sharp::interpreter::yieldrequest::YieldRequest {
2185 unsafe {
2186 let __receiver = <DynValue as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2187 ::unity::il2cpp_call!(__DynValue_unity_raw::__lookup_get_yield_request::get_method_info().method_ptr,crate::moon_sharp::interpreter::yieldrequest::YieldRequest;
2188(DynValue)__receiver)
2189 }
2190 }
2191 #[doc = "`get_UserData()` overload"]
2192 fn get_user_data(self) -> crate::moon_sharp::interpreter::userdata::UserData {
2193 unsafe {
2194 let __receiver = <DynValue as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2195 ::unity::il2cpp_call!(__DynValue_unity_raw::__lookup_get_user_data::get_method_info().method_ptr,crate::moon_sharp::interpreter::userdata::UserData;
2196(DynValue)__receiver)
2197 }
2198 }
2199 #[doc = "`get_ReadOnly()` overload"]
2200 fn get_read_only(self) -> bool {
2201 unsafe {
2202 let __receiver = <DynValue as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2203 ::unity::il2cpp_call!(__DynValue_unity_raw::__lookup_get_read_only::get_method_info().method_ptr,bool;
2204(DynValue)__receiver)
2205 }
2206 }
2207 #[doc = "`AsReadOnly()` overload"]
2208 fn as_read_only(self) -> crate::moon_sharp::interpreter::dynvalue::DynValue {
2209 unsafe {
2210 let __receiver = <DynValue as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2211 ::unity::il2cpp_call!(__DynValue_unity_raw::__lookup_as_read_only::get_method_info().method_ptr,crate::moon_sharp::interpreter::dynvalue::DynValue;
2212(DynValue)__receiver)
2213 }
2214 }
2215 #[doc = "`Clone()` overload"]
2216 fn clone(self) -> crate::moon_sharp::interpreter::dynvalue::DynValue {
2217 unsafe {
2218 let __receiver = <DynValue as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2219 ::unity::il2cpp_call!(__DynValue_unity_raw::__lookup_clone::get_method_info().method_ptr,crate::moon_sharp::interpreter::dynvalue::DynValue;
2220(DynValue)__receiver)
2221 }
2222 }
2223 #[doc = "`Clone(bool)` overload"]
2224 fn clone_2(self, read_only: impl ::core::convert::Into<bool>) -> crate::moon_sharp::interpreter::dynvalue::DynValue {
2225 unsafe {
2226 let __receiver = <DynValue as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2227 ::unity::il2cpp_call!(__DynValue_unity_raw::__lookup_clone_2::get_method_info().method_ptr,crate::moon_sharp::interpreter::dynvalue::DynValue;
2228(DynValue)__receiver,(bool)::core::convert::Into::into(read_only))
2229 }
2230 }
2231 #[doc = "`CloneAsWritable()` overload"]
2232 fn clone_as_writable(self) -> crate::moon_sharp::interpreter::dynvalue::DynValue {
2233 unsafe {
2234 let __receiver = <DynValue as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2235 ::unity::il2cpp_call!(__DynValue_unity_raw::__lookup_clone_as_writable::get_method_info().method_ptr,crate::moon_sharp::interpreter::dynvalue::DynValue;
2236(DynValue)__receiver)
2237 }
2238 }
2239 #[doc = "`ToPrintString()` overload"]
2240 fn to_print_string(self) -> ::unity::Il2CppString {
2241 unsafe {
2242 let __receiver = <DynValue as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2243 ::unity::il2cpp_call!(__DynValue_unity_raw::__lookup_to_print_string::get_method_info().method_ptr, ::unity::Il2CppString;
2244(DynValue)__receiver)
2245 }
2246 }
2247 #[doc = "`ToDebugPrintString()` overload"]
2248 fn to_debug_print_string(self) -> ::unity::Il2CppString {
2249 unsafe {
2250 let __receiver = <DynValue as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2251 ::unity::il2cpp_call!(__DynValue_unity_raw::__lookup_to_debug_print_string::get_method_info().method_ptr, ::unity::Il2CppString;
2252(DynValue)__receiver)
2253 }
2254 }
2255 #[doc = "`ToString()` overload"]
2256 fn to_string(self) -> ::unity::Il2CppString {
2257 unsafe {
2258 let __receiver = <DynValue as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2259 {
2260 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2261 let __vi = *__vt.get(3usize).unwrap_or_else(|| {
2262 panic!(
2263 "unity: virtual slot {}
2264 out of range (vtable len {}
2265) on the runtime class behind {}
2266 (method `{}
2267`)",
2268 3usize,
2269 __vt.len(),
2270 <DynValue as ::unity::ClassIdentity>::NAME,
2271 "ToString",
2272 )
2273 });
2274 let __inner: extern "C" fn(DynValue, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__vi.method_ptr);
2275 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2276 __inner(__receiver, __mi)
2277 }
2278 }
2279 }
2280 #[doc = "`GetHashCode()` overload"]
2281 fn get_hash_code(self) -> i32 {
2282 unsafe {
2283 let __receiver = <DynValue as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2284 {
2285 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2286 let __vi = *__vt.get(2usize).unwrap_or_else(|| {
2287 panic!(
2288 "unity: virtual slot {}
2289 out of range (vtable len {}
2290) on the runtime class behind {}
2291 (method `{}
2292`)",
2293 2usize,
2294 __vt.len(),
2295 <DynValue as ::unity::ClassIdentity>::NAME,
2296 "GetHashCode",
2297 )
2298 });
2299 let __inner: extern "C" fn(DynValue, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__vi.method_ptr);
2300 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2301 __inner(__receiver, __mi)
2302 }
2303 }
2304 }
2305 #[doc = "`Equals(crate::system::object::Object)` overload"]
2306 fn equals(self, obj: impl ::core::convert::Into<crate::system::object::Object>) -> bool {
2307 unsafe {
2308 let __receiver = <DynValue as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2309 {
2310 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2311 let __vi = *__vt.get(0usize).unwrap_or_else(|| {
2312 panic!(
2313 "unity: virtual slot {}
2314 out of range (vtable len {}
2315) on the runtime class behind {}
2316 (method `{}
2317`)",
2318 0usize,
2319 __vt.len(),
2320 <DynValue as ::unity::ClassIdentity>::NAME,
2321 "Equals",
2322 )
2323 });
2324 let __inner: extern "C" fn(DynValue, crate::system::object::Object, ::unity::OptionalMethod) -> bool =
2325 ::core::mem::transmute(__vi.method_ptr);
2326 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2327 __inner(__receiver, ::core::convert::Into::into(obj), __mi)
2328 }
2329 }
2330 }
2331 #[doc = "`CastToString()` overload"]
2332 fn cast_to_string(self) -> ::unity::Il2CppString {
2333 unsafe {
2334 let __receiver = <DynValue as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2335 ::unity::il2cpp_call!(__DynValue_unity_raw::__lookup_cast_to_string::get_method_info().method_ptr, ::unity::Il2CppString;
2336(DynValue)__receiver)
2337 }
2338 }
2339 #[doc = "`CastToBool()` overload"]
2340 fn cast_to_bool(self) -> bool {
2341 unsafe {
2342 let __receiver = <DynValue as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2343 ::unity::il2cpp_call!(__DynValue_unity_raw::__lookup_cast_to_bool::get_method_info().method_ptr,bool;
2344(DynValue)__receiver)
2345 }
2346 }
2347 #[doc = "`GetAsPrivateResource()` overload"]
2348 fn get_as_private_resource(self) -> crate::moon_sharp::interpreter::iscriptprivateresource::IScriptPrivateResource {
2349 unsafe {
2350 let __receiver = <DynValue as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2351 ::unity::il2cpp_call!(__DynValue_unity_raw::__lookup_get_as_private_resource::get_method_info().method_ptr,crate::moon_sharp::interpreter::iscriptprivateresource::IScriptPrivateResource;
2352(DynValue)__receiver)
2353 }
2354 }
2355 #[doc = "`ToScalar()` overload"]
2356 fn to_scalar(self) -> crate::moon_sharp::interpreter::dynvalue::DynValue {
2357 unsafe {
2358 let __receiver = <DynValue as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2359 ::unity::il2cpp_call!(__DynValue_unity_raw::__lookup_to_scalar::get_method_info().method_ptr,crate::moon_sharp::interpreter::dynvalue::DynValue;
2360(DynValue)__receiver)
2361 }
2362 }
2363 #[doc = "`Assign(crate::moon_sharp::interpreter::dynvalue::DynValue)` overload"]
2364 fn assign(self, value: impl ::core::convert::Into<crate::moon_sharp::interpreter::dynvalue::DynValue>) -> () {
2365 unsafe {
2366 let __receiver = <DynValue as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2367 ::unity::il2cpp_call!(__DynValue_unity_raw::__lookup_assign::get_method_info().method_ptr,();
2368(DynValue)__receiver,(crate::moon_sharp::interpreter::dynvalue::DynValue)::core::convert::Into::into(value))
2369 }
2370 }
2371 #[doc = "`GetLength()` overload"]
2372 fn get_length(self) -> crate::moon_sharp::interpreter::dynvalue::DynValue {
2373 unsafe {
2374 let __receiver = <DynValue as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2375 ::unity::il2cpp_call!(__DynValue_unity_raw::__lookup_get_length::get_method_info().method_ptr,crate::moon_sharp::interpreter::dynvalue::DynValue;
2376(DynValue)__receiver)
2377 }
2378 }
2379 #[doc = "`IsNil()` overload"]
2380 fn is_nil(self) -> bool {
2381 unsafe {
2382 let __receiver = <DynValue as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2383 ::unity::il2cpp_call!(__DynValue_unity_raw::__lookup_is_nil::get_method_info().method_ptr,bool;
2384(DynValue)__receiver)
2385 }
2386 }
2387 #[doc = "`IsNotNil()` overload"]
2388 fn is_not_nil(self) -> bool {
2389 unsafe {
2390 let __receiver = <DynValue as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2391 ::unity::il2cpp_call!(__DynValue_unity_raw::__lookup_is_not_nil::get_method_info().method_ptr,bool;
2392(DynValue)__receiver)
2393 }
2394 }
2395 #[doc = "`IsVoid()` overload"]
2396 fn is_void(self) -> bool {
2397 unsafe {
2398 let __receiver = <DynValue as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2399 ::unity::il2cpp_call!(__DynValue_unity_raw::__lookup_is_void::get_method_info().method_ptr,bool;
2400(DynValue)__receiver)
2401 }
2402 }
2403 #[doc = "`IsNotVoid()` overload"]
2404 fn is_not_void(self) -> bool {
2405 unsafe {
2406 let __receiver = <DynValue as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2407 ::unity::il2cpp_call!(__DynValue_unity_raw::__lookup_is_not_void::get_method_info().method_ptr,bool;
2408(DynValue)__receiver)
2409 }
2410 }
2411 #[doc = "`IsNilOrNan()` overload"]
2412 fn is_nil_or_nan(self) -> bool {
2413 unsafe {
2414 let __receiver = <DynValue as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2415 ::unity::il2cpp_call!(__DynValue_unity_raw::__lookup_is_nil_or_nan::get_method_info().method_ptr,bool;
2416(DynValue)__receiver)
2417 }
2418 }
2419 #[doc = "`AssignNumber(f64)` overload"]
2420 fn assign_number(self, num: impl ::core::convert::Into<f64>) -> () {
2421 unsafe {
2422 let __receiver = <DynValue as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2423 ::unity::il2cpp_call!(__DynValue_unity_raw::__lookup_assign_number::get_method_info().method_ptr,();
2424(DynValue)__receiver,(f64)::core::convert::Into::into(num))
2425 }
2426 }
2427 #[doc = "`ToObject()` overload"]
2428 fn to_object(self) -> crate::system::object::Object {
2429 unsafe {
2430 let __receiver = <DynValue as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2431 ::unity::il2cpp_call!(__DynValue_unity_raw::__lookup_to_object::get_method_info().method_ptr,crate::system::object::Object;
2432(DynValue)__receiver)
2433 }
2434 }
2435 #[doc = "`ToObject(::unity::SystemType)` overload"]
2436 fn to_object_2(self, desired_type: impl ::core::convert::Into<::unity::SystemType>) -> crate::system::object::Object {
2437 unsafe {
2438 let __receiver = <DynValue as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2439 ::unity::il2cpp_call!(__DynValue_unity_raw::__lookup_to_object_2::get_method_info().method_ptr,crate::system::object::Object;
2440(DynValue)__receiver,(::unity::SystemType)::core::convert::Into::into(desired_type))
2441 }
2442 }
2443 #[doc = "`CheckType(::unity::Il2CppString, crate::moon_sharp::interpreter::datatype::DataType, i32, crate::moon_sharp::interpreter::typevalidationflags::TypeValidationFlags)` overload"]
2444 fn check_type(
2445 self,
2446 func_name: impl ::core::convert::Into<::unity::Il2CppString>,
2447 desired_type: impl ::core::convert::Into<crate::moon_sharp::interpreter::datatype::DataType>,
2448 arg_num: impl ::core::convert::Into<i32>,
2449 flags: impl ::core::convert::Into<crate::moon_sharp::interpreter::typevalidationflags::TypeValidationFlags>,
2450 ) -> crate::moon_sharp::interpreter::dynvalue::DynValue {
2451 unsafe {
2452 let __receiver = <DynValue as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2453 ::unity::il2cpp_call!(__DynValue_unity_raw::__lookup_check_type::get_method_info().method_ptr,crate::moon_sharp::interpreter::dynvalue::DynValue;
2454(DynValue)__receiver,(::unity::Il2CppString)::core::convert::Into::into(func_name),(crate::moon_sharp::interpreter::datatype::DataType)::core::convert::Into::into(desired_type),(i32)::core::convert::Into::into(arg_num),(crate::moon_sharp::interpreter::typevalidationflags::TypeValidationFlags)::core::convert::Into::into(flags))
2455 }
2456 }
2457 fn check_user_data_type<M0: ::unity::IlType + ::core::marker::Copy + ::unity::ClassIdentity>(
2458 self,
2459 func_name: impl ::core::convert::Into<::unity::Il2CppString>,
2460 arg_num: impl ::core::convert::Into<i32>,
2461 flags: impl ::core::convert::Into<crate::moon_sharp::interpreter::typevalidationflags::TypeValidationFlags>,
2462 ) -> M0 {
2463 static OPEN: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
2464 ::unity::lookup::method_info_on_class(<DynValue as ::unity::ClassIdentity>::class(), "CheckUserDataType", 3)
2465 });
2466 #[allow(clippy::type_complexity)]
2467 static CACHE: ::std::sync::OnceLock<::std::sync::Mutex<::std::collections::HashMap<usize, &'static ::unity::il2cpp::MethodInfo>>> =
2468 ::std::sync::OnceLock::new();
2469 let _ = false;
2470 let __open: &'static ::unity::il2cpp::MethodInfo = match &*OPEN {
2471 ::core::result::Result::Ok(mi) => *mi,
2472 ::core::result::Result::Err(e) => {
2473 panic!(
2474 "method lookup failed: {}
2475::{}
2476: {}
2477",
2478 <DynValue as ::unity::ClassIdentity>::NAME,
2479 "CheckUserDataType",
2480 e
2481 )
2482 },
2483 };
2484 let __cache = CACHE.get_or_init(|| ::std::sync::Mutex::new(::std::collections::HashMap::new()));
2485 let __key: usize = <M0 as ::unity::IlType>::il_type() as *const _ as usize;
2486 let __inflated: &'static ::unity::il2cpp::MethodInfo = {
2487 let mut __guard = __cache.lock().unwrap();
2488 *__guard
2489 .entry(__key)
2490 .or_insert_with(|| ::unity::il2cpp::generic::create_generic_method_info(__open, &[<M0 as ::unity::IlType>::il_type()]))
2491 };
2492 unsafe {
2493 let __receiver = <DynValue as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2494 let __f: extern "C" fn(
2495 DynValue,
2496 ::unity::Il2CppString,
2497 i32,
2498 crate::moon_sharp::interpreter::typevalidationflags::TypeValidationFlags,
2499 ::unity::OptionalMethod,
2500 ) -> M0 = ::core::mem::transmute(__inflated.method_ptr);
2501 let __mi_opaque: &'static () = &*(__inflated as *const _ as *const ());
2502 __f(
2503 __receiver,
2504 ::core::convert::Into::into(func_name),
2505 ::core::convert::Into::into(arg_num),
2506 ::core::convert::Into::into(flags),
2507 ::core::option::Option::Some(__mi_opaque),
2508 )
2509 }
2510 }
2511 #[doc = "`.ctor()` overload"]
2512 fn ctor(self) -> () {
2513 unsafe {
2514 let __receiver = <DynValue as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2515 ::unity::il2cpp_call!(__DynValue_unity_raw::__lookup_ctor::get_method_info().method_ptr,();
2516(DynValue)__receiver)
2517 }
2518 }
2519}
2520
2521#[cfg(feature = "moon_sharp-interpreter-dynvalue")]
2522impl<__T: IDynValue> IDynValueMethods for __T {}
2523
2524#[cfg(feature = "moon_sharp-interpreter-dynvalue")]
2525impl DynValue {
2526 pub fn get_reference_id_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2527 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
2528 }
2529
2530 pub fn get_type_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2531 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
2532 }
2533
2534 pub fn get_function_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2535 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
2536 }
2537
2538 pub fn get_number_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2539 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
2540 }
2541
2542 pub fn get_tuple_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2543 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
2544 }
2545
2546 pub fn get_coroutine_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2547 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
2548 }
2549
2550 pub fn get_table_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2551 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
2552 }
2553
2554 pub fn get_boolean_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2555 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
2556 }
2557
2558 pub fn get_string_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2559 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[8]
2560 }
2561
2562 pub fn get_callback_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2563 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[9]
2564 }
2565
2566 pub fn get_tail_call_data_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2567 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[10]
2568 }
2569
2570 pub fn get_yield_request_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2571 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[11]
2572 }
2573
2574 pub fn get_user_data_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2575 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[12]
2576 }
2577
2578 pub fn get_read_only_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2579 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[13]
2580 }
2581
2582 pub fn new_nil_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2583 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[14]
2584 }
2585
2586 pub fn new_boolean_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2587 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[15]
2588 }
2589
2590 pub fn new_number_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2591 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[16]
2592 }
2593
2594 pub fn new_string_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2595 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[17]
2596 }
2597
2598 pub fn new_string_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2599 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[19]
2600 }
2601
2602 pub fn new_coroutine_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2603 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[20]
2604 }
2605
2606 pub fn new_closure_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2607 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[21]
2608 }
2609
2610 pub fn new_callback_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2611 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[22]
2612 }
2613
2614 pub fn new_callback_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2615 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[23]
2616 }
2617
2618 pub fn new_table_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2619 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[24]
2620 }
2621
2622 pub fn new_prime_table_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2623 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[25]
2624 }
2625
2626 pub fn new_table_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2627 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[26]
2628 }
2629
2630 pub fn new_table_3_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2631 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[27]
2632 }
2633
2634 pub fn new_tail_call_req_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2635 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[28]
2636 }
2637
2638 pub fn new_tail_call_req_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2639 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[29]
2640 }
2641
2642 pub fn new_yield_req_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2643 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[30]
2644 }
2645
2646 pub fn new_forced_yield_req_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2647 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[31]
2648 }
2649
2650 pub fn new_tuple_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2651 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[32]
2652 }
2653
2654 pub fn new_tuple_nested_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2655 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[33]
2656 }
2657
2658 pub fn new_user_data_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2659 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[34]
2660 }
2661
2662 pub fn as_read_only_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2663 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[35]
2664 }
2665
2666 pub fn clone_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2667 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[36]
2668 }
2669
2670 pub fn clone_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2671 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[37]
2672 }
2673
2674 pub fn clone_as_writable_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2675 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[38]
2676 }
2677
2678 pub fn get_void_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2679 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[39]
2680 }
2681
2682 pub fn set_void_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2683 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[40]
2684 }
2685
2686 pub fn get_nil_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2687 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[41]
2688 }
2689
2690 pub fn set_nil_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2691 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[42]
2692 }
2693
2694 pub fn get_true_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2695 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[43]
2696 }
2697
2698 pub fn set_true_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2699 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[44]
2700 }
2701
2702 pub fn get_false_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2703 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[45]
2704 }
2705
2706 pub fn set_false_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2707 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[46]
2708 }
2709
2710 pub fn cctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2711 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[47]
2712 }
2713
2714 pub fn to_print_string_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2715 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[48]
2716 }
2717
2718 pub fn to_debug_print_string_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2719 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[49]
2720 }
2721
2722 pub fn to_string_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2723 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[50]
2724 }
2725
2726 pub fn get_hash_code_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2727 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[51]
2728 }
2729
2730 pub fn equals_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2731 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[52]
2732 }
2733
2734 pub fn cast_to_string_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2735 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[53]
2736 }
2737
2738 pub fn cast_to_bool_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2739 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[55]
2740 }
2741
2742 pub fn get_as_private_resource_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2743 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[56]
2744 }
2745
2746 pub fn to_scalar_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2747 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[57]
2748 }
2749
2750 pub fn assign_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2751 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[58]
2752 }
2753
2754 pub fn get_length_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2755 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[59]
2756 }
2757
2758 pub fn is_nil_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2759 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[60]
2760 }
2761
2762 pub fn is_not_nil_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2763 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[61]
2764 }
2765
2766 pub fn is_void_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2767 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[62]
2768 }
2769
2770 pub fn is_not_void_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2771 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[63]
2772 }
2773
2774 pub fn is_nil_or_nan_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2775 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[64]
2776 }
2777
2778 pub fn assign_number_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2779 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[65]
2780 }
2781
2782 pub fn from_object_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2783 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[66]
2784 }
2785
2786 pub fn to_object_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2787 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[67]
2788 }
2789
2790 pub fn to_object_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2791 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[68]
2792 }
2793
2794 pub fn check_type_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2795 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[70]
2796 }
2797
2798 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2799 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[72]
2800 }
2801}
2802
2803#[cfg(feature = "moon_sharp-interpreter-dynvalue")]
2804impl DynValue {
2805 #[doc = "Direct (non-virtual) call to `DynValue`'s own `ToString`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2806 pub unsafe fn to_string(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
2807 let __mi = Self::to_string_method_info();
2808 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
2809 __inner(this.into(), ::core::option::Option::None)
2810 }
2811
2812 #[doc = "Direct (non-virtual) call to `DynValue`'s own `GetHashCode`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2813 pub unsafe fn get_hash_code(this: impl ::core::convert::Into<::unity::IlInstance>) -> i32 {
2814 let __mi = Self::get_hash_code_method_info();
2815 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__mi.method_ptr);
2816 __inner(this.into(), ::core::option::Option::None)
2817 }
2818
2819 #[doc = "Direct (non-virtual) call to `DynValue`'s own `Equals`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2820 pub unsafe fn equals(this: impl ::core::convert::Into<::unity::IlInstance>, obj: crate::system::object::Object) -> bool {
2821 let __mi = Self::equals_method_info();
2822 let __inner: extern "C" fn(::unity::IlInstance, crate::system::object::Object, ::unity::OptionalMethod) -> bool =
2823 ::core::mem::transmute(__mi.method_ptr);
2824 __inner(this.into(), obj, ::core::option::Option::None)
2825 }
2826}
2827
2828#[cfg(feature = "moon_sharp-interpreter-dynvalue")]
2829impl DynValue {
2830 #[doc = "`.ctor()` — no args"]
2831 pub fn new() -> Self {
2832 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
2833 panic!(
2834 "{}
2835::{}
2836 failed to instantiate",
2837 ::core::stringify!(DynValue),
2838 ::core::stringify!(new),
2839 )
2840 });
2841 <Self as IDynValueMethods>::ctor(this);
2842 this
2843 }
2844}
2845
2846#[cfg(feature = "moon_sharp-interpreter-dynvalue")]
2847#[doc(hidden)]
2848pub mod prelude {
2849 pub use super::{DynValue, IDynValue, IDynValueMethods};
2850 pub use crate::system::object::IObject;
2851 #[cfg(feature = "system-object")]
2852 pub use crate::system::object::IObjectMethods;
2853}