1#[cfg(feature = "system-reflection-methodbase-types")]
4mod __types {
5 #[allow(unused_imports)] use ::unity::prelude::*;
6
7 use super::*;
8 use crate::system::{
9 object::{IObject, Object},
10 reflection::memberinfo::{IMemberInfo, MemberInfo},
11 };
12
13 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/system/reflection/methodbase/MethodBase.md"))]
14 #[::unity::class(namespace = "System.Reflection", name = "MethodBase")]
15 #[parent(crate::system::reflection::memberinfo::MemberInfo)]
16 pub struct MethodBase {}
17}
18
19#[cfg(feature = "system-reflection-methodbase-types")]
20pub use __types::*;
21
22#[cfg(feature = "system-reflection-methodbase")]
23impl MethodBase {
24 #[doc = "`op_Equality(crate::system::reflection::methodbase::MethodBase, crate::system::reflection::methodbase::MethodBase)` overload"]
25 pub fn op_equality(
26 left: impl ::core::convert::Into<crate::system::reflection::methodbase::MethodBase>,
27 right: impl ::core::convert::Into<crate::system::reflection::methodbase::MethodBase>,
28 ) -> bool {
29 unsafe {
30 ::unity::il2cpp_call!((::unity::module_base()+0x336fb70usize)as*mut u8,bool;
31(crate::system::reflection::methodbase::MethodBase)::core::convert::Into::into(left),(crate::system::reflection::methodbase::MethodBase)::core::convert::Into::into(right))
32 }
33 }
34
35 #[doc = "`op_Inequality(crate::system::reflection::methodbase::MethodBase, crate::system::reflection::methodbase::MethodBase)` overload"]
36 pub fn op_inequality(
37 left: impl ::core::convert::Into<crate::system::reflection::methodbase::MethodBase>,
38 right: impl ::core::convert::Into<crate::system::reflection::methodbase::MethodBase>,
39 ) -> bool {
40 unsafe {
41 ::unity::il2cpp_call!((::unity::module_base()+0x336fb50usize)as*mut u8,bool;
42(crate::system::reflection::methodbase::MethodBase)::core::convert::Into::into(left),(crate::system::reflection::methodbase::MethodBase)::core::convert::Into::into(right))
43 }
44 }
45
46 #[doc = "`ConstructParameters(::unity::Array<::unity::SystemType>, crate::system::reflection::callingconventions::CallingConventions, bool)` overload"]
47 pub fn construct_parameters(
48 parameter_types: impl ::core::convert::Into<::unity::Array<::unity::SystemType>>,
49 calling_convention: impl ::core::convert::Into<crate::system::reflection::callingconventions::CallingConventions>,
50 serialization: impl ::core::convert::Into<bool>,
51 ) -> ::unity::Il2CppString {
52 unsafe {
53 ::unity::il2cpp_call!((::unity::module_base()+0x3375200usize)as*mut u8, ::unity::Il2CppString;
54(::unity::Array< ::unity::SystemType>)::core::convert::Into::into(parameter_types),(crate::system::reflection::callingconventions::CallingConventions)::core::convert::Into::into(calling_convention),(bool)::core::convert::Into::into(serialization))
55 }
56 }
57
58 #[doc = "`GetMethodFromHandleInternalType(::unity::IntPtr, ::unity::IntPtr)` overload"]
59 pub fn get_method_from_handle_internal_type(
60 method_handle: impl ::core::convert::Into<::unity::IntPtr>,
61 type_handle: impl ::core::convert::Into<::unity::IntPtr>,
62 ) -> crate::system::reflection::methodbase::MethodBase {
63 unsafe {
64 ::unity::il2cpp_call!((::unity::module_base()+0x3374d40usize)as*mut u8,crate::system::reflection::methodbase::MethodBase;
65(::unity::IntPtr)::core::convert::Into::into(method_handle),(::unity::IntPtr)::core::convert::Into::into(type_handle))
66 }
67 }
68
69 #[doc = "`GetMethodFromHandleInternalType_native(::unity::IntPtr, ::unity::IntPtr, bool)` overload"]
70 pub fn get_method_from_handle_internal_type_native(
71 method_handle: impl ::core::convert::Into<::unity::IntPtr>,
72 type_handle: impl ::core::convert::Into<::unity::IntPtr>,
73 generic_check: impl ::core::convert::Into<bool>,
74 ) -> crate::system::reflection::methodbase::MethodBase {
75 unsafe {
76 ::unity::il2cpp_call!((::unity::module_base()+0x3375760usize)as*mut u8,crate::system::reflection::methodbase::MethodBase;
77(::unity::IntPtr)::core::convert::Into::into(method_handle),(::unity::IntPtr)::core::convert::Into::into(type_handle),(bool)::core::convert::Into::into(generic_check))
78 }
79 }
80}
81
82#[cfg(feature = "system-reflection-methodbase")]
83pub trait IMethodBaseMethods: IMethodBase {
84 #[doc = "`.ctor()` overload"]
85 fn ctor(self) -> () {
86 unsafe {
87 let __receiver = <MethodBase as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
88 ::unity::il2cpp_call!((::unity::module_base()+0x3374d50usize)as*mut u8,();
89(MethodBase)__receiver)
90 }
91 }
92 #[doc = "`Equals(crate::system::object::Object)` overload"]
93 fn equals(self, obj: impl ::core::convert::Into<crate::system::object::Object>) -> bool {
94 unsafe {
95 let __receiver = <MethodBase as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
96 {
97 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
98 let __vi = *__vt.get(0usize).unwrap_or_else(|| {
99 panic!(
100 "unity: virtual slot {}
101 out of range (vtable len {}
102) on the runtime class behind {}
103 (method `{}
104`)",
105 0usize,
106 __vt.len(),
107 <MethodBase as ::unity::ClassIdentity>::NAME,
108 "Equals",
109 )
110 });
111 let __inner: extern "C" fn(MethodBase, crate::system::object::Object, ::unity::OptionalMethod) -> bool =
112 ::core::mem::transmute(__vi.method_ptr);
113 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
114 __inner(__receiver, ::core::convert::Into::into(obj), __mi)
115 }
116 }
117 }
118 #[doc = "`GetHashCode()` overload"]
119 fn get_hash_code(self) -> i32 {
120 unsafe {
121 let __receiver = <MethodBase as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
122 {
123 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
124 let __vi = *__vt.get(2usize).unwrap_or_else(|| {
125 panic!(
126 "unity: virtual slot {}
127 out of range (vtable len {}
128) on the runtime class behind {}
129 (method `{}
130`)",
131 2usize,
132 __vt.len(),
133 <MethodBase as ::unity::ClassIdentity>::NAME,
134 "GetHashCode",
135 )
136 });
137 let __inner: extern "C" fn(MethodBase, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__vi.method_ptr);
138 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
139 __inner(__receiver, __mi)
140 }
141 }
142 }
143 #[doc = "`GetParametersNoCopy()` overload"]
144 fn get_parameters_no_copy(self) -> ::unity::Array<crate::system::reflection::parameterinfo::ParameterInfo> {
145 unsafe {
146 let __receiver = <MethodBase as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
147 {
148 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
149 let __vi = *__vt.get(16usize).unwrap_or_else(|| {
150 panic!(
151 "unity: virtual slot {}
152 out of range (vtable len {}
153) on the runtime class behind {}
154 (method `{}
155`)",
156 16usize,
157 __vt.len(),
158 <MethodBase as ::unity::ClassIdentity>::NAME,
159 "GetParametersNoCopy",
160 )
161 });
162 let __inner: extern "C" fn(
163 MethodBase,
164 ::unity::OptionalMethod,
165 ) -> ::unity::Array<crate::system::reflection::parameterinfo::ParameterInfo> = ::core::mem::transmute(__vi.method_ptr);
166 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
167 __inner(__receiver, __mi)
168 }
169 }
170 }
171 #[doc = "`GetParameters()` overload"]
172 fn get_parameters(self) -> ::unity::Array<crate::system::reflection::parameterinfo::ParameterInfo> {
173 unsafe {
174 let __receiver = <MethodBase as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
175 {
176 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
177 let __vi = *__vt.get(17usize).unwrap_or_else(|| {
178 panic!(
179 "unity: virtual slot {}
180 out of range (vtable len {}
181) on the runtime class behind {}
182 (method `{}
183`)",
184 17usize,
185 __vt.len(),
186 <MethodBase as ::unity::ClassIdentity>::NAME,
187 "GetParameters",
188 )
189 });
190 let __inner: extern "C" fn(
191 MethodBase,
192 ::unity::OptionalMethod,
193 ) -> ::unity::Array<crate::system::reflection::parameterinfo::ParameterInfo> = ::core::mem::transmute(__vi.method_ptr);
194 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
195 __inner(__receiver, __mi)
196 }
197 }
198 }
199 #[doc = "`GetMethodImplementationFlags()` overload"]
200 fn get_method_implementation_flags(self) -> crate::system::reflection::methodimplattributes::MethodImplAttributes {
201 unsafe {
202 let __receiver = <MethodBase as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
203 {
204 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
205 let __vi = *__vt.get(18usize).unwrap_or_else(|| {
206 panic!(
207 "unity: virtual slot {}
208 out of range (vtable len {}
209) on the runtime class behind {}
210 (method `{}
211`)",
212 18usize,
213 __vt.len(),
214 <MethodBase as ::unity::ClassIdentity>::NAME,
215 "GetMethodImplementationFlags",
216 )
217 });
218 let __inner: extern "C" fn(
219 MethodBase,
220 ::unity::OptionalMethod,
221 ) -> crate::system::reflection::methodimplattributes::MethodImplAttributes = ::core::mem::transmute(__vi.method_ptr);
222 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
223 __inner(__receiver, __mi)
224 }
225 }
226 }
227 #[doc = "`get_Attributes()` overload"]
228 fn get_attributes(self) -> crate::system::reflection::methodattributes::MethodAttributes {
229 unsafe {
230 let __receiver = <MethodBase as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
231 {
232 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
233 let __vi = *__vt.get(20usize).unwrap_or_else(|| {
234 panic!(
235 "unity: virtual slot {}
236 out of range (vtable len {}
237) on the runtime class behind {}
238 (method `{}
239`)",
240 20usize,
241 __vt.len(),
242 <MethodBase as ::unity::ClassIdentity>::NAME,
243 "get_Attributes",
244 )
245 });
246 let __inner: extern "C" fn(MethodBase, ::unity::OptionalMethod) -> crate::system::reflection::methodattributes::MethodAttributes =
247 ::core::mem::transmute(__vi.method_ptr);
248 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
249 __inner(__receiver, __mi)
250 }
251 }
252 }
253 #[doc = "`get_CallingConvention()` overload"]
254 fn get_calling_convention(self) -> crate::system::reflection::callingconventions::CallingConventions {
255 unsafe {
256 let __receiver = <MethodBase as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
257 {
258 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
259 let __vi = *__vt.get(22usize).unwrap_or_else(|| {
260 panic!(
261 "unity: virtual slot {}
262 out of range (vtable len {}
263) on the runtime class behind {}
264 (method `{}
265`)",
266 22usize,
267 __vt.len(),
268 <MethodBase as ::unity::ClassIdentity>::NAME,
269 "get_CallingConvention",
270 )
271 });
272 let __inner: extern "C" fn(MethodBase, ::unity::OptionalMethod) -> crate::system::reflection::callingconventions::CallingConventions =
273 ::core::mem::transmute(__vi.method_ptr);
274 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
275 __inner(__receiver, __mi)
276 }
277 }
278 }
279 #[doc = "`GetGenericArguments()` overload"]
280 fn get_generic_arguments(self) -> ::unity::Array<::unity::SystemType> {
281 unsafe {
282 let __receiver = <MethodBase as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
283 {
284 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
285 let __vi = *__vt.get(23usize).unwrap_or_else(|| {
286 panic!(
287 "unity: virtual slot {}
288 out of range (vtable len {}
289) on the runtime class behind {}
290 (method `{}
291`)",
292 23usize,
293 __vt.len(),
294 <MethodBase as ::unity::ClassIdentity>::NAME,
295 "GetGenericArguments",
296 )
297 });
298 let __inner: extern "C" fn(MethodBase, ::unity::OptionalMethod) -> ::unity::Array<::unity::SystemType> =
299 ::core::mem::transmute(__vi.method_ptr);
300 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
301 __inner(__receiver, __mi)
302 }
303 }
304 }
305 #[doc = "`get_IsGenericMethodDefinition()` overload"]
306 fn get_is_generic_method_definition(self) -> bool {
307 unsafe {
308 let __receiver = <MethodBase as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
309 {
310 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
311 let __vi = *__vt.get(24usize).unwrap_or_else(|| {
312 panic!(
313 "unity: virtual slot {}
314 out of range (vtable len {}
315) on the runtime class behind {}
316 (method `{}
317`)",
318 24usize,
319 __vt.len(),
320 <MethodBase as ::unity::ClassIdentity>::NAME,
321 "get_IsGenericMethodDefinition",
322 )
323 });
324 let __inner: extern "C" fn(MethodBase, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
325 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
326 __inner(__receiver, __mi)
327 }
328 }
329 }
330 #[doc = "`get_ContainsGenericParameters()` overload"]
331 fn get_contains_generic_parameters(self) -> bool {
332 unsafe {
333 let __receiver = <MethodBase as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
334 {
335 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
336 let __vi = *__vt.get(25usize).unwrap_or_else(|| {
337 panic!(
338 "unity: virtual slot {}
339 out of range (vtable len {}
340) on the runtime class behind {}
341 (method `{}
342`)",
343 25usize,
344 __vt.len(),
345 <MethodBase as ::unity::ClassIdentity>::NAME,
346 "get_ContainsGenericParameters",
347 )
348 });
349 let __inner: extern "C" fn(MethodBase, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
350 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
351 __inner(__receiver, __mi)
352 }
353 }
354 }
355 #[doc = "`get_IsGenericMethod()` overload"]
356 fn get_is_generic_method(self) -> bool {
357 unsafe {
358 let __receiver = <MethodBase as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
359 {
360 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
361 let __vi = *__vt.get(26usize).unwrap_or_else(|| {
362 panic!(
363 "unity: virtual slot {}
364 out of range (vtable len {}
365) on the runtime class behind {}
366 (method `{}
367`)",
368 26usize,
369 __vt.len(),
370 <MethodBase as ::unity::ClassIdentity>::NAME,
371 "get_IsGenericMethod",
372 )
373 });
374 let __inner: extern "C" fn(MethodBase, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
375 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
376 __inner(__receiver, __mi)
377 }
378 }
379 }
380 #[doc = "`get_IsSecurityCritical()` overload"]
381 fn get_is_security_critical(self) -> bool {
382 unsafe {
383 let __receiver = <MethodBase as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
384 {
385 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
386 let __vi = *__vt.get(27usize).unwrap_or_else(|| {
387 panic!(
388 "unity: virtual slot {}
389 out of range (vtable len {}
390) on the runtime class behind {}
391 (method `{}
392`)",
393 27usize,
394 __vt.len(),
395 <MethodBase as ::unity::ClassIdentity>::NAME,
396 "get_IsSecurityCritical",
397 )
398 });
399 let __inner: extern "C" fn(MethodBase, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
400 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
401 __inner(__receiver, __mi)
402 }
403 }
404 }
405 #[doc = "`Invoke(crate::system::object::Object, ::unity::Array<crate::system::object::Object>)` overload"]
406 fn invoke(
407 self,
408 obj: impl ::core::convert::Into<crate::system::object::Object>,
409 parameters: impl ::core::convert::Into<::unity::Array<crate::system::object::Object>>,
410 ) -> crate::system::object::Object {
411 unsafe {
412 let __receiver = <MethodBase as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
413 {
414 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
415 let __vi = *__vt.get(28usize).unwrap_or_else(|| {
416 panic!(
417 "unity: virtual slot {}
418 out of range (vtable len {}
419) on the runtime class behind {}
420 (method `{}
421`)",
422 28usize,
423 __vt.len(),
424 <MethodBase as ::unity::ClassIdentity>::NAME,
425 "Invoke",
426 )
427 });
428 let __inner: extern "C" fn(
429 MethodBase,
430 crate::system::object::Object,
431 ::unity::Array<crate::system::object::Object>,
432 ::unity::OptionalMethod,
433 ) -> crate::system::object::Object = ::core::mem::transmute(__vi.method_ptr);
434 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
435 __inner(
436 __receiver,
437 ::core::convert::Into::into(obj),
438 ::core::convert::Into::into(parameters),
439 __mi,
440 )
441 }
442 }
443 }
444 #[doc = "`get_IsPublic()` overload"]
445 fn get_is_public(self) -> bool {
446 unsafe {
447 let __receiver = <MethodBase as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
448 {
449 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
450 let __vi = *__vt.get(29usize).unwrap_or_else(|| {
451 panic!(
452 "unity: virtual slot {}
453 out of range (vtable len {}
454) on the runtime class behind {}
455 (method `{}
456`)",
457 29usize,
458 __vt.len(),
459 <MethodBase as ::unity::ClassIdentity>::NAME,
460 "get_IsPublic",
461 )
462 });
463 let __inner: extern "C" fn(MethodBase, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
464 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
465 __inner(__receiver, __mi)
466 }
467 }
468 }
469 #[doc = "`get_IsPrivate()` overload"]
470 fn get_is_private(self) -> bool {
471 unsafe {
472 let __receiver = <MethodBase as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
473 {
474 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
475 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
476 panic!(
477 "unity: virtual slot {}
478 out of range (vtable len {}
479) on the runtime class behind {}
480 (method `{}
481`)",
482 30usize,
483 __vt.len(),
484 <MethodBase as ::unity::ClassIdentity>::NAME,
485 "get_IsPrivate",
486 )
487 });
488 let __inner: extern "C" fn(MethodBase, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
489 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
490 __inner(__receiver, __mi)
491 }
492 }
493 }
494 #[doc = "`get_IsFamily()` overload"]
495 fn get_is_family(self) -> bool {
496 unsafe {
497 let __receiver = <MethodBase as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
498 {
499 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
500 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
501 panic!(
502 "unity: virtual slot {}
503 out of range (vtable len {}
504) on the runtime class behind {}
505 (method `{}
506`)",
507 31usize,
508 __vt.len(),
509 <MethodBase as ::unity::ClassIdentity>::NAME,
510 "get_IsFamily",
511 )
512 });
513 let __inner: extern "C" fn(MethodBase, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
514 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
515 __inner(__receiver, __mi)
516 }
517 }
518 }
519 #[doc = "`get_IsAssembly()` overload"]
520 fn get_is_assembly(self) -> bool {
521 unsafe {
522 let __receiver = <MethodBase as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
523 {
524 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
525 let __vi = *__vt.get(32usize).unwrap_or_else(|| {
526 panic!(
527 "unity: virtual slot {}
528 out of range (vtable len {}
529) on the runtime class behind {}
530 (method `{}
531`)",
532 32usize,
533 __vt.len(),
534 <MethodBase as ::unity::ClassIdentity>::NAME,
535 "get_IsAssembly",
536 )
537 });
538 let __inner: extern "C" fn(MethodBase, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
539 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
540 __inner(__receiver, __mi)
541 }
542 }
543 }
544 #[doc = "`get_IsFamilyAndAssembly()` overload"]
545 fn get_is_family_and_assembly(self) -> bool {
546 unsafe {
547 let __receiver = <MethodBase as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
548 {
549 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
550 let __vi = *__vt.get(33usize).unwrap_or_else(|| {
551 panic!(
552 "unity: virtual slot {}
553 out of range (vtable len {}
554) on the runtime class behind {}
555 (method `{}
556`)",
557 33usize,
558 __vt.len(),
559 <MethodBase as ::unity::ClassIdentity>::NAME,
560 "get_IsFamilyAndAssembly",
561 )
562 });
563 let __inner: extern "C" fn(MethodBase, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
564 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
565 __inner(__receiver, __mi)
566 }
567 }
568 }
569 #[doc = "`get_IsFamilyOrAssembly()` overload"]
570 fn get_is_family_or_assembly(self) -> bool {
571 unsafe {
572 let __receiver = <MethodBase as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
573 {
574 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
575 let __vi = *__vt.get(34usize).unwrap_or_else(|| {
576 panic!(
577 "unity: virtual slot {}
578 out of range (vtable len {}
579) on the runtime class behind {}
580 (method `{}
581`)",
582 34usize,
583 __vt.len(),
584 <MethodBase as ::unity::ClassIdentity>::NAME,
585 "get_IsFamilyOrAssembly",
586 )
587 });
588 let __inner: extern "C" fn(MethodBase, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
589 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
590 __inner(__receiver, __mi)
591 }
592 }
593 }
594 #[doc = "`get_IsStatic()` overload"]
595 fn get_is_static(self) -> bool {
596 unsafe {
597 let __receiver = <MethodBase as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
598 {
599 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
600 let __vi = *__vt.get(35usize).unwrap_or_else(|| {
601 panic!(
602 "unity: virtual slot {}
603 out of range (vtable len {}
604) on the runtime class behind {}
605 (method `{}
606`)",
607 35usize,
608 __vt.len(),
609 <MethodBase as ::unity::ClassIdentity>::NAME,
610 "get_IsStatic",
611 )
612 });
613 let __inner: extern "C" fn(MethodBase, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
614 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
615 __inner(__receiver, __mi)
616 }
617 }
618 }
619 #[doc = "`get_IsVirtual()` overload"]
620 fn get_is_virtual(self) -> bool {
621 unsafe {
622 let __receiver = <MethodBase as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
623 {
624 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
625 let __vi = *__vt.get(36usize).unwrap_or_else(|| {
626 panic!(
627 "unity: virtual slot {}
628 out of range (vtable len {}
629) on the runtime class behind {}
630 (method `{}
631`)",
632 36usize,
633 __vt.len(),
634 <MethodBase as ::unity::ClassIdentity>::NAME,
635 "get_IsVirtual",
636 )
637 });
638 let __inner: extern "C" fn(MethodBase, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
639 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
640 __inner(__receiver, __mi)
641 }
642 }
643 }
644 #[doc = "`get_IsAbstract()` overload"]
645 fn get_is_abstract(self) -> bool {
646 unsafe {
647 let __receiver = <MethodBase as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
648 {
649 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
650 let __vi = *__vt.get(37usize).unwrap_or_else(|| {
651 panic!(
652 "unity: virtual slot {}
653 out of range (vtable len {}
654) on the runtime class behind {}
655 (method `{}
656`)",
657 37usize,
658 __vt.len(),
659 <MethodBase as ::unity::ClassIdentity>::NAME,
660 "get_IsAbstract",
661 )
662 });
663 let __inner: extern "C" fn(MethodBase, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
664 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
665 __inner(__receiver, __mi)
666 }
667 }
668 }
669 #[doc = "`get_IsSpecialName()` overload"]
670 fn get_is_special_name(self) -> bool {
671 unsafe {
672 let __receiver = <MethodBase as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
673 {
674 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
675 let __vi = *__vt.get(38usize).unwrap_or_else(|| {
676 panic!(
677 "unity: virtual slot {}
678 out of range (vtable len {}
679) on the runtime class behind {}
680 (method `{}
681`)",
682 38usize,
683 __vt.len(),
684 <MethodBase as ::unity::ClassIdentity>::NAME,
685 "get_IsSpecialName",
686 )
687 });
688 let __inner: extern "C" fn(MethodBase, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
689 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
690 __inner(__receiver, __mi)
691 }
692 }
693 }
694 #[doc = "`get_IsConstructor()` overload"]
695 fn get_is_constructor(self) -> bool {
696 unsafe {
697 let __receiver = <MethodBase as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
698 {
699 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
700 let __vi = *__vt.get(39usize).unwrap_or_else(|| {
701 panic!(
702 "unity: virtual slot {}
703 out of range (vtable len {}
704) on the runtime class behind {}
705 (method `{}
706`)",
707 39usize,
708 __vt.len(),
709 <MethodBase as ::unity::ClassIdentity>::NAME,
710 "get_IsConstructor",
711 )
712 });
713 let __inner: extern "C" fn(MethodBase, ::unity::OptionalMethod) -> bool = ::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, __mi)
716 }
717 }
718 }
719 #[doc = "`FormatNameAndSig(bool)` overload"]
720 fn format_name_and_sig(self, serialization: impl ::core::convert::Into<bool>) -> ::unity::Il2CppString {
721 unsafe {
722 let __receiver = <MethodBase as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
723 {
724 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
725 let __vi = *__vt.get(40usize).unwrap_or_else(|| {
726 panic!(
727 "unity: virtual slot {}
728 out of range (vtable len {}
729) on the runtime class behind {}
730 (method `{}
731`)",
732 40usize,
733 __vt.len(),
734 <MethodBase as ::unity::ClassIdentity>::NAME,
735 "FormatNameAndSig",
736 )
737 });
738 let __inner: extern "C" fn(MethodBase, bool, ::unity::OptionalMethod) -> ::unity::Il2CppString =
739 ::core::mem::transmute(__vi.method_ptr);
740 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
741 __inner(__receiver, ::core::convert::Into::into(serialization), __mi)
742 }
743 }
744 }
745 #[doc = "`GetParameterTypes()` overload"]
746 fn get_parameter_types(self) -> ::unity::Array<::unity::SystemType> {
747 unsafe {
748 let __receiver = <MethodBase as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
749 {
750 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
751 let __vi = *__vt.get(41usize).unwrap_or_else(|| {
752 panic!(
753 "unity: virtual slot {}
754 out of range (vtable len {}
755) on the runtime class behind {}
756 (method `{}
757`)",
758 41usize,
759 __vt.len(),
760 <MethodBase as ::unity::ClassIdentity>::NAME,
761 "GetParameterTypes",
762 )
763 });
764 let __inner: extern "C" fn(MethodBase, ::unity::OptionalMethod) -> ::unity::Array<::unity::SystemType> =
765 ::core::mem::transmute(__vi.method_ptr);
766 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
767 __inner(__receiver, __mi)
768 }
769 }
770 }
771 #[doc = "`GetParametersInternal()` overload"]
772 fn get_parameters_internal(self) -> ::unity::Array<crate::system::reflection::parameterinfo::ParameterInfo> {
773 unsafe {
774 let __receiver = <MethodBase as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
775 {
776 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
777 let __vi = *__vt.get(42usize).unwrap_or_else(|| {
778 panic!(
779 "unity: virtual slot {}
780 out of range (vtable len {}
781) on the runtime class behind {}
782 (method `{}
783`)",
784 42usize,
785 __vt.len(),
786 <MethodBase as ::unity::ClassIdentity>::NAME,
787 "GetParametersInternal",
788 )
789 });
790 let __inner: extern "C" fn(
791 MethodBase,
792 ::unity::OptionalMethod,
793 ) -> ::unity::Array<crate::system::reflection::parameterinfo::ParameterInfo> = ::core::mem::transmute(__vi.method_ptr);
794 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
795 __inner(__receiver, __mi)
796 }
797 }
798 }
799 #[doc = "`GetParametersCount()` overload"]
800 fn get_parameters_count(self) -> i32 {
801 unsafe {
802 let __receiver = <MethodBase as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
803 {
804 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
805 let __vi = *__vt.get(43usize).unwrap_or_else(|| {
806 panic!(
807 "unity: virtual slot {}
808 out of range (vtable len {}
809) on the runtime class behind {}
810 (method `{}
811`)",
812 43usize,
813 __vt.len(),
814 <MethodBase as ::unity::ClassIdentity>::NAME,
815 "GetParametersCount",
816 )
817 });
818 let __inner: extern "C" fn(MethodBase, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__vi.method_ptr);
819 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
820 __inner(__receiver, __mi)
821 }
822 }
823 }
824}
825
826#[cfg(feature = "system-reflection-methodbase")]
827impl<__T: IMethodBase> IMethodBaseMethods for __T {}
828
829#[cfg(feature = "system-reflection-methodbase")]
830impl MethodBase {
831 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
832 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
833 }
834
835 pub fn op_equality_method_info() -> &'static ::unity::il2cpp::MethodInfo {
836 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
837 }
838
839 pub fn op_inequality_method_info() -> &'static ::unity::il2cpp::MethodInfo {
840 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
841 }
842
843 pub fn equals_method_info() -> &'static ::unity::il2cpp::MethodInfo {
844 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
845 }
846
847 pub fn get_hash_code_method_info() -> &'static ::unity::il2cpp::MethodInfo {
848 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
849 }
850
851 pub fn get_parameters_no_copy_method_info() -> &'static ::unity::il2cpp::MethodInfo {
852 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
853 }
854
855 pub fn get_parameters_method_info() -> &'static ::unity::il2cpp::MethodInfo {
856 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
857 }
858
859 pub fn get_method_implementation_flags_method_info() -> &'static ::unity::il2cpp::MethodInfo {
860 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[8]
861 }
862
863 pub fn get_attributes_method_info() -> &'static ::unity::il2cpp::MethodInfo {
864 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[10]
865 }
866
867 pub fn get_calling_convention_method_info() -> &'static ::unity::il2cpp::MethodInfo {
868 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[12]
869 }
870
871 pub fn get_generic_arguments_method_info() -> &'static ::unity::il2cpp::MethodInfo {
872 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[13]
873 }
874
875 pub fn get_is_generic_method_definition_method_info() -> &'static ::unity::il2cpp::MethodInfo {
876 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[14]
877 }
878
879 pub fn get_contains_generic_parameters_method_info() -> &'static ::unity::il2cpp::MethodInfo {
880 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[15]
881 }
882
883 pub fn get_is_generic_method_method_info() -> &'static ::unity::il2cpp::MethodInfo {
884 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[16]
885 }
886
887 pub fn get_is_security_critical_method_info() -> &'static ::unity::il2cpp::MethodInfo {
888 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[17]
889 }
890
891 pub fn invoke_method_info() -> &'static ::unity::il2cpp::MethodInfo {
892 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[18]
893 }
894
895 pub fn get_is_public_method_info() -> &'static ::unity::il2cpp::MethodInfo {
896 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[19]
897 }
898
899 pub fn get_is_private_method_info() -> &'static ::unity::il2cpp::MethodInfo {
900 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[20]
901 }
902
903 pub fn get_is_family_method_info() -> &'static ::unity::il2cpp::MethodInfo {
904 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[21]
905 }
906
907 pub fn get_is_assembly_method_info() -> &'static ::unity::il2cpp::MethodInfo {
908 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[22]
909 }
910
911 pub fn get_is_family_and_assembly_method_info() -> &'static ::unity::il2cpp::MethodInfo {
912 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[23]
913 }
914
915 pub fn get_is_family_or_assembly_method_info() -> &'static ::unity::il2cpp::MethodInfo {
916 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[24]
917 }
918
919 pub fn get_is_static_method_info() -> &'static ::unity::il2cpp::MethodInfo {
920 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[25]
921 }
922
923 pub fn get_is_virtual_method_info() -> &'static ::unity::il2cpp::MethodInfo {
924 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[26]
925 }
926
927 pub fn get_is_abstract_method_info() -> &'static ::unity::il2cpp::MethodInfo {
928 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[27]
929 }
930
931 pub fn get_is_special_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
932 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[28]
933 }
934
935 pub fn get_is_constructor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
936 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[29]
937 }
938
939 pub fn construct_parameters_method_info() -> &'static ::unity::il2cpp::MethodInfo {
940 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[30]
941 }
942
943 pub fn format_name_and_sig_method_info() -> &'static ::unity::il2cpp::MethodInfo {
944 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[31]
945 }
946
947 pub fn get_parameter_types_method_info() -> &'static ::unity::il2cpp::MethodInfo {
948 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[32]
949 }
950
951 pub fn get_parameters_internal_method_info() -> &'static ::unity::il2cpp::MethodInfo {
952 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[33]
953 }
954
955 pub fn get_parameters_count_method_info() -> &'static ::unity::il2cpp::MethodInfo {
956 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[34]
957 }
958
959 pub fn get_method_from_handle_internal_type_method_info() -> &'static ::unity::il2cpp::MethodInfo {
960 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[37]
961 }
962
963 pub fn get_method_from_handle_internal_type_native_method_info() -> &'static ::unity::il2cpp::MethodInfo {
964 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[38]
965 }
966}
967
968#[cfg(feature = "system-reflection-methodbase")]
969impl MethodBase {
970 #[doc = "Direct (non-virtual) call to `MethodBase`'s own `Equals`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
971 pub unsafe fn equals(this: impl ::core::convert::Into<::unity::IlInstance>, obj: crate::system::object::Object) -> bool {
972 let __mi = Self::equals_method_info();
973 let __inner: extern "C" fn(::unity::IlInstance, crate::system::object::Object, ::unity::OptionalMethod) -> bool =
974 ::core::mem::transmute(__mi.method_ptr);
975 __inner(this.into(), obj, ::core::option::Option::None)
976 }
977
978 #[doc = "Direct (non-virtual) call to `MethodBase`'s own `GetHashCode`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
979 pub unsafe fn get_hash_code(this: impl ::core::convert::Into<::unity::IlInstance>) -> i32 {
980 let __mi = Self::get_hash_code_method_info();
981 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__mi.method_ptr);
982 __inner(this.into(), ::core::option::Option::None)
983 }
984
985 #[doc = "Direct (non-virtual) call to `MethodBase`'s own `GetParametersNoCopy`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
986 pub unsafe fn get_parameters_no_copy(
987 this: impl ::core::convert::Into<::unity::IlInstance>,
988 ) -> ::unity::Array<crate::system::reflection::parameterinfo::ParameterInfo> {
989 let __mi = Self::get_parameters_no_copy_method_info();
990 let __inner: extern "C" fn(
991 ::unity::IlInstance,
992 ::unity::OptionalMethod,
993 ) -> ::unity::Array<crate::system::reflection::parameterinfo::ParameterInfo> = ::core::mem::transmute(__mi.method_ptr);
994 __inner(this.into(), ::core::option::Option::None)
995 }
996
997 #[doc = "Direct (non-virtual) call to `MethodBase`'s own `GetParameters`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
998 pub unsafe fn get_parameters(
999 this: impl ::core::convert::Into<::unity::IlInstance>,
1000 ) -> ::unity::Array<crate::system::reflection::parameterinfo::ParameterInfo> {
1001 let __mi = Self::get_parameters_method_info();
1002 let __inner: extern "C" fn(
1003 ::unity::IlInstance,
1004 ::unity::OptionalMethod,
1005 ) -> ::unity::Array<crate::system::reflection::parameterinfo::ParameterInfo> = ::core::mem::transmute(__mi.method_ptr);
1006 __inner(this.into(), ::core::option::Option::None)
1007 }
1008
1009 #[doc = "Direct (non-virtual) call to `MethodBase`'s own `GetMethodImplementationFlags`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1010 pub unsafe fn get_method_implementation_flags(
1011 this: impl ::core::convert::Into<::unity::IlInstance>,
1012 ) -> crate::system::reflection::methodimplattributes::MethodImplAttributes {
1013 let __mi = Self::get_method_implementation_flags_method_info();
1014 let __inner: extern "C" fn(
1015 ::unity::IlInstance,
1016 ::unity::OptionalMethod,
1017 ) -> crate::system::reflection::methodimplattributes::MethodImplAttributes = ::core::mem::transmute(__mi.method_ptr);
1018 __inner(this.into(), ::core::option::Option::None)
1019 }
1020
1021 #[doc = "Direct (non-virtual) call to `MethodBase`'s own `get_Attributes`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1022 pub unsafe fn get_attributes(
1023 this: impl ::core::convert::Into<::unity::IlInstance>,
1024 ) -> crate::system::reflection::methodattributes::MethodAttributes {
1025 let __mi = Self::get_attributes_method_info();
1026 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::system::reflection::methodattributes::MethodAttributes =
1027 ::core::mem::transmute(__mi.method_ptr);
1028 __inner(this.into(), ::core::option::Option::None)
1029 }
1030
1031 #[doc = "Direct (non-virtual) call to `MethodBase`'s own `get_CallingConvention`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1032 pub unsafe fn get_calling_convention(
1033 this: impl ::core::convert::Into<::unity::IlInstance>,
1034 ) -> crate::system::reflection::callingconventions::CallingConventions {
1035 let __mi = Self::get_calling_convention_method_info();
1036 let __inner: extern "C" fn(
1037 ::unity::IlInstance,
1038 ::unity::OptionalMethod,
1039 ) -> crate::system::reflection::callingconventions::CallingConventions = ::core::mem::transmute(__mi.method_ptr);
1040 __inner(this.into(), ::core::option::Option::None)
1041 }
1042
1043 #[doc = "Direct (non-virtual) call to `MethodBase`'s own `GetGenericArguments`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1044 pub unsafe fn get_generic_arguments(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Array<::unity::SystemType> {
1045 let __mi = Self::get_generic_arguments_method_info();
1046 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Array<::unity::SystemType> =
1047 ::core::mem::transmute(__mi.method_ptr);
1048 __inner(this.into(), ::core::option::Option::None)
1049 }
1050
1051 #[doc = "Direct (non-virtual) call to `MethodBase`'s own `get_IsGenericMethodDefinition`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1052 pub unsafe fn get_is_generic_method_definition(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
1053 let __mi = Self::get_is_generic_method_definition_method_info();
1054 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
1055 __inner(this.into(), ::core::option::Option::None)
1056 }
1057
1058 #[doc = "Direct (non-virtual) call to `MethodBase`'s own `get_ContainsGenericParameters`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1059 pub unsafe fn get_contains_generic_parameters(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
1060 let __mi = Self::get_contains_generic_parameters_method_info();
1061 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
1062 __inner(this.into(), ::core::option::Option::None)
1063 }
1064
1065 #[doc = "Direct (non-virtual) call to `MethodBase`'s own `get_IsGenericMethod`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1066 pub unsafe fn get_is_generic_method(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
1067 let __mi = Self::get_is_generic_method_method_info();
1068 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
1069 __inner(this.into(), ::core::option::Option::None)
1070 }
1071
1072 #[doc = "Direct (non-virtual) call to `MethodBase`'s own `get_IsSecurityCritical`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1073 pub unsafe fn get_is_security_critical(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
1074 let __mi = Self::get_is_security_critical_method_info();
1075 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
1076 __inner(this.into(), ::core::option::Option::None)
1077 }
1078
1079 #[doc = "Direct (non-virtual) call to `MethodBase`'s own `Invoke`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1080 pub unsafe fn invoke(
1081 this: impl ::core::convert::Into<::unity::IlInstance>,
1082 obj: crate::system::object::Object,
1083 parameters: ::unity::Array<crate::system::object::Object>,
1084 ) -> crate::system::object::Object {
1085 let __mi = Self::invoke_method_info();
1086 let __inner: extern "C" fn(
1087 ::unity::IlInstance,
1088 crate::system::object::Object,
1089 ::unity::Array<crate::system::object::Object>,
1090 ::unity::OptionalMethod,
1091 ) -> crate::system::object::Object = ::core::mem::transmute(__mi.method_ptr);
1092 __inner(this.into(), obj, parameters, ::core::option::Option::None)
1093 }
1094
1095 #[doc = "Direct (non-virtual) call to `MethodBase`'s own `get_IsPublic`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1096 pub unsafe fn get_is_public(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
1097 let __mi = Self::get_is_public_method_info();
1098 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
1099 __inner(this.into(), ::core::option::Option::None)
1100 }
1101
1102 #[doc = "Direct (non-virtual) call to `MethodBase`'s own `get_IsPrivate`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1103 pub unsafe fn get_is_private(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
1104 let __mi = Self::get_is_private_method_info();
1105 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
1106 __inner(this.into(), ::core::option::Option::None)
1107 }
1108
1109 #[doc = "Direct (non-virtual) call to `MethodBase`'s own `get_IsFamily`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1110 pub unsafe fn get_is_family(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
1111 let __mi = Self::get_is_family_method_info();
1112 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
1113 __inner(this.into(), ::core::option::Option::None)
1114 }
1115
1116 #[doc = "Direct (non-virtual) call to `MethodBase`'s own `get_IsAssembly`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1117 pub unsafe fn get_is_assembly(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
1118 let __mi = Self::get_is_assembly_method_info();
1119 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
1120 __inner(this.into(), ::core::option::Option::None)
1121 }
1122
1123 #[doc = "Direct (non-virtual) call to `MethodBase`'s own `get_IsFamilyAndAssembly`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1124 pub unsafe fn get_is_family_and_assembly(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
1125 let __mi = Self::get_is_family_and_assembly_method_info();
1126 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
1127 __inner(this.into(), ::core::option::Option::None)
1128 }
1129
1130 #[doc = "Direct (non-virtual) call to `MethodBase`'s own `get_IsFamilyOrAssembly`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1131 pub unsafe fn get_is_family_or_assembly(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
1132 let __mi = Self::get_is_family_or_assembly_method_info();
1133 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
1134 __inner(this.into(), ::core::option::Option::None)
1135 }
1136
1137 #[doc = "Direct (non-virtual) call to `MethodBase`'s own `get_IsStatic`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1138 pub unsafe fn get_is_static(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
1139 let __mi = Self::get_is_static_method_info();
1140 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
1141 __inner(this.into(), ::core::option::Option::None)
1142 }
1143
1144 #[doc = "Direct (non-virtual) call to `MethodBase`'s own `get_IsVirtual`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1145 pub unsafe fn get_is_virtual(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
1146 let __mi = Self::get_is_virtual_method_info();
1147 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
1148 __inner(this.into(), ::core::option::Option::None)
1149 }
1150
1151 #[doc = "Direct (non-virtual) call to `MethodBase`'s own `get_IsAbstract`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1152 pub unsafe fn get_is_abstract(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
1153 let __mi = Self::get_is_abstract_method_info();
1154 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
1155 __inner(this.into(), ::core::option::Option::None)
1156 }
1157
1158 #[doc = "Direct (non-virtual) call to `MethodBase`'s own `get_IsSpecialName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1159 pub unsafe fn get_is_special_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
1160 let __mi = Self::get_is_special_name_method_info();
1161 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
1162 __inner(this.into(), ::core::option::Option::None)
1163 }
1164
1165 #[doc = "Direct (non-virtual) call to `MethodBase`'s own `get_IsConstructor`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1166 pub unsafe fn get_is_constructor(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
1167 let __mi = Self::get_is_constructor_method_info();
1168 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
1169 __inner(this.into(), ::core::option::Option::None)
1170 }
1171
1172 #[doc = "Direct (non-virtual) call to `MethodBase`'s own `FormatNameAndSig`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1173 pub unsafe fn format_name_and_sig(this: impl ::core::convert::Into<::unity::IlInstance>, serialization: bool) -> ::unity::Il2CppString {
1174 let __mi = Self::format_name_and_sig_method_info();
1175 let __inner: extern "C" fn(::unity::IlInstance, bool, ::unity::OptionalMethod) -> ::unity::Il2CppString =
1176 ::core::mem::transmute(__mi.method_ptr);
1177 __inner(this.into(), serialization, ::core::option::Option::None)
1178 }
1179
1180 #[doc = "Direct (non-virtual) call to `MethodBase`'s own `GetParameterTypes`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1181 pub unsafe fn get_parameter_types(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Array<::unity::SystemType> {
1182 let __mi = Self::get_parameter_types_method_info();
1183 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Array<::unity::SystemType> =
1184 ::core::mem::transmute(__mi.method_ptr);
1185 __inner(this.into(), ::core::option::Option::None)
1186 }
1187
1188 #[doc = "Direct (non-virtual) call to `MethodBase`'s own `GetParametersInternal`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1189 pub unsafe fn get_parameters_internal(
1190 this: impl ::core::convert::Into<::unity::IlInstance>,
1191 ) -> ::unity::Array<crate::system::reflection::parameterinfo::ParameterInfo> {
1192 let __mi = Self::get_parameters_internal_method_info();
1193 let __inner: extern "C" fn(
1194 ::unity::IlInstance,
1195 ::unity::OptionalMethod,
1196 ) -> ::unity::Array<crate::system::reflection::parameterinfo::ParameterInfo> = ::core::mem::transmute(__mi.method_ptr);
1197 __inner(this.into(), ::core::option::Option::None)
1198 }
1199
1200 #[doc = "Direct (non-virtual) call to `MethodBase`'s own `GetParametersCount`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1201 pub unsafe fn get_parameters_count(this: impl ::core::convert::Into<::unity::IlInstance>) -> i32 {
1202 let __mi = Self::get_parameters_count_method_info();
1203 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__mi.method_ptr);
1204 __inner(this.into(), ::core::option::Option::None)
1205 }
1206}
1207
1208#[cfg(feature = "system-reflection-methodbase")]
1209impl MethodBase {
1210 #[doc = "`.ctor()` — no args"]
1211 pub fn new() -> Self {
1212 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1213 panic!(
1214 "{}
1215::{}
1216 failed to instantiate",
1217 ::core::stringify!(MethodBase),
1218 ::core::stringify!(new),
1219 )
1220 });
1221 <Self as IMethodBaseMethods>::ctor(this);
1222 this
1223 }
1224}
1225
1226#[cfg(feature = "system-reflection-methodbase")]
1227#[doc(hidden)]
1228pub mod prelude {
1229 pub use super::{IMethodBase, IMethodBaseMethods, MethodBase};
1230 #[cfg(feature = "system-object")]
1231 pub use crate::system::object::IObjectMethods;
1232 #[cfg(feature = "system-reflection-memberinfo")]
1233 pub use crate::system::reflection::memberinfo::IMemberInfoMethods;
1234 pub use crate::system::{object::IObject, reflection::memberinfo::IMemberInfo};
1235}