1#[cfg(feature = "moon_sharp-interpreter-compatibility-frameworks-frameworkbase-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/compatibility/frameworks/frameworkbase/FrameworkBase.md"))]
11 #[::unity::class(namespace = "MoonSharp.Interpreter.Compatibility.Frameworks", name = "FrameworkBase")]
12 #[parent(crate::system::object::Object)]
13 pub struct FrameworkBase {}
14}
15
16#[cfg(feature = "moon_sharp-interpreter-compatibility-frameworks-frameworkbase-types")]
17pub use __types::*;
18
19#[cfg(feature = "moon_sharp-interpreter-compatibility-frameworks-frameworkbase")]
20#[doc(hidden)]
21#[allow(non_snake_case, non_camel_case_types, clippy::too_many_arguments)]
22mod __FrameworkBase_unity_raw {
23 use super::*;
24 #[doc(hidden)]
25 #[allow(non_snake_case)]
26 pub mod __lookup_ctor {
27 use super::*;
28 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
29 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
30 ::unity::lookup::method_info_on_class_with_signature(<FrameworkBase as ::unity::ClassIdentity>::class(), ".ctor", 0, param_types, false)
31 });
32 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
33 match &*METHOD {
34 ::core::result::Result::Ok(mi) => *mi,
35 ::core::result::Result::Err(e) => {
36 panic!(
37 "method lookup failed: {}
38::{}
39: {}
40",
41 <FrameworkBase as ::unity::ClassIdentity>::NAME,
42 ".ctor",
43 e
44 )
45 },
46 }
47 }
48 }
49}
50
51#[cfg(feature = "moon_sharp-interpreter-compatibility-frameworks-frameworkbase")]
52pub trait IFrameworkBaseMethods: IFrameworkBase {
53 #[doc = "`StringContainsChar(::unity::Il2CppString, u16)` overload"]
54 fn string_contains_char(self, str: impl ::core::convert::Into<::unity::Il2CppString>, chr: impl ::core::convert::Into<u16>) -> bool {
55 unsafe {
56 let __receiver = <FrameworkBase as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
57 {
58 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
59 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
60 panic!(
61 "unity: virtual slot {}
62 out of range (vtable len {}
63) on the runtime class behind {}
64 (method `{}
65`)",
66 4usize,
67 __vt.len(),
68 <FrameworkBase as ::unity::ClassIdentity>::NAME,
69 "StringContainsChar",
70 )
71 });
72 let __inner: extern "C" fn(FrameworkBase, ::unity::Il2CppString, u16, ::unity::OptionalMethod) -> bool =
73 ::core::mem::transmute(__vi.method_ptr);
74 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
75 __inner(__receiver, ::core::convert::Into::into(str), ::core::convert::Into::into(chr), __mi)
76 }
77 }
78 }
79 #[doc = "`IsValueType(::unity::SystemType)` overload"]
80 fn is_value_type(self, t: impl ::core::convert::Into<::unity::SystemType>) -> bool {
81 unsafe {
82 let __receiver = <FrameworkBase as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
83 {
84 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
85 let __vi = *__vt.get(5usize).unwrap_or_else(|| {
86 panic!(
87 "unity: virtual slot {}
88 out of range (vtable len {}
89) on the runtime class behind {}
90 (method `{}
91`)",
92 5usize,
93 __vt.len(),
94 <FrameworkBase as ::unity::ClassIdentity>::NAME,
95 "IsValueType",
96 )
97 });
98 let __inner: extern "C" fn(FrameworkBase, ::unity::SystemType, ::unity::OptionalMethod) -> bool =
99 ::core::mem::transmute(__vi.method_ptr);
100 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
101 __inner(__receiver, ::core::convert::Into::into(t), __mi)
102 }
103 }
104 }
105 #[doc = "`GetAssembly(::unity::SystemType)` overload"]
106 fn get_assembly(self, t: impl ::core::convert::Into<::unity::SystemType>) -> crate::system::reflection::assembly::Assembly {
107 unsafe {
108 let __receiver = <FrameworkBase as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
109 {
110 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
111 let __vi = *__vt.get(6usize).unwrap_or_else(|| {
112 panic!(
113 "unity: virtual slot {}
114 out of range (vtable len {}
115) on the runtime class behind {}
116 (method `{}
117`)",
118 6usize,
119 __vt.len(),
120 <FrameworkBase as ::unity::ClassIdentity>::NAME,
121 "GetAssembly",
122 )
123 });
124 let __inner: extern "C" fn(
125 FrameworkBase,
126 ::unity::SystemType,
127 ::unity::OptionalMethod,
128 ) -> crate::system::reflection::assembly::Assembly = ::core::mem::transmute(__vi.method_ptr);
129 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
130 __inner(__receiver, ::core::convert::Into::into(t), __mi)
131 }
132 }
133 }
134 #[doc = "`GetBaseType(::unity::SystemType)` overload"]
135 fn get_base_type(self, t: impl ::core::convert::Into<::unity::SystemType>) -> ::unity::SystemType {
136 unsafe {
137 let __receiver = <FrameworkBase as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
138 {
139 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
140 let __vi = *__vt.get(7usize).unwrap_or_else(|| {
141 panic!(
142 "unity: virtual slot {}
143 out of range (vtable len {}
144) on the runtime class behind {}
145 (method `{}
146`)",
147 7usize,
148 __vt.len(),
149 <FrameworkBase as ::unity::ClassIdentity>::NAME,
150 "GetBaseType",
151 )
152 });
153 let __inner: extern "C" fn(FrameworkBase, ::unity::SystemType, ::unity::OptionalMethod) -> ::unity::SystemType =
154 ::core::mem::transmute(__vi.method_ptr);
155 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
156 __inner(__receiver, ::core::convert::Into::into(t), __mi)
157 }
158 }
159 }
160 #[doc = "`IsGenericType(::unity::SystemType)` overload"]
161 fn is_generic_type(self, t: impl ::core::convert::Into<::unity::SystemType>) -> bool {
162 unsafe {
163 let __receiver = <FrameworkBase as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
164 {
165 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
166 let __vi = *__vt.get(8usize).unwrap_or_else(|| {
167 panic!(
168 "unity: virtual slot {}
169 out of range (vtable len {}
170) on the runtime class behind {}
171 (method `{}
172`)",
173 8usize,
174 __vt.len(),
175 <FrameworkBase as ::unity::ClassIdentity>::NAME,
176 "IsGenericType",
177 )
178 });
179 let __inner: extern "C" fn(FrameworkBase, ::unity::SystemType, ::unity::OptionalMethod) -> bool =
180 ::core::mem::transmute(__vi.method_ptr);
181 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
182 __inner(__receiver, ::core::convert::Into::into(t), __mi)
183 }
184 }
185 }
186 #[doc = "`IsGenericTypeDefinition(::unity::SystemType)` overload"]
187 fn is_generic_type_definition(self, t: impl ::core::convert::Into<::unity::SystemType>) -> bool {
188 unsafe {
189 let __receiver = <FrameworkBase as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
190 {
191 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
192 let __vi = *__vt.get(9usize).unwrap_or_else(|| {
193 panic!(
194 "unity: virtual slot {}
195 out of range (vtable len {}
196) on the runtime class behind {}
197 (method `{}
198`)",
199 9usize,
200 __vt.len(),
201 <FrameworkBase as ::unity::ClassIdentity>::NAME,
202 "IsGenericTypeDefinition",
203 )
204 });
205 let __inner: extern "C" fn(FrameworkBase, ::unity::SystemType, ::unity::OptionalMethod) -> bool =
206 ::core::mem::transmute(__vi.method_ptr);
207 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
208 __inner(__receiver, ::core::convert::Into::into(t), __mi)
209 }
210 }
211 }
212 #[doc = "`IsEnum(::unity::SystemType)` overload"]
213 fn is_enum(self, t: impl ::core::convert::Into<::unity::SystemType>) -> bool {
214 unsafe {
215 let __receiver = <FrameworkBase as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
216 {
217 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
218 let __vi = *__vt.get(10usize).unwrap_or_else(|| {
219 panic!(
220 "unity: virtual slot {}
221 out of range (vtable len {}
222) on the runtime class behind {}
223 (method `{}
224`)",
225 10usize,
226 __vt.len(),
227 <FrameworkBase as ::unity::ClassIdentity>::NAME,
228 "IsEnum",
229 )
230 });
231 let __inner: extern "C" fn(FrameworkBase, ::unity::SystemType, ::unity::OptionalMethod) -> bool =
232 ::core::mem::transmute(__vi.method_ptr);
233 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
234 __inner(__receiver, ::core::convert::Into::into(t), __mi)
235 }
236 }
237 }
238 #[doc = "`IsNestedPublic(::unity::SystemType)` overload"]
239 fn is_nested_public(self, t: impl ::core::convert::Into<::unity::SystemType>) -> bool {
240 unsafe {
241 let __receiver = <FrameworkBase as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
242 {
243 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
244 let __vi = *__vt.get(11usize).unwrap_or_else(|| {
245 panic!(
246 "unity: virtual slot {}
247 out of range (vtable len {}
248) on the runtime class behind {}
249 (method `{}
250`)",
251 11usize,
252 __vt.len(),
253 <FrameworkBase as ::unity::ClassIdentity>::NAME,
254 "IsNestedPublic",
255 )
256 });
257 let __inner: extern "C" fn(FrameworkBase, ::unity::SystemType, ::unity::OptionalMethod) -> bool =
258 ::core::mem::transmute(__vi.method_ptr);
259 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
260 __inner(__receiver, ::core::convert::Into::into(t), __mi)
261 }
262 }
263 }
264 #[doc = "`IsAbstract(::unity::SystemType)` overload"]
265 fn is_abstract(self, t: impl ::core::convert::Into<::unity::SystemType>) -> bool {
266 unsafe {
267 let __receiver = <FrameworkBase as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
268 {
269 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
270 let __vi = *__vt.get(12usize).unwrap_or_else(|| {
271 panic!(
272 "unity: virtual slot {}
273 out of range (vtable len {}
274) on the runtime class behind {}
275 (method `{}
276`)",
277 12usize,
278 __vt.len(),
279 <FrameworkBase as ::unity::ClassIdentity>::NAME,
280 "IsAbstract",
281 )
282 });
283 let __inner: extern "C" fn(FrameworkBase, ::unity::SystemType, ::unity::OptionalMethod) -> bool =
284 ::core::mem::transmute(__vi.method_ptr);
285 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
286 __inner(__receiver, ::core::convert::Into::into(t), __mi)
287 }
288 }
289 }
290 #[doc = "`IsInterface(::unity::SystemType)` overload"]
291 fn is_interface(self, t: impl ::core::convert::Into<::unity::SystemType>) -> bool {
292 unsafe {
293 let __receiver = <FrameworkBase as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
294 {
295 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
296 let __vi = *__vt.get(13usize).unwrap_or_else(|| {
297 panic!(
298 "unity: virtual slot {}
299 out of range (vtable len {}
300) on the runtime class behind {}
301 (method `{}
302`)",
303 13usize,
304 __vt.len(),
305 <FrameworkBase as ::unity::ClassIdentity>::NAME,
306 "IsInterface",
307 )
308 });
309 let __inner: extern "C" fn(FrameworkBase, ::unity::SystemType, ::unity::OptionalMethod) -> bool =
310 ::core::mem::transmute(__vi.method_ptr);
311 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
312 __inner(__receiver, ::core::convert::Into::into(t), __mi)
313 }
314 }
315 }
316 #[doc = "`GetInterfaces(::unity::SystemType)` overload"]
317 fn get_interfaces(self, t: impl ::core::convert::Into<::unity::SystemType>) -> ::unity::Array<::unity::SystemType> {
318 unsafe {
319 let __receiver = <FrameworkBase as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
320 {
321 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
322 let __vi = *__vt.get(16usize).unwrap_or_else(|| {
323 panic!(
324 "unity: virtual slot {}
325 out of range (vtable len {}
326) on the runtime class behind {}
327 (method `{}
328`)",
329 16usize,
330 __vt.len(),
331 <FrameworkBase as ::unity::ClassIdentity>::NAME,
332 "GetInterfaces",
333 )
334 });
335 let __inner: extern "C" fn(FrameworkBase, ::unity::SystemType, ::unity::OptionalMethod) -> ::unity::Array<::unity::SystemType> =
336 ::core::mem::transmute(__vi.method_ptr);
337 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
338 __inner(__receiver, ::core::convert::Into::into(t), __mi)
339 }
340 }
341 }
342 #[doc = "`IsInstanceOfType(::unity::SystemType, crate::system::object::Object)` overload"]
343 fn is_instance_of_type(
344 self,
345 t: impl ::core::convert::Into<::unity::SystemType>,
346 o: impl ::core::convert::Into<crate::system::object::Object>,
347 ) -> bool {
348 unsafe {
349 let __receiver = <FrameworkBase as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
350 {
351 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
352 let __vi = *__vt.get(17usize).unwrap_or_else(|| {
353 panic!(
354 "unity: virtual slot {}
355 out of range (vtable len {}
356) on the runtime class behind {}
357 (method `{}
358`)",
359 17usize,
360 __vt.len(),
361 <FrameworkBase as ::unity::ClassIdentity>::NAME,
362 "IsInstanceOfType",
363 )
364 });
365 let __inner: extern "C" fn(FrameworkBase, ::unity::SystemType, crate::system::object::Object, ::unity::OptionalMethod) -> bool =
366 ::core::mem::transmute(__vi.method_ptr);
367 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
368 __inner(__receiver, ::core::convert::Into::into(t), ::core::convert::Into::into(o), __mi)
369 }
370 }
371 }
372 #[doc = "`GetAddMethod(crate::system::reflection::eventinfo::EventInfo)` overload"]
373 fn get_add_method(
374 self,
375 ei: impl ::core::convert::Into<crate::system::reflection::eventinfo::EventInfo>,
376 ) -> crate::system::reflection::methodinfo::MethodInfo {
377 unsafe {
378 let __receiver = <FrameworkBase as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
379 {
380 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
381 let __vi = *__vt.get(18usize).unwrap_or_else(|| {
382 panic!(
383 "unity: virtual slot {}
384 out of range (vtable len {}
385) on the runtime class behind {}
386 (method `{}
387`)",
388 18usize,
389 __vt.len(),
390 <FrameworkBase as ::unity::ClassIdentity>::NAME,
391 "GetAddMethod",
392 )
393 });
394 let __inner: extern "C" fn(
395 FrameworkBase,
396 crate::system::reflection::eventinfo::EventInfo,
397 ::unity::OptionalMethod,
398 ) -> crate::system::reflection::methodinfo::MethodInfo = ::core::mem::transmute(__vi.method_ptr);
399 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
400 __inner(__receiver, ::core::convert::Into::into(ei), __mi)
401 }
402 }
403 }
404 #[doc = "`GetRemoveMethod(crate::system::reflection::eventinfo::EventInfo)` overload"]
405 fn get_remove_method(
406 self,
407 ei: impl ::core::convert::Into<crate::system::reflection::eventinfo::EventInfo>,
408 ) -> crate::system::reflection::methodinfo::MethodInfo {
409 unsafe {
410 let __receiver = <FrameworkBase as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
411 {
412 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
413 let __vi = *__vt.get(19usize).unwrap_or_else(|| {
414 panic!(
415 "unity: virtual slot {}
416 out of range (vtable len {}
417) on the runtime class behind {}
418 (method `{}
419`)",
420 19usize,
421 __vt.len(),
422 <FrameworkBase as ::unity::ClassIdentity>::NAME,
423 "GetRemoveMethod",
424 )
425 });
426 let __inner: extern "C" fn(
427 FrameworkBase,
428 crate::system::reflection::eventinfo::EventInfo,
429 ::unity::OptionalMethod,
430 ) -> crate::system::reflection::methodinfo::MethodInfo = ::core::mem::transmute(__vi.method_ptr);
431 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
432 __inner(__receiver, ::core::convert::Into::into(ei), __mi)
433 }
434 }
435 }
436 #[doc = "`GetGetMethod(crate::system::reflection::propertyinfo::PropertyInfo)` overload"]
437 fn get_get_method(
438 self,
439 pi: impl ::core::convert::Into<crate::system::reflection::propertyinfo::PropertyInfo>,
440 ) -> crate::system::reflection::methodinfo::MethodInfo {
441 unsafe {
442 let __receiver = <FrameworkBase as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
443 {
444 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
445 let __vi = *__vt.get(20usize).unwrap_or_else(|| {
446 panic!(
447 "unity: virtual slot {}
448 out of range (vtable len {}
449) on the runtime class behind {}
450 (method `{}
451`)",
452 20usize,
453 __vt.len(),
454 <FrameworkBase as ::unity::ClassIdentity>::NAME,
455 "GetGetMethod",
456 )
457 });
458 let __inner: extern "C" fn(
459 FrameworkBase,
460 crate::system::reflection::propertyinfo::PropertyInfo,
461 ::unity::OptionalMethod,
462 ) -> crate::system::reflection::methodinfo::MethodInfo = ::core::mem::transmute(__vi.method_ptr);
463 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
464 __inner(__receiver, ::core::convert::Into::into(pi), __mi)
465 }
466 }
467 }
468 #[doc = "`GetSetMethod(crate::system::reflection::propertyinfo::PropertyInfo)` overload"]
469 fn get_set_method(
470 self,
471 pi: impl ::core::convert::Into<crate::system::reflection::propertyinfo::PropertyInfo>,
472 ) -> crate::system::reflection::methodinfo::MethodInfo {
473 unsafe {
474 let __receiver = <FrameworkBase as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
475 {
476 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
477 let __vi = *__vt.get(21usize).unwrap_or_else(|| {
478 panic!(
479 "unity: virtual slot {}
480 out of range (vtable len {}
481) on the runtime class behind {}
482 (method `{}
483`)",
484 21usize,
485 __vt.len(),
486 <FrameworkBase as ::unity::ClassIdentity>::NAME,
487 "GetSetMethod",
488 )
489 });
490 let __inner: extern "C" fn(
491 FrameworkBase,
492 crate::system::reflection::propertyinfo::PropertyInfo,
493 ::unity::OptionalMethod,
494 ) -> crate::system::reflection::methodinfo::MethodInfo = ::core::mem::transmute(__vi.method_ptr);
495 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
496 __inner(__receiver, ::core::convert::Into::into(pi), __mi)
497 }
498 }
499 }
500 #[doc = "`GetInterface(::unity::SystemType, ::unity::Il2CppString)` overload"]
501 fn get_interface(
502 self,
503 r#type: impl ::core::convert::Into<::unity::SystemType>,
504 name: impl ::core::convert::Into<::unity::Il2CppString>,
505 ) -> ::unity::SystemType {
506 unsafe {
507 let __receiver = <FrameworkBase as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
508 {
509 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
510 let __vi = *__vt.get(22usize).unwrap_or_else(|| {
511 panic!(
512 "unity: virtual slot {}
513 out of range (vtable len {}
514) on the runtime class behind {}
515 (method `{}
516`)",
517 22usize,
518 __vt.len(),
519 <FrameworkBase as ::unity::ClassIdentity>::NAME,
520 "GetInterface",
521 )
522 });
523 let __inner: extern "C" fn(
524 FrameworkBase,
525 ::unity::SystemType,
526 ::unity::Il2CppString,
527 ::unity::OptionalMethod,
528 ) -> ::unity::SystemType = ::core::mem::transmute(__vi.method_ptr);
529 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
530 __inner(__receiver, ::core::convert::Into::into(r#type), ::core::convert::Into::into(name), __mi)
531 }
532 }
533 }
534 #[doc = "`GetProperties(::unity::SystemType)` overload"]
535 fn get_properties(
536 self,
537 r#type: impl ::core::convert::Into<::unity::SystemType>,
538 ) -> ::unity::Array<crate::system::reflection::propertyinfo::PropertyInfo> {
539 unsafe {
540 let __receiver = <FrameworkBase as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
541 {
542 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
543 let __vi = *__vt.get(23usize).unwrap_or_else(|| {
544 panic!(
545 "unity: virtual slot {}
546 out of range (vtable len {}
547) on the runtime class behind {}
548 (method `{}
549`)",
550 23usize,
551 __vt.len(),
552 <FrameworkBase as ::unity::ClassIdentity>::NAME,
553 "GetProperties",
554 )
555 });
556 let __inner: extern "C" fn(
557 FrameworkBase,
558 ::unity::SystemType,
559 ::unity::OptionalMethod,
560 ) -> ::unity::Array<crate::system::reflection::propertyinfo::PropertyInfo> = ::core::mem::transmute(__vi.method_ptr);
561 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
562 __inner(__receiver, ::core::convert::Into::into(r#type), __mi)
563 }
564 }
565 }
566 #[doc = "`GetProperty(::unity::SystemType, ::unity::Il2CppString)` overload"]
567 fn get_property(
568 self,
569 r#type: impl ::core::convert::Into<::unity::SystemType>,
570 name: impl ::core::convert::Into<::unity::Il2CppString>,
571 ) -> crate::system::reflection::propertyinfo::PropertyInfo {
572 unsafe {
573 let __receiver = <FrameworkBase as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
574 {
575 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
576 let __vi = *__vt.get(24usize).unwrap_or_else(|| {
577 panic!(
578 "unity: virtual slot {}
579 out of range (vtable len {}
580) on the runtime class behind {}
581 (method `{}
582`)",
583 24usize,
584 __vt.len(),
585 <FrameworkBase as ::unity::ClassIdentity>::NAME,
586 "GetProperty",
587 )
588 });
589 let __inner: extern "C" fn(
590 FrameworkBase,
591 ::unity::SystemType,
592 ::unity::Il2CppString,
593 ::unity::OptionalMethod,
594 ) -> crate::system::reflection::propertyinfo::PropertyInfo = ::core::mem::transmute(__vi.method_ptr);
595 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
596 __inner(__receiver, ::core::convert::Into::into(r#type), ::core::convert::Into::into(name), __mi)
597 }
598 }
599 }
600 #[doc = "`GetNestedTypes(::unity::SystemType)` overload"]
601 fn get_nested_types(self, r#type: impl ::core::convert::Into<::unity::SystemType>) -> ::unity::Array<::unity::SystemType> {
602 unsafe {
603 let __receiver = <FrameworkBase as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
604 {
605 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
606 let __vi = *__vt.get(25usize).unwrap_or_else(|| {
607 panic!(
608 "unity: virtual slot {}
609 out of range (vtable len {}
610) on the runtime class behind {}
611 (method `{}
612`)",
613 25usize,
614 __vt.len(),
615 <FrameworkBase as ::unity::ClassIdentity>::NAME,
616 "GetNestedTypes",
617 )
618 });
619 let __inner: extern "C" fn(FrameworkBase, ::unity::SystemType, ::unity::OptionalMethod) -> ::unity::Array<::unity::SystemType> =
620 ::core::mem::transmute(__vi.method_ptr);
621 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
622 __inner(__receiver, ::core::convert::Into::into(r#type), __mi)
623 }
624 }
625 }
626 #[doc = "`GetEvents(::unity::SystemType)` overload"]
627 fn get_events(self, r#type: impl ::core::convert::Into<::unity::SystemType>) -> ::unity::Array<crate::system::reflection::eventinfo::EventInfo> {
628 unsafe {
629 let __receiver = <FrameworkBase as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
630 {
631 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
632 let __vi = *__vt.get(26usize).unwrap_or_else(|| {
633 panic!(
634 "unity: virtual slot {}
635 out of range (vtable len {}
636) on the runtime class behind {}
637 (method `{}
638`)",
639 26usize,
640 __vt.len(),
641 <FrameworkBase as ::unity::ClassIdentity>::NAME,
642 "GetEvents",
643 )
644 });
645 let __inner: extern "C" fn(
646 FrameworkBase,
647 ::unity::SystemType,
648 ::unity::OptionalMethod,
649 ) -> ::unity::Array<crate::system::reflection::eventinfo::EventInfo> = ::core::mem::transmute(__vi.method_ptr);
650 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
651 __inner(__receiver, ::core::convert::Into::into(r#type), __mi)
652 }
653 }
654 }
655 #[doc = "`GetConstructors(::unity::SystemType)` overload"]
656 fn get_constructors(
657 self,
658 r#type: impl ::core::convert::Into<::unity::SystemType>,
659 ) -> ::unity::Array<crate::system::reflection::constructorinfo::ConstructorInfo> {
660 unsafe {
661 let __receiver = <FrameworkBase as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
662 {
663 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
664 let __vi = *__vt.get(27usize).unwrap_or_else(|| {
665 panic!(
666 "unity: virtual slot {}
667 out of range (vtable len {}
668) on the runtime class behind {}
669 (method `{}
670`)",
671 27usize,
672 __vt.len(),
673 <FrameworkBase as ::unity::ClassIdentity>::NAME,
674 "GetConstructors",
675 )
676 });
677 let __inner: extern "C" fn(
678 FrameworkBase,
679 ::unity::SystemType,
680 ::unity::OptionalMethod,
681 ) -> ::unity::Array<crate::system::reflection::constructorinfo::ConstructorInfo> = ::core::mem::transmute(__vi.method_ptr);
682 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
683 __inner(__receiver, ::core::convert::Into::into(r#type), __mi)
684 }
685 }
686 }
687 #[doc = "`GetAssemblyTypes(crate::system::reflection::assembly::Assembly)` overload"]
688 fn get_assembly_types(
689 self,
690 asm: impl ::core::convert::Into<crate::system::reflection::assembly::Assembly>,
691 ) -> ::unity::Array<::unity::SystemType> {
692 unsafe {
693 let __receiver = <FrameworkBase as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
694 {
695 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
696 let __vi = *__vt.get(28usize).unwrap_or_else(|| {
697 panic!(
698 "unity: virtual slot {}
699 out of range (vtable len {}
700) on the runtime class behind {}
701 (method `{}
702`)",
703 28usize,
704 __vt.len(),
705 <FrameworkBase as ::unity::ClassIdentity>::NAME,
706 "GetAssemblyTypes",
707 )
708 });
709 let __inner: extern "C" fn(
710 FrameworkBase,
711 crate::system::reflection::assembly::Assembly,
712 ::unity::OptionalMethod,
713 ) -> ::unity::Array<::unity::SystemType> = ::core::mem::transmute(__vi.method_ptr);
714 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
715 __inner(__receiver, ::core::convert::Into::into(asm), __mi)
716 }
717 }
718 }
719 #[doc = "`GetMethods(::unity::SystemType)` overload"]
720 fn get_methods(
721 self,
722 r#type: impl ::core::convert::Into<::unity::SystemType>,
723 ) -> ::unity::Array<crate::system::reflection::methodinfo::MethodInfo> {
724 unsafe {
725 let __receiver = <FrameworkBase as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
726 {
727 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
728 let __vi = *__vt.get(29usize).unwrap_or_else(|| {
729 panic!(
730 "unity: virtual slot {}
731 out of range (vtable len {}
732) on the runtime class behind {}
733 (method `{}
734`)",
735 29usize,
736 __vt.len(),
737 <FrameworkBase as ::unity::ClassIdentity>::NAME,
738 "GetMethods",
739 )
740 });
741 let __inner: extern "C" fn(
742 FrameworkBase,
743 ::unity::SystemType,
744 ::unity::OptionalMethod,
745 ) -> ::unity::Array<crate::system::reflection::methodinfo::MethodInfo> = ::core::mem::transmute(__vi.method_ptr);
746 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
747 __inner(__receiver, ::core::convert::Into::into(r#type), __mi)
748 }
749 }
750 }
751 #[doc = "`GetFields(::unity::SystemType)` overload"]
752 fn get_fields(self, t: impl ::core::convert::Into<::unity::SystemType>) -> ::unity::Array<crate::system::reflection::fieldinfo::FieldInfo> {
753 unsafe {
754 let __receiver = <FrameworkBase as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
755 {
756 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
757 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
758 panic!(
759 "unity: virtual slot {}
760 out of range (vtable len {}
761) on the runtime class behind {}
762 (method `{}
763`)",
764 30usize,
765 __vt.len(),
766 <FrameworkBase as ::unity::ClassIdentity>::NAME,
767 "GetFields",
768 )
769 });
770 let __inner: extern "C" fn(
771 FrameworkBase,
772 ::unity::SystemType,
773 ::unity::OptionalMethod,
774 ) -> ::unity::Array<crate::system::reflection::fieldinfo::FieldInfo> = ::core::mem::transmute(__vi.method_ptr);
775 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
776 __inner(__receiver, ::core::convert::Into::into(t), __mi)
777 }
778 }
779 }
780 #[doc = "`GetMethod(::unity::SystemType, ::unity::Il2CppString)` overload"]
781 fn get_method(
782 self,
783 r#type: impl ::core::convert::Into<::unity::SystemType>,
784 name: impl ::core::convert::Into<::unity::Il2CppString>,
785 ) -> crate::system::reflection::methodinfo::MethodInfo {
786 unsafe {
787 let __receiver = <FrameworkBase as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
788 {
789 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
790 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
791 panic!(
792 "unity: virtual slot {}
793 out of range (vtable len {}
794) on the runtime class behind {}
795 (method `{}
796`)",
797 31usize,
798 __vt.len(),
799 <FrameworkBase as ::unity::ClassIdentity>::NAME,
800 "GetMethod",
801 )
802 });
803 let __inner: extern "C" fn(
804 FrameworkBase,
805 ::unity::SystemType,
806 ::unity::Il2CppString,
807 ::unity::OptionalMethod,
808 ) -> crate::system::reflection::methodinfo::MethodInfo = ::core::mem::transmute(__vi.method_ptr);
809 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
810 __inner(__receiver, ::core::convert::Into::into(r#type), ::core::convert::Into::into(name), __mi)
811 }
812 }
813 }
814 #[doc = "`GetGenericArguments(::unity::SystemType)` overload"]
815 fn get_generic_arguments(self, t: impl ::core::convert::Into<::unity::SystemType>) -> ::unity::Array<::unity::SystemType> {
816 unsafe {
817 let __receiver = <FrameworkBase as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
818 {
819 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
820 let __vi = *__vt.get(32usize).unwrap_or_else(|| {
821 panic!(
822 "unity: virtual slot {}
823 out of range (vtable len {}
824) on the runtime class behind {}
825 (method `{}
826`)",
827 32usize,
828 __vt.len(),
829 <FrameworkBase as ::unity::ClassIdentity>::NAME,
830 "GetGenericArguments",
831 )
832 });
833 let __inner: extern "C" fn(FrameworkBase, ::unity::SystemType, ::unity::OptionalMethod) -> ::unity::Array<::unity::SystemType> =
834 ::core::mem::transmute(__vi.method_ptr);
835 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
836 __inner(__receiver, ::core::convert::Into::into(t), __mi)
837 }
838 }
839 }
840 #[doc = "`IsAssignableFrom(::unity::SystemType, ::unity::SystemType)` overload"]
841 fn is_assignable_from(
842 self,
843 current: impl ::core::convert::Into<::unity::SystemType>,
844 to_compare: impl ::core::convert::Into<::unity::SystemType>,
845 ) -> bool {
846 unsafe {
847 let __receiver = <FrameworkBase as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
848 {
849 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
850 let __vi = *__vt.get(33usize).unwrap_or_else(|| {
851 panic!(
852 "unity: virtual slot {}
853 out of range (vtable len {}
854) on the runtime class behind {}
855 (method `{}
856`)",
857 33usize,
858 __vt.len(),
859 <FrameworkBase as ::unity::ClassIdentity>::NAME,
860 "IsAssignableFrom",
861 )
862 });
863 let __inner: extern "C" fn(FrameworkBase, ::unity::SystemType, ::unity::SystemType, ::unity::OptionalMethod) -> bool =
864 ::core::mem::transmute(__vi.method_ptr);
865 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
866 __inner(
867 __receiver,
868 ::core::convert::Into::into(current),
869 ::core::convert::Into::into(to_compare),
870 __mi,
871 )
872 }
873 }
874 }
875 #[doc = "`IsDbNull(crate::system::object::Object)` overload"]
876 fn is_db_null(self, o: impl ::core::convert::Into<crate::system::object::Object>) -> bool {
877 unsafe {
878 let __receiver = <FrameworkBase as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
879 {
880 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
881 let __vi = *__vt.get(34usize).unwrap_or_else(|| {
882 panic!(
883 "unity: virtual slot {}
884 out of range (vtable len {}
885) on the runtime class behind {}
886 (method `{}
887`)",
888 34usize,
889 __vt.len(),
890 <FrameworkBase as ::unity::ClassIdentity>::NAME,
891 "IsDbNull",
892 )
893 });
894 let __inner: extern "C" fn(FrameworkBase, crate::system::object::Object, ::unity::OptionalMethod) -> bool =
895 ::core::mem::transmute(__vi.method_ptr);
896 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
897 __inner(__receiver, ::core::convert::Into::into(o), __mi)
898 }
899 }
900 }
901 #[doc = "`GetMethod(::unity::SystemType, ::unity::Il2CppString, ::unity::Array<::unity::SystemType>)` overload"]
902 fn get_method_2(
903 self,
904 resources_type: impl ::core::convert::Into<::unity::SystemType>,
905 v: impl ::core::convert::Into<::unity::Il2CppString>,
906 r#type: impl ::core::convert::Into<::unity::Array<::unity::SystemType>>,
907 ) -> crate::system::reflection::methodinfo::MethodInfo {
908 unsafe {
909 let __receiver = <FrameworkBase as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
910 {
911 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
912 let __vi = *__vt.get(35usize).unwrap_or_else(|| {
913 panic!(
914 "unity: virtual slot {}
915 out of range (vtable len {}
916) on the runtime class behind {}
917 (method `{}
918`)",
919 35usize,
920 __vt.len(),
921 <FrameworkBase as ::unity::ClassIdentity>::NAME,
922 "GetMethod",
923 )
924 });
925 let __inner: extern "C" fn(
926 FrameworkBase,
927 ::unity::SystemType,
928 ::unity::Il2CppString,
929 ::unity::Array<::unity::SystemType>,
930 ::unity::OptionalMethod,
931 ) -> crate::system::reflection::methodinfo::MethodInfo = ::core::mem::transmute(__vi.method_ptr);
932 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
933 __inner(
934 __receiver,
935 ::core::convert::Into::into(resources_type),
936 ::core::convert::Into::into(v),
937 ::core::convert::Into::into(r#type),
938 __mi,
939 )
940 }
941 }
942 }
943 #[doc = "`.ctor()` overload"]
944 fn ctor(self) -> () {
945 unsafe {
946 let __receiver = <FrameworkBase as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
947 ::unity::il2cpp_call!(__FrameworkBase_unity_raw::__lookup_ctor::get_method_info().method_ptr,();
948(FrameworkBase)__receiver)
949 }
950 }
951}
952
953#[cfg(feature = "moon_sharp-interpreter-compatibility-frameworks-frameworkbase")]
954impl<__T: IFrameworkBase> IFrameworkBaseMethods for __T {}
955
956#[cfg(feature = "moon_sharp-interpreter-compatibility-frameworks-frameworkbase")]
957impl FrameworkBase {
958 pub fn string_contains_char_method_info() -> &'static ::unity::il2cpp::MethodInfo {
959 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
960 }
961
962 pub fn is_value_type_method_info() -> &'static ::unity::il2cpp::MethodInfo {
963 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
964 }
965
966 pub fn get_assembly_method_info() -> &'static ::unity::il2cpp::MethodInfo {
967 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
968 }
969
970 pub fn get_base_type_method_info() -> &'static ::unity::il2cpp::MethodInfo {
971 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
972 }
973
974 pub fn is_generic_type_method_info() -> &'static ::unity::il2cpp::MethodInfo {
975 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
976 }
977
978 pub fn is_generic_type_definition_method_info() -> &'static ::unity::il2cpp::MethodInfo {
979 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
980 }
981
982 pub fn is_enum_method_info() -> &'static ::unity::il2cpp::MethodInfo {
983 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
984 }
985
986 pub fn is_nested_public_method_info() -> &'static ::unity::il2cpp::MethodInfo {
987 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
988 }
989
990 pub fn is_abstract_method_info() -> &'static ::unity::il2cpp::MethodInfo {
991 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[8]
992 }
993
994 pub fn is_interface_method_info() -> &'static ::unity::il2cpp::MethodInfo {
995 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[9]
996 }
997
998 pub fn get_interfaces_method_info() -> &'static ::unity::il2cpp::MethodInfo {
999 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[12]
1000 }
1001
1002 pub fn is_instance_of_type_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1003 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[13]
1004 }
1005
1006 pub fn get_add_method_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1007 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[14]
1008 }
1009
1010 pub fn get_remove_method_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1011 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[15]
1012 }
1013
1014 pub fn get_get_method_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1015 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[16]
1016 }
1017
1018 pub fn get_set_method_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1019 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[17]
1020 }
1021
1022 pub fn get_interface_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1023 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[18]
1024 }
1025
1026 pub fn get_properties_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1027 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[19]
1028 }
1029
1030 pub fn get_property_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1031 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[20]
1032 }
1033
1034 pub fn get_nested_types_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1035 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[21]
1036 }
1037
1038 pub fn get_events_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1039 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[22]
1040 }
1041
1042 pub fn get_constructors_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1043 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[23]
1044 }
1045
1046 pub fn get_assembly_types_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1047 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[24]
1048 }
1049
1050 pub fn get_methods_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1051 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[25]
1052 }
1053
1054 pub fn get_fields_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1055 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[26]
1056 }
1057
1058 pub fn get_method_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1059 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[27]
1060 }
1061
1062 pub fn get_generic_arguments_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1063 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[28]
1064 }
1065
1066 pub fn is_assignable_from_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1067 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[29]
1068 }
1069
1070 pub fn is_db_null_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1071 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[30]
1072 }
1073
1074 pub fn get_method_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1075 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[31]
1076 }
1077
1078 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1079 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[32]
1080 }
1081}
1082
1083#[cfg(feature = "moon_sharp-interpreter-compatibility-frameworks-frameworkbase")]
1084impl FrameworkBase {
1085 #[doc = "Direct (non-virtual) call to `FrameworkBase`'s own `StringContainsChar`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1086 pub unsafe fn string_contains_char(this: impl ::core::convert::Into<::unity::IlInstance>, str: ::unity::Il2CppString, chr: u16) -> bool {
1087 let __mi = Self::string_contains_char_method_info();
1088 let __inner: extern "C" fn(::unity::IlInstance, ::unity::Il2CppString, u16, ::unity::OptionalMethod) -> bool =
1089 ::core::mem::transmute(__mi.method_ptr);
1090 __inner(this.into(), str, chr, ::core::option::Option::None)
1091 }
1092
1093 #[doc = "Direct (non-virtual) call to `FrameworkBase`'s own `IsValueType`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1094 pub unsafe fn is_value_type(this: impl ::core::convert::Into<::unity::IlInstance>, t: ::unity::SystemType) -> bool {
1095 let __mi = Self::is_value_type_method_info();
1096 let __inner: extern "C" fn(::unity::IlInstance, ::unity::SystemType, ::unity::OptionalMethod) -> bool =
1097 ::core::mem::transmute(__mi.method_ptr);
1098 __inner(this.into(), t, ::core::option::Option::None)
1099 }
1100
1101 #[doc = "Direct (non-virtual) call to `FrameworkBase`'s own `GetAssembly`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1102 pub unsafe fn get_assembly(
1103 this: impl ::core::convert::Into<::unity::IlInstance>,
1104 t: ::unity::SystemType,
1105 ) -> crate::system::reflection::assembly::Assembly {
1106 let __mi = Self::get_assembly_method_info();
1107 let __inner: extern "C" fn(
1108 ::unity::IlInstance,
1109 ::unity::SystemType,
1110 ::unity::OptionalMethod,
1111 ) -> crate::system::reflection::assembly::Assembly = ::core::mem::transmute(__mi.method_ptr);
1112 __inner(this.into(), t, ::core::option::Option::None)
1113 }
1114
1115 #[doc = "Direct (non-virtual) call to `FrameworkBase`'s own `GetBaseType`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1116 pub unsafe fn get_base_type(this: impl ::core::convert::Into<::unity::IlInstance>, t: ::unity::SystemType) -> ::unity::SystemType {
1117 let __mi = Self::get_base_type_method_info();
1118 let __inner: extern "C" fn(::unity::IlInstance, ::unity::SystemType, ::unity::OptionalMethod) -> ::unity::SystemType =
1119 ::core::mem::transmute(__mi.method_ptr);
1120 __inner(this.into(), t, ::core::option::Option::None)
1121 }
1122
1123 #[doc = "Direct (non-virtual) call to `FrameworkBase`'s own `IsGenericType`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1124 pub unsafe fn is_generic_type(this: impl ::core::convert::Into<::unity::IlInstance>, t: ::unity::SystemType) -> bool {
1125 let __mi = Self::is_generic_type_method_info();
1126 let __inner: extern "C" fn(::unity::IlInstance, ::unity::SystemType, ::unity::OptionalMethod) -> bool =
1127 ::core::mem::transmute(__mi.method_ptr);
1128 __inner(this.into(), t, ::core::option::Option::None)
1129 }
1130
1131 #[doc = "Direct (non-virtual) call to `FrameworkBase`'s own `IsGenericTypeDefinition`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1132 pub unsafe fn is_generic_type_definition(this: impl ::core::convert::Into<::unity::IlInstance>, t: ::unity::SystemType) -> bool {
1133 let __mi = Self::is_generic_type_definition_method_info();
1134 let __inner: extern "C" fn(::unity::IlInstance, ::unity::SystemType, ::unity::OptionalMethod) -> bool =
1135 ::core::mem::transmute(__mi.method_ptr);
1136 __inner(this.into(), t, ::core::option::Option::None)
1137 }
1138
1139 #[doc = "Direct (non-virtual) call to `FrameworkBase`'s own `IsEnum`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1140 pub unsafe fn is_enum(this: impl ::core::convert::Into<::unity::IlInstance>, t: ::unity::SystemType) -> bool {
1141 let __mi = Self::is_enum_method_info();
1142 let __inner: extern "C" fn(::unity::IlInstance, ::unity::SystemType, ::unity::OptionalMethod) -> bool =
1143 ::core::mem::transmute(__mi.method_ptr);
1144 __inner(this.into(), t, ::core::option::Option::None)
1145 }
1146
1147 #[doc = "Direct (non-virtual) call to `FrameworkBase`'s own `IsNestedPublic`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1148 pub unsafe fn is_nested_public(this: impl ::core::convert::Into<::unity::IlInstance>, t: ::unity::SystemType) -> bool {
1149 let __mi = Self::is_nested_public_method_info();
1150 let __inner: extern "C" fn(::unity::IlInstance, ::unity::SystemType, ::unity::OptionalMethod) -> bool =
1151 ::core::mem::transmute(__mi.method_ptr);
1152 __inner(this.into(), t, ::core::option::Option::None)
1153 }
1154
1155 #[doc = "Direct (non-virtual) call to `FrameworkBase`'s own `IsAbstract`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1156 pub unsafe fn is_abstract(this: impl ::core::convert::Into<::unity::IlInstance>, t: ::unity::SystemType) -> bool {
1157 let __mi = Self::is_abstract_method_info();
1158 let __inner: extern "C" fn(::unity::IlInstance, ::unity::SystemType, ::unity::OptionalMethod) -> bool =
1159 ::core::mem::transmute(__mi.method_ptr);
1160 __inner(this.into(), t, ::core::option::Option::None)
1161 }
1162
1163 #[doc = "Direct (non-virtual) call to `FrameworkBase`'s own `IsInterface`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1164 pub unsafe fn is_interface(this: impl ::core::convert::Into<::unity::IlInstance>, t: ::unity::SystemType) -> bool {
1165 let __mi = Self::is_interface_method_info();
1166 let __inner: extern "C" fn(::unity::IlInstance, ::unity::SystemType, ::unity::OptionalMethod) -> bool =
1167 ::core::mem::transmute(__mi.method_ptr);
1168 __inner(this.into(), t, ::core::option::Option::None)
1169 }
1170
1171 #[doc = "Direct (non-virtual) call to `FrameworkBase`'s own `GetInterfaces`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1172 pub unsafe fn get_interfaces(
1173 this: impl ::core::convert::Into<::unity::IlInstance>,
1174 t: ::unity::SystemType,
1175 ) -> ::unity::Array<::unity::SystemType> {
1176 let __mi = Self::get_interfaces_method_info();
1177 let __inner: extern "C" fn(::unity::IlInstance, ::unity::SystemType, ::unity::OptionalMethod) -> ::unity::Array<::unity::SystemType> =
1178 ::core::mem::transmute(__mi.method_ptr);
1179 __inner(this.into(), t, ::core::option::Option::None)
1180 }
1181
1182 #[doc = "Direct (non-virtual) call to `FrameworkBase`'s own `IsInstanceOfType`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1183 pub unsafe fn is_instance_of_type(
1184 this: impl ::core::convert::Into<::unity::IlInstance>,
1185 t: ::unity::SystemType,
1186 o: crate::system::object::Object,
1187 ) -> bool {
1188 let __mi = Self::is_instance_of_type_method_info();
1189 let __inner: extern "C" fn(::unity::IlInstance, ::unity::SystemType, crate::system::object::Object, ::unity::OptionalMethod) -> bool =
1190 ::core::mem::transmute(__mi.method_ptr);
1191 __inner(this.into(), t, o, ::core::option::Option::None)
1192 }
1193
1194 #[doc = "Direct (non-virtual) call to `FrameworkBase`'s own `GetAddMethod`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1195 pub unsafe fn get_add_method(
1196 this: impl ::core::convert::Into<::unity::IlInstance>,
1197 ei: crate::system::reflection::eventinfo::EventInfo,
1198 ) -> crate::system::reflection::methodinfo::MethodInfo {
1199 let __mi = Self::get_add_method_method_info();
1200 let __inner: extern "C" fn(
1201 ::unity::IlInstance,
1202 crate::system::reflection::eventinfo::EventInfo,
1203 ::unity::OptionalMethod,
1204 ) -> crate::system::reflection::methodinfo::MethodInfo = ::core::mem::transmute(__mi.method_ptr);
1205 __inner(this.into(), ei, ::core::option::Option::None)
1206 }
1207
1208 #[doc = "Direct (non-virtual) call to `FrameworkBase`'s own `GetRemoveMethod`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1209 pub unsafe fn get_remove_method(
1210 this: impl ::core::convert::Into<::unity::IlInstance>,
1211 ei: crate::system::reflection::eventinfo::EventInfo,
1212 ) -> crate::system::reflection::methodinfo::MethodInfo {
1213 let __mi = Self::get_remove_method_method_info();
1214 let __inner: extern "C" fn(
1215 ::unity::IlInstance,
1216 crate::system::reflection::eventinfo::EventInfo,
1217 ::unity::OptionalMethod,
1218 ) -> crate::system::reflection::methodinfo::MethodInfo = ::core::mem::transmute(__mi.method_ptr);
1219 __inner(this.into(), ei, ::core::option::Option::None)
1220 }
1221
1222 #[doc = "Direct (non-virtual) call to `FrameworkBase`'s own `GetGetMethod`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1223 pub unsafe fn get_get_method(
1224 this: impl ::core::convert::Into<::unity::IlInstance>,
1225 pi: crate::system::reflection::propertyinfo::PropertyInfo,
1226 ) -> crate::system::reflection::methodinfo::MethodInfo {
1227 let __mi = Self::get_get_method_method_info();
1228 let __inner: extern "C" fn(
1229 ::unity::IlInstance,
1230 crate::system::reflection::propertyinfo::PropertyInfo,
1231 ::unity::OptionalMethod,
1232 ) -> crate::system::reflection::methodinfo::MethodInfo = ::core::mem::transmute(__mi.method_ptr);
1233 __inner(this.into(), pi, ::core::option::Option::None)
1234 }
1235
1236 #[doc = "Direct (non-virtual) call to `FrameworkBase`'s own `GetSetMethod`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1237 pub unsafe fn get_set_method(
1238 this: impl ::core::convert::Into<::unity::IlInstance>,
1239 pi: crate::system::reflection::propertyinfo::PropertyInfo,
1240 ) -> crate::system::reflection::methodinfo::MethodInfo {
1241 let __mi = Self::get_set_method_method_info();
1242 let __inner: extern "C" fn(
1243 ::unity::IlInstance,
1244 crate::system::reflection::propertyinfo::PropertyInfo,
1245 ::unity::OptionalMethod,
1246 ) -> crate::system::reflection::methodinfo::MethodInfo = ::core::mem::transmute(__mi.method_ptr);
1247 __inner(this.into(), pi, ::core::option::Option::None)
1248 }
1249
1250 #[doc = "Direct (non-virtual) call to `FrameworkBase`'s own `GetInterface`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1251 pub unsafe fn get_interface(
1252 this: impl ::core::convert::Into<::unity::IlInstance>,
1253 r#type: ::unity::SystemType,
1254 name: ::unity::Il2CppString,
1255 ) -> ::unity::SystemType {
1256 let __mi = Self::get_interface_method_info();
1257 let __inner: extern "C" fn(::unity::IlInstance, ::unity::SystemType, ::unity::Il2CppString, ::unity::OptionalMethod) -> ::unity::SystemType =
1258 ::core::mem::transmute(__mi.method_ptr);
1259 __inner(this.into(), r#type, name, ::core::option::Option::None)
1260 }
1261
1262 #[doc = "Direct (non-virtual) call to `FrameworkBase`'s own `GetProperties`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1263 pub unsafe fn get_properties(
1264 this: impl ::core::convert::Into<::unity::IlInstance>,
1265 r#type: ::unity::SystemType,
1266 ) -> ::unity::Array<crate::system::reflection::propertyinfo::PropertyInfo> {
1267 let __mi = Self::get_properties_method_info();
1268 let __inner: extern "C" fn(
1269 ::unity::IlInstance,
1270 ::unity::SystemType,
1271 ::unity::OptionalMethod,
1272 ) -> ::unity::Array<crate::system::reflection::propertyinfo::PropertyInfo> = ::core::mem::transmute(__mi.method_ptr);
1273 __inner(this.into(), r#type, ::core::option::Option::None)
1274 }
1275
1276 #[doc = "Direct (non-virtual) call to `FrameworkBase`'s own `GetProperty`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1277 pub unsafe fn get_property(
1278 this: impl ::core::convert::Into<::unity::IlInstance>,
1279 r#type: ::unity::SystemType,
1280 name: ::unity::Il2CppString,
1281 ) -> crate::system::reflection::propertyinfo::PropertyInfo {
1282 let __mi = Self::get_property_method_info();
1283 let __inner: extern "C" fn(
1284 ::unity::IlInstance,
1285 ::unity::SystemType,
1286 ::unity::Il2CppString,
1287 ::unity::OptionalMethod,
1288 ) -> crate::system::reflection::propertyinfo::PropertyInfo = ::core::mem::transmute(__mi.method_ptr);
1289 __inner(this.into(), r#type, name, ::core::option::Option::None)
1290 }
1291
1292 #[doc = "Direct (non-virtual) call to `FrameworkBase`'s own `GetNestedTypes`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1293 pub unsafe fn get_nested_types(
1294 this: impl ::core::convert::Into<::unity::IlInstance>,
1295 r#type: ::unity::SystemType,
1296 ) -> ::unity::Array<::unity::SystemType> {
1297 let __mi = Self::get_nested_types_method_info();
1298 let __inner: extern "C" fn(::unity::IlInstance, ::unity::SystemType, ::unity::OptionalMethod) -> ::unity::Array<::unity::SystemType> =
1299 ::core::mem::transmute(__mi.method_ptr);
1300 __inner(this.into(), r#type, ::core::option::Option::None)
1301 }
1302
1303 #[doc = "Direct (non-virtual) call to `FrameworkBase`'s own `GetEvents`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1304 pub unsafe fn get_events(
1305 this: impl ::core::convert::Into<::unity::IlInstance>,
1306 r#type: ::unity::SystemType,
1307 ) -> ::unity::Array<crate::system::reflection::eventinfo::EventInfo> {
1308 let __mi = Self::get_events_method_info();
1309 let __inner: extern "C" fn(
1310 ::unity::IlInstance,
1311 ::unity::SystemType,
1312 ::unity::OptionalMethod,
1313 ) -> ::unity::Array<crate::system::reflection::eventinfo::EventInfo> = ::core::mem::transmute(__mi.method_ptr);
1314 __inner(this.into(), r#type, ::core::option::Option::None)
1315 }
1316
1317 #[doc = "Direct (non-virtual) call to `FrameworkBase`'s own `GetConstructors`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1318 pub unsafe fn get_constructors(
1319 this: impl ::core::convert::Into<::unity::IlInstance>,
1320 r#type: ::unity::SystemType,
1321 ) -> ::unity::Array<crate::system::reflection::constructorinfo::ConstructorInfo> {
1322 let __mi = Self::get_constructors_method_info();
1323 let __inner: extern "C" fn(
1324 ::unity::IlInstance,
1325 ::unity::SystemType,
1326 ::unity::OptionalMethod,
1327 ) -> ::unity::Array<crate::system::reflection::constructorinfo::ConstructorInfo> = ::core::mem::transmute(__mi.method_ptr);
1328 __inner(this.into(), r#type, ::core::option::Option::None)
1329 }
1330
1331 #[doc = "Direct (non-virtual) call to `FrameworkBase`'s own `GetAssemblyTypes`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1332 pub unsafe fn get_assembly_types(
1333 this: impl ::core::convert::Into<::unity::IlInstance>,
1334 asm: crate::system::reflection::assembly::Assembly,
1335 ) -> ::unity::Array<::unity::SystemType> {
1336 let __mi = Self::get_assembly_types_method_info();
1337 let __inner: extern "C" fn(
1338 ::unity::IlInstance,
1339 crate::system::reflection::assembly::Assembly,
1340 ::unity::OptionalMethod,
1341 ) -> ::unity::Array<::unity::SystemType> = ::core::mem::transmute(__mi.method_ptr);
1342 __inner(this.into(), asm, ::core::option::Option::None)
1343 }
1344
1345 #[doc = "Direct (non-virtual) call to `FrameworkBase`'s own `GetMethods`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1346 pub unsafe fn get_methods(
1347 this: impl ::core::convert::Into<::unity::IlInstance>,
1348 r#type: ::unity::SystemType,
1349 ) -> ::unity::Array<crate::system::reflection::methodinfo::MethodInfo> {
1350 let __mi = Self::get_methods_method_info();
1351 let __inner: extern "C" fn(
1352 ::unity::IlInstance,
1353 ::unity::SystemType,
1354 ::unity::OptionalMethod,
1355 ) -> ::unity::Array<crate::system::reflection::methodinfo::MethodInfo> = ::core::mem::transmute(__mi.method_ptr);
1356 __inner(this.into(), r#type, ::core::option::Option::None)
1357 }
1358
1359 #[doc = "Direct (non-virtual) call to `FrameworkBase`'s own `GetFields`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1360 pub unsafe fn get_fields(
1361 this: impl ::core::convert::Into<::unity::IlInstance>,
1362 t: ::unity::SystemType,
1363 ) -> ::unity::Array<crate::system::reflection::fieldinfo::FieldInfo> {
1364 let __mi = Self::get_fields_method_info();
1365 let __inner: extern "C" fn(
1366 ::unity::IlInstance,
1367 ::unity::SystemType,
1368 ::unity::OptionalMethod,
1369 ) -> ::unity::Array<crate::system::reflection::fieldinfo::FieldInfo> = ::core::mem::transmute(__mi.method_ptr);
1370 __inner(this.into(), t, ::core::option::Option::None)
1371 }
1372
1373 #[doc = "Direct (non-virtual) call to `FrameworkBase`'s own `GetMethod`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1374 pub unsafe fn get_method(
1375 this: impl ::core::convert::Into<::unity::IlInstance>,
1376 r#type: ::unity::SystemType,
1377 name: ::unity::Il2CppString,
1378 ) -> crate::system::reflection::methodinfo::MethodInfo {
1379 let __mi = Self::get_method_method_info();
1380 let __inner: extern "C" fn(
1381 ::unity::IlInstance,
1382 ::unity::SystemType,
1383 ::unity::Il2CppString,
1384 ::unity::OptionalMethod,
1385 ) -> crate::system::reflection::methodinfo::MethodInfo = ::core::mem::transmute(__mi.method_ptr);
1386 __inner(this.into(), r#type, name, ::core::option::Option::None)
1387 }
1388
1389 #[doc = "Direct (non-virtual) call to `FrameworkBase`'s own `GetGenericArguments`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1390 pub unsafe fn get_generic_arguments(
1391 this: impl ::core::convert::Into<::unity::IlInstance>,
1392 t: ::unity::SystemType,
1393 ) -> ::unity::Array<::unity::SystemType> {
1394 let __mi = Self::get_generic_arguments_method_info();
1395 let __inner: extern "C" fn(::unity::IlInstance, ::unity::SystemType, ::unity::OptionalMethod) -> ::unity::Array<::unity::SystemType> =
1396 ::core::mem::transmute(__mi.method_ptr);
1397 __inner(this.into(), t, ::core::option::Option::None)
1398 }
1399
1400 #[doc = "Direct (non-virtual) call to `FrameworkBase`'s own `IsAssignableFrom`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1401 pub unsafe fn is_assignable_from(
1402 this: impl ::core::convert::Into<::unity::IlInstance>,
1403 current: ::unity::SystemType,
1404 to_compare: ::unity::SystemType,
1405 ) -> bool {
1406 let __mi = Self::is_assignable_from_method_info();
1407 let __inner: extern "C" fn(::unity::IlInstance, ::unity::SystemType, ::unity::SystemType, ::unity::OptionalMethod) -> bool =
1408 ::core::mem::transmute(__mi.method_ptr);
1409 __inner(this.into(), current, to_compare, ::core::option::Option::None)
1410 }
1411
1412 #[doc = "Direct (non-virtual) call to `FrameworkBase`'s own `IsDbNull`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1413 pub unsafe fn is_db_null(this: impl ::core::convert::Into<::unity::IlInstance>, o: crate::system::object::Object) -> bool {
1414 let __mi = Self::is_db_null_method_info();
1415 let __inner: extern "C" fn(::unity::IlInstance, crate::system::object::Object, ::unity::OptionalMethod) -> bool =
1416 ::core::mem::transmute(__mi.method_ptr);
1417 __inner(this.into(), o, ::core::option::Option::None)
1418 }
1419
1420 #[doc = "Direct (non-virtual) call to `FrameworkBase`'s own `GetMethod`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1421 pub unsafe fn get_method_2(
1422 this: impl ::core::convert::Into<::unity::IlInstance>,
1423 resources_type: ::unity::SystemType,
1424 v: ::unity::Il2CppString,
1425 r#type: ::unity::Array<::unity::SystemType>,
1426 ) -> crate::system::reflection::methodinfo::MethodInfo {
1427 let __mi = Self::get_method_2_method_info();
1428 let __inner: extern "C" fn(
1429 ::unity::IlInstance,
1430 ::unity::SystemType,
1431 ::unity::Il2CppString,
1432 ::unity::Array<::unity::SystemType>,
1433 ::unity::OptionalMethod,
1434 ) -> crate::system::reflection::methodinfo::MethodInfo = ::core::mem::transmute(__mi.method_ptr);
1435 __inner(this.into(), resources_type, v, r#type, ::core::option::Option::None)
1436 }
1437}
1438
1439#[cfg(feature = "moon_sharp-interpreter-compatibility-frameworks-frameworkbase")]
1440impl FrameworkBase {
1441 #[doc = "`.ctor()` — no args"]
1442 pub fn new() -> Self {
1443 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1444 panic!(
1445 "{}
1446::{}
1447 failed to instantiate",
1448 ::core::stringify!(FrameworkBase),
1449 ::core::stringify!(new),
1450 )
1451 });
1452 <Self as IFrameworkBaseMethods>::ctor(this);
1453 this
1454 }
1455}
1456
1457#[cfg(feature = "moon_sharp-interpreter-compatibility-frameworks-frameworkbase")]
1458#[doc(hidden)]
1459pub mod prelude {
1460 pub use super::{FrameworkBase, IFrameworkBase, IFrameworkBaseMethods};
1461 pub use crate::system::object::IObject;
1462 #[cfg(feature = "system-object")]
1463 pub use crate::system::object::IObjectMethods;
1464}