1#[cfg(feature = "system-runtimetype-types")]
4mod __types {
5 #[allow(unused_imports)] use ::unity::prelude::*;
6
7 use super::*;
8 use crate::system::{
9 object::{IObject, Object},
10 reflection::{
11 memberinfo::{IMemberInfo, MemberInfo},
12 typeinfo::{ITypeInfo, TypeInfo},
13 },
14 };
15
16 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/system/runtimetype/RuntimeType.md"))]
17 #[::unity::class(namespace = "System", name = "RuntimeType")]
18 #[parent(crate::system::reflection::typeinfo::TypeInfo)]
19 pub struct RuntimeType {
20 #[static_field]
21 #[rename(name = "ValueType")]
22 pub value_type: crate::system::runtimetype::RuntimeType,
23 #[static_field]
24 #[rename(name = "EnumType")]
25 pub enum_type: crate::system::runtimetype::RuntimeType,
26 #[static_field]
27 #[rename(name = "ObjectType")]
28 pub object_type: crate::system::runtimetype::RuntimeType,
29 #[static_field]
30 #[rename(name = "StringType")]
31 pub string_type: crate::system::runtimetype::RuntimeType,
32 #[static_field]
33 #[rename(name = "DelegateType")]
34 pub delegate_type: crate::system::runtimetype::RuntimeType,
35 #[static_field]
36 #[rename(name = "s_SICtorParamTypes")]
37 pub s_si_ctor_param_types: ::unity::Array<::unity::SystemType>,
38 #[static_field]
39 #[rename(name = "MemberBindingMask")]
40 pub member_binding_mask: crate::system::reflection::bindingflags::BindingFlags,
41 #[static_field]
42 #[rename(name = "InvocationMask")]
43 pub invocation_mask: crate::system::reflection::bindingflags::BindingFlags,
44 #[static_field]
45 #[rename(name = "BinderNonCreateInstance")]
46 pub binder_non_create_instance: crate::system::reflection::bindingflags::BindingFlags,
47 #[static_field]
48 #[rename(name = "BinderGetSetProperty")]
49 pub binder_get_set_property: crate::system::reflection::bindingflags::BindingFlags,
50 #[static_field]
51 #[rename(name = "BinderSetInvokeProperty")]
52 pub binder_set_invoke_property: crate::system::reflection::bindingflags::BindingFlags,
53 #[static_field]
54 #[rename(name = "BinderGetSetField")]
55 pub binder_get_set_field: crate::system::reflection::bindingflags::BindingFlags,
56 #[static_field]
57 #[rename(name = "BinderSetInvokeField")]
58 pub binder_set_invoke_field: crate::system::reflection::bindingflags::BindingFlags,
59 #[static_field]
60 #[rename(name = "BinderNonFieldGetSet")]
61 pub binder_non_field_get_set: crate::system::reflection::bindingflags::BindingFlags,
62 #[static_field]
63 #[rename(name = "ClassicBindingMask")]
64 pub classic_binding_mask: crate::system::reflection::bindingflags::BindingFlags,
65 #[static_field]
66 #[rename(name = "s_typedRef")]
67 pub s_typed_ref: crate::system::runtimetype::RuntimeType,
68 #[offset(32)]
69 #[rename(name = "GenericCache")]
70 pub generic_cache: ::unity::IlInstance,
71 #[offset(40)]
72 #[rename(name = "m_serializationCtor")]
73 pub m_serialization_ctor: crate::system::reflection::runtimeconstructorinfo::RuntimeConstructorInfo,
74 }
75}
76
77#[cfg(feature = "system-runtimetype-types")]
78pub use __types::*;
79
80#[cfg(feature = "system-runtimetype")]
81impl RuntimeType {
82 #[doc = "`ThrowIfTypeNeverValidGenericArgument(crate::system::runtimetype::RuntimeType)` overload"]
83 pub fn throw_if_type_never_valid_generic_argument(r#type: impl ::core::convert::Into<crate::system::runtimetype::RuntimeType>) -> () {
84 unsafe {
85 ::unity::il2cpp_call!((::unity::module_base()+0x2fd7bc0usize)as*mut u8,();
86(crate::system::runtimetype::RuntimeType)::core::convert::Into::into(r#type))
87 }
88 }
89
90 #[doc = "`SanityCheckGenericArguments(::unity::Array<crate::system::runtimetype::RuntimeType>, ::unity::Array<crate::system::runtimetype::RuntimeType>)` overload"]
91 pub fn sanity_check_generic_arguments(
92 generic_arguments: impl ::core::convert::Into<::unity::Array<crate::system::runtimetype::RuntimeType>>,
93 generic_paramters: impl ::core::convert::Into<::unity::Array<crate::system::runtimetype::RuntimeType>>,
94 ) -> () {
95 unsafe {
96 ::unity::il2cpp_call!((::unity::module_base()+0x2fd7d10usize)as*mut u8,();
97(::unity::Array<crate::system::runtimetype::RuntimeType>)::core::convert::Into::into(generic_arguments),(::unity::Array<crate::system::runtimetype::RuntimeType>)::core::convert::Into::into(generic_paramters))
98 }
99 }
100
101 #[doc = "`SplitName(::unity::Il2CppString, *mut::unity::Il2CppString, *mut::unity::Il2CppString)` overload"]
102 pub fn split_name(fullname: impl ::core::convert::Into<::unity::Il2CppString>) -> (::unity::Il2CppString, ::unity::Il2CppString) {
103 unsafe {
104 let mut __out_0 = ::core::mem::MaybeUninit::<::unity::Il2CppString>::uninit();
105 let mut __out_1 = ::core::mem::MaybeUninit::<::unity::Il2CppString>::uninit();
106 ::unity::il2cpp_call!((::unity::module_base()+0x2fd7f30usize)as*mut u8,();
107(::unity::Il2CppString)::core::convert::Into::into(fullname),(*mut::unity::Il2CppString)__out_0.as_mut_ptr(),(*mut::unity::Il2CppString)__out_1.as_mut_ptr());
108 (__out_0.assume_init(), __out_1.assume_init())
109 }
110 }
111
112 #[doc = "`FilterApplyPrefixLookup(crate::system::reflection::memberinfo::MemberInfo, ::unity::Il2CppString, bool)` overload"]
113 pub fn filter_apply_prefix_lookup(
114 member_info: impl ::core::convert::Into<crate::system::reflection::memberinfo::MemberInfo>,
115 name: impl ::core::convert::Into<::unity::Il2CppString>,
116 ignore_case: impl ::core::convert::Into<bool>,
117 ) -> bool {
118 unsafe {
119 ::unity::il2cpp_call!((::unity::module_base()+0x2fd8260usize)as*mut u8,bool;
120(crate::system::reflection::memberinfo::MemberInfo)::core::convert::Into::into(member_info),(::unity::Il2CppString)::core::convert::Into::into(name),(bool)::core::convert::Into::into(ignore_case))
121 }
122 }
123
124 #[doc = "`FilterApplyBase(crate::system::reflection::memberinfo::MemberInfo, crate::system::reflection::bindingflags::BindingFlags, bool, bool, bool, ::unity::Il2CppString, bool)` overload"]
125 pub fn filter_apply_base(
126 member_info: impl ::core::convert::Into<crate::system::reflection::memberinfo::MemberInfo>,
127 binding_flags: impl ::core::convert::Into<crate::system::reflection::bindingflags::BindingFlags>,
128 is_public: impl ::core::convert::Into<bool>,
129 is_non_protected_internal: impl ::core::convert::Into<bool>,
130 is_static: impl ::core::convert::Into<bool>,
131 name: impl ::core::convert::Into<::unity::Il2CppString>,
132 prefix_lookup: impl ::core::convert::Into<bool>,
133 ) -> bool {
134 unsafe {
135 ::unity::il2cpp_call!((::unity::module_base()+0x2fd82d0usize)as*mut u8,bool;
136(crate::system::reflection::memberinfo::MemberInfo)::core::convert::Into::into(member_info),(crate::system::reflection::bindingflags::BindingFlags)::core::convert::Into::into(binding_flags),(bool)::core::convert::Into::into(is_public),(bool)::core::convert::Into::into(is_non_protected_internal),(bool)::core::convert::Into::into(is_static),(::unity::Il2CppString)::core::convert::Into::into(name),(bool)::core::convert::Into::into(prefix_lookup))
137 }
138 }
139
140 #[doc = "`FilterApplyType(::unity::SystemType, crate::system::reflection::bindingflags::BindingFlags, ::unity::Il2CppString, bool, ::unity::Il2CppString)` overload"]
141 pub fn filter_apply_type(
142 r#type: impl ::core::convert::Into<::unity::SystemType>,
143 binding_flags: impl ::core::convert::Into<crate::system::reflection::bindingflags::BindingFlags>,
144 name: impl ::core::convert::Into<::unity::Il2CppString>,
145 prefix_lookup: impl ::core::convert::Into<bool>,
146 ns: impl ::core::convert::Into<::unity::Il2CppString>,
147 ) -> bool {
148 unsafe {
149 ::unity::il2cpp_call!((::unity::module_base()+0x2fd84e0usize)as*mut u8,bool;
150(::unity::SystemType)::core::convert::Into::into(r#type),(crate::system::reflection::bindingflags::BindingFlags)::core::convert::Into::into(binding_flags),(::unity::Il2CppString)::core::convert::Into::into(name),(bool)::core::convert::Into::into(prefix_lookup),(::unity::Il2CppString)::core::convert::Into::into(ns))
151 }
152 }
153
154 #[doc = "`FilterApplyMethodInfo(crate::system::reflection::runtimemethodinfo::RuntimeMethodInfo, crate::system::reflection::bindingflags::BindingFlags, crate::system::reflection::callingconventions::CallingConventions, ::unity::Array<::unity::SystemType>)` overload"]
155 pub fn filter_apply_method_info(
156 method: impl ::core::convert::Into<crate::system::reflection::runtimemethodinfo::RuntimeMethodInfo>,
157 binding_flags: impl ::core::convert::Into<crate::system::reflection::bindingflags::BindingFlags>,
158 call_conv: impl ::core::convert::Into<crate::system::reflection::callingconventions::CallingConventions>,
159 argument_types: impl ::core::convert::Into<::unity::Array<::unity::SystemType>>,
160 ) -> bool {
161 unsafe {
162 ::unity::il2cpp_call!((::unity::module_base()+0x2fd8600usize)as*mut u8,bool;
163(crate::system::reflection::runtimemethodinfo::RuntimeMethodInfo)::core::convert::Into::into(method),(crate::system::reflection::bindingflags::BindingFlags)::core::convert::Into::into(binding_flags),(crate::system::reflection::callingconventions::CallingConventions)::core::convert::Into::into(call_conv),(::unity::Array< ::unity::SystemType>)::core::convert::Into::into(argument_types))
164 }
165 }
166
167 #[doc = "`FilterApplyConstructorInfo(crate::system::reflection::runtimeconstructorinfo::RuntimeConstructorInfo, crate::system::reflection::bindingflags::BindingFlags, crate::system::reflection::callingconventions::CallingConventions, ::unity::Array<::unity::SystemType>)` overload"]
168 pub fn filter_apply_constructor_info(
169 constructor: impl ::core::convert::Into<crate::system::reflection::runtimeconstructorinfo::RuntimeConstructorInfo>,
170 binding_flags: impl ::core::convert::Into<crate::system::reflection::bindingflags::BindingFlags>,
171 call_conv: impl ::core::convert::Into<crate::system::reflection::callingconventions::CallingConventions>,
172 argument_types: impl ::core::convert::Into<::unity::Array<::unity::SystemType>>,
173 ) -> bool {
174 unsafe {
175 ::unity::il2cpp_call!((::unity::module_base()+0x2fd8900usize)as*mut u8,bool;
176(crate::system::reflection::runtimeconstructorinfo::RuntimeConstructorInfo)::core::convert::Into::into(constructor),(crate::system::reflection::bindingflags::BindingFlags)::core::convert::Into::into(binding_flags),(crate::system::reflection::callingconventions::CallingConventions)::core::convert::Into::into(call_conv),(::unity::Array< ::unity::SystemType>)::core::convert::Into::into(argument_types))
177 }
178 }
179
180 #[doc = "`FilterApplyMethodBase(crate::system::reflection::methodbase::MethodBase, crate::system::reflection::bindingflags::BindingFlags, crate::system::reflection::bindingflags::BindingFlags, crate::system::reflection::callingconventions::CallingConventions, ::unity::Array<::unity::SystemType>)` overload"]
181 pub fn filter_apply_method_base(
182 method_base: impl ::core::convert::Into<crate::system::reflection::methodbase::MethodBase>,
183 method_flags: impl ::core::convert::Into<crate::system::reflection::bindingflags::BindingFlags>,
184 binding_flags: impl ::core::convert::Into<crate::system::reflection::bindingflags::BindingFlags>,
185 call_conv: impl ::core::convert::Into<crate::system::reflection::callingconventions::CallingConventions>,
186 argument_types: impl ::core::convert::Into<::unity::Array<::unity::SystemType>>,
187 ) -> bool {
188 unsafe {
189 ::unity::il2cpp_call!((::unity::module_base()+0x2fd8690usize)as*mut u8,bool;
190(crate::system::reflection::methodbase::MethodBase)::core::convert::Into::into(method_base),(crate::system::reflection::bindingflags::BindingFlags)::core::convert::Into::into(method_flags),(crate::system::reflection::bindingflags::BindingFlags)::core::convert::Into::into(binding_flags),(crate::system::reflection::callingconventions::CallingConventions)::core::convert::Into::into(call_conv),(::unity::Array< ::unity::SystemType>)::core::convert::Into::into(argument_types))
191 }
192 }
193
194 #[doc = "`op_Equality(crate::system::runtimetype::RuntimeType, crate::system::runtimetype::RuntimeType)` overload"]
195 pub fn op_equality(
196 left: impl ::core::convert::Into<crate::system::runtimetype::RuntimeType>,
197 right: impl ::core::convert::Into<crate::system::runtimetype::RuntimeType>,
198 ) -> bool {
199 unsafe {
200 ::unity::il2cpp_call!((::unity::module_base()+0x2fcea40usize)as*mut u8,bool;
201(crate::system::runtimetype::RuntimeType)::core::convert::Into::into(left),(crate::system::runtimetype::RuntimeType)::core::convert::Into::into(right))
202 }
203 }
204
205 #[doc = "`op_Inequality(crate::system::runtimetype::RuntimeType, crate::system::runtimetype::RuntimeType)` overload"]
206 pub fn op_inequality(
207 left: impl ::core::convert::Into<crate::system::runtimetype::RuntimeType>,
208 right: impl ::core::convert::Into<crate::system::runtimetype::RuntimeType>,
209 ) -> bool {
210 unsafe {
211 ::unity::il2cpp_call!((::unity::module_base()+0x2fd8cd0usize)as*mut u8,bool;
212(crate::system::runtimetype::RuntimeType)::core::convert::Into::into(left),(crate::system::runtimetype::RuntimeType)::core::convert::Into::into(right))
213 }
214 }
215
216 #[doc = "`IsConvertibleToPrimitiveType(crate::system::object::Object, ::unity::SystemType)` overload"]
217 pub fn is_convertible_to_primitive_type(
218 value: impl ::core::convert::Into<crate::system::object::Object>,
219 target_type: impl ::core::convert::Into<::unity::SystemType>,
220 ) -> crate::system::object::Object {
221 unsafe {
222 ::unity::il2cpp_call!((::unity::module_base()+0x2fe1510usize)as*mut u8,crate::system::object::Object;
223(crate::system::object::Object)::core::convert::Into::into(value),(::unity::SystemType)::core::convert::Into::into(target_type))
224 }
225 }
226
227 #[doc = "`MakePointerType(::unity::SystemType)` overload"]
228 pub fn make_pointer_type(r#type: impl ::core::convert::Into<::unity::SystemType>) -> ::unity::SystemType {
229 unsafe {
230 ::unity::il2cpp_call!((::unity::module_base()+0x2fe2150usize)as*mut u8, ::unity::SystemType;
231(::unity::SystemType)::core::convert::Into::into(r#type))
232 }
233 }
234
235 #[doc = "`CreateInstanceForAnotherGenericParameter(::unity::SystemType, crate::system::runtimetype::RuntimeType)` overload"]
236 pub fn create_instance_for_another_generic_parameter(
237 generic_type: impl ::core::convert::Into<::unity::SystemType>,
238 generic_argument: impl ::core::convert::Into<crate::system::runtimetype::RuntimeType>,
239 ) -> crate::system::object::Object {
240 unsafe {
241 ::unity::il2cpp_call!((::unity::module_base()+0x2fe2400usize)as*mut u8,crate::system::object::Object;
242(::unity::SystemType)::core::convert::Into::into(generic_type),(crate::system::runtimetype::RuntimeType)::core::convert::Into::into(generic_argument))
243 }
244 }
245
246 #[doc = "`MakeGenericType(::unity::SystemType, ::unity::Array<::unity::SystemType>)` overload"]
247 pub fn make_generic_type_2(
248 gt: impl ::core::convert::Into<::unity::SystemType>,
249 types: impl ::core::convert::Into<::unity::Array<::unity::SystemType>>,
250 ) -> ::unity::SystemType {
251 unsafe {
252 ::unity::il2cpp_call!((::unity::module_base()+0x2fde1a0usize)as*mut u8, ::unity::SystemType;
253(::unity::SystemType)::core::convert::Into::into(gt),(::unity::Array< ::unity::SystemType>)::core::convert::Into::into(types))
254 }
255 }
256
257 #[doc = "`CreateInstanceInternal(::unity::SystemType)` overload"]
258 pub fn create_instance_internal(r#type: impl ::core::convert::Into<::unity::SystemType>) -> crate::system::object::Object {
259 unsafe {
260 ::unity::il2cpp_call!((::unity::module_base()+0x2fe10e0usize)as*mut u8,crate::system::object::Object;
261(::unity::SystemType)::core::convert::Into::into(r#type))
262 }
263 }
264
265 #[doc = "`.cctor()` overload"]
266 pub fn cctor() -> () {
267 unsafe {
268 ::unity::il2cpp_call!((::unity::module_base()+0x2fe2ab0usize)as*mut u8,();
269 )
270 }
271 }
272}
273
274#[cfg(feature = "system-runtimetype")]
275pub trait IRuntimeTypeMethods: IRuntimeType {
276 #[doc = "`.ctor()` overload"]
277 fn ctor(self) -> () {
278 unsafe {
279 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
280 ::unity::il2cpp_call!((::unity::module_base()+0x2fd8990usize)as*mut u8,();
281(RuntimeType)__receiver)
282 }
283 }
284 #[doc = "`IsSpecialSerializableType()` overload"]
285 fn is_special_serializable_type(self) -> bool {
286 unsafe {
287 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
288 ::unity::il2cpp_call!((::unity::module_base()+0x2fd89e0usize)as*mut u8,bool;
289(RuntimeType)__receiver)
290 }
291 }
292 #[doc = "`GetMethods(crate::system::reflection::bindingflags::BindingFlags)` overload"]
293 fn get_methods(
294 self,
295 binding_attr: impl ::core::convert::Into<crate::system::reflection::bindingflags::BindingFlags>,
296 ) -> ::unity::Array<crate::system::reflection::methodinfo::MethodInfo> {
297 unsafe {
298 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
299 {
300 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
301 let __vi = *__vt.get(43usize).unwrap_or_else(|| {
302 panic!(
303 "unity: virtual slot {}
304 out of range (vtable len {}
305) on the runtime class behind {}
306 (method `{}
307`)",
308 43usize,
309 __vt.len(),
310 <RuntimeType as ::unity::ClassIdentity>::NAME,
311 "GetMethods",
312 )
313 });
314 let __inner: extern "C" fn(
315 RuntimeType,
316 crate::system::reflection::bindingflags::BindingFlags,
317 ::unity::OptionalMethod,
318 ) -> ::unity::Array<crate::system::reflection::methodinfo::MethodInfo> = ::core::mem::transmute(__vi.method_ptr);
319 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
320 __inner(__receiver, ::core::convert::Into::into(binding_attr), __mi)
321 }
322 }
323 }
324 #[doc = "`GetConstructors(crate::system::reflection::bindingflags::BindingFlags)` overload"]
325 fn get_constructors(
326 self,
327 binding_attr: impl ::core::convert::Into<crate::system::reflection::bindingflags::BindingFlags>,
328 ) -> ::unity::Array<crate::system::reflection::constructorinfo::ConstructorInfo> {
329 unsafe {
330 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
331 {
332 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
333 let __vi = *__vt.get(36usize).unwrap_or_else(|| {
334 panic!(
335 "unity: virtual slot {}
336 out of range (vtable len {}
337) on the runtime class behind {}
338 (method `{}
339`)",
340 36usize,
341 __vt.len(),
342 <RuntimeType as ::unity::ClassIdentity>::NAME,
343 "GetConstructors",
344 )
345 });
346 let __inner: extern "C" fn(
347 RuntimeType,
348 crate::system::reflection::bindingflags::BindingFlags,
349 ::unity::OptionalMethod,
350 ) -> ::unity::Array<crate::system::reflection::constructorinfo::ConstructorInfo> = ::core::mem::transmute(__vi.method_ptr);
351 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
352 __inner(__receiver, ::core::convert::Into::into(binding_attr), __mi)
353 }
354 }
355 }
356 #[doc = "`GetProperties(crate::system::reflection::bindingflags::BindingFlags)` overload"]
357 fn get_properties(
358 self,
359 binding_attr: impl ::core::convert::Into<crate::system::reflection::bindingflags::BindingFlags>,
360 ) -> ::unity::Array<crate::system::reflection::propertyinfo::PropertyInfo> {
361 unsafe {
362 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
363 {
364 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
365 let __vi = *__vt.get(56usize).unwrap_or_else(|| {
366 panic!(
367 "unity: virtual slot {}
368 out of range (vtable len {}
369) on the runtime class behind {}
370 (method `{}
371`)",
372 56usize,
373 __vt.len(),
374 <RuntimeType as ::unity::ClassIdentity>::NAME,
375 "GetProperties",
376 )
377 });
378 let __inner: extern "C" fn(
379 RuntimeType,
380 crate::system::reflection::bindingflags::BindingFlags,
381 ::unity::OptionalMethod,
382 ) -> ::unity::Array<crate::system::reflection::propertyinfo::PropertyInfo> = ::core::mem::transmute(__vi.method_ptr);
383 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
384 __inner(__receiver, ::core::convert::Into::into(binding_attr), __mi)
385 }
386 }
387 }
388 #[doc = "`GetEvents(crate::system::reflection::bindingflags::BindingFlags)` overload"]
389 fn get_events(
390 self,
391 binding_attr: impl ::core::convert::Into<crate::system::reflection::bindingflags::BindingFlags>,
392 ) -> ::unity::Array<crate::system::reflection::eventinfo::EventInfo> {
393 unsafe {
394 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
395 {
396 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
397 let __vi = *__vt.get(50usize).unwrap_or_else(|| {
398 panic!(
399 "unity: virtual slot {}
400 out of range (vtable len {}
401) on the runtime class behind {}
402 (method `{}
403`)",
404 50usize,
405 __vt.len(),
406 <RuntimeType as ::unity::ClassIdentity>::NAME,
407 "GetEvents",
408 )
409 });
410 let __inner: extern "C" fn(
411 RuntimeType,
412 crate::system::reflection::bindingflags::BindingFlags,
413 ::unity::OptionalMethod,
414 ) -> ::unity::Array<crate::system::reflection::eventinfo::EventInfo> = ::core::mem::transmute(__vi.method_ptr);
415 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
416 __inner(__receiver, ::core::convert::Into::into(binding_attr), __mi)
417 }
418 }
419 }
420 #[doc = "`GetFields(crate::system::reflection::bindingflags::BindingFlags)` overload"]
421 fn get_fields(
422 self,
423 binding_attr: impl ::core::convert::Into<crate::system::reflection::bindingflags::BindingFlags>,
424 ) -> ::unity::Array<crate::system::reflection::fieldinfo::FieldInfo> {
425 unsafe {
426 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
427 {
428 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
429 let __vi = *__vt.get(45usize).unwrap_or_else(|| {
430 panic!(
431 "unity: virtual slot {}
432 out of range (vtable len {}
433) on the runtime class behind {}
434 (method `{}
435`)",
436 45usize,
437 __vt.len(),
438 <RuntimeType as ::unity::ClassIdentity>::NAME,
439 "GetFields",
440 )
441 });
442 let __inner: extern "C" fn(
443 RuntimeType,
444 crate::system::reflection::bindingflags::BindingFlags,
445 ::unity::OptionalMethod,
446 ) -> ::unity::Array<crate::system::reflection::fieldinfo::FieldInfo> = ::core::mem::transmute(__vi.method_ptr);
447 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
448 __inner(__receiver, ::core::convert::Into::into(binding_attr), __mi)
449 }
450 }
451 }
452 #[doc = "`GetNestedTypes(crate::system::reflection::bindingflags::BindingFlags)` overload"]
453 fn get_nested_types(
454 self,
455 binding_attr: impl ::core::convert::Into<crate::system::reflection::bindingflags::BindingFlags>,
456 ) -> ::unity::Array<::unity::SystemType> {
457 unsafe {
458 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
459 {
460 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
461 let __vi = *__vt.get(58usize).unwrap_or_else(|| {
462 panic!(
463 "unity: virtual slot {}
464 out of range (vtable len {}
465) on the runtime class behind {}
466 (method `{}
467`)",
468 58usize,
469 __vt.len(),
470 <RuntimeType as ::unity::ClassIdentity>::NAME,
471 "GetNestedTypes",
472 )
473 });
474 let __inner: extern "C" fn(
475 RuntimeType,
476 crate::system::reflection::bindingflags::BindingFlags,
477 ::unity::OptionalMethod,
478 ) -> ::unity::Array<::unity::SystemType> = ::core::mem::transmute(__vi.method_ptr);
479 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
480 __inner(__receiver, ::core::convert::Into::into(binding_attr), __mi)
481 }
482 }
483 }
484 #[doc = "`GetMethodImpl(::unity::Il2CppString, crate::system::reflection::bindingflags::BindingFlags, crate::system::reflection::binder::Binder, crate::system::reflection::callingconventions::CallingConventions, ::unity::Array<::unity::SystemType>, ::unity::Array<crate::system::reflection::parametermodifier::ParameterModifier>)` overload"]
485 fn get_method_impl(
486 self,
487 name: impl ::core::convert::Into<::unity::Il2CppString>,
488 binding_attr: impl ::core::convert::Into<crate::system::reflection::bindingflags::BindingFlags>,
489 binder: impl ::core::convert::Into<crate::system::reflection::binder::Binder>,
490 call_conv: impl ::core::convert::Into<crate::system::reflection::callingconventions::CallingConventions>,
491 types: impl ::core::convert::Into<::unity::Array<::unity::SystemType>>,
492 modifiers: impl ::core::convert::Into<::unity::Array<crate::system::reflection::parametermodifier::ParameterModifier>>,
493 ) -> crate::system::reflection::methodinfo::MethodInfo {
494 unsafe {
495 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
496 {
497 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
498 let __vi = *__vt.get(41usize).unwrap_or_else(|| {
499 panic!(
500 "unity: virtual slot {}
501 out of range (vtable len {}
502) on the runtime class behind {}
503 (method `{}
504`)",
505 41usize,
506 __vt.len(),
507 <RuntimeType as ::unity::ClassIdentity>::NAME,
508 "GetMethodImpl",
509 )
510 });
511 let __inner: extern "C" fn(
512 RuntimeType,
513 ::unity::Il2CppString,
514 crate::system::reflection::bindingflags::BindingFlags,
515 crate::system::reflection::binder::Binder,
516 crate::system::reflection::callingconventions::CallingConventions,
517 ::unity::Array<::unity::SystemType>,
518 ::unity::Array<crate::system::reflection::parametermodifier::ParameterModifier>,
519 ::unity::OptionalMethod,
520 ) -> crate::system::reflection::methodinfo::MethodInfo = ::core::mem::transmute(__vi.method_ptr);
521 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
522 __inner(
523 __receiver,
524 ::core::convert::Into::into(name),
525 ::core::convert::Into::into(binding_attr),
526 ::core::convert::Into::into(binder),
527 ::core::convert::Into::into(call_conv),
528 ::core::convert::Into::into(types),
529 ::core::convert::Into::into(modifiers),
530 __mi,
531 )
532 }
533 }
534 }
535 #[doc = "`GetConstructorImpl(crate::system::reflection::bindingflags::BindingFlags, crate::system::reflection::binder::Binder, crate::system::reflection::callingconventions::CallingConventions, ::unity::Array<::unity::SystemType>, ::unity::Array<crate::system::reflection::parametermodifier::ParameterModifier>)` overload"]
536 fn get_constructor_impl(
537 self,
538 binding_attr: impl ::core::convert::Into<crate::system::reflection::bindingflags::BindingFlags>,
539 binder: impl ::core::convert::Into<crate::system::reflection::binder::Binder>,
540 call_convention: impl ::core::convert::Into<crate::system::reflection::callingconventions::CallingConventions>,
541 types: impl ::core::convert::Into<::unity::Array<::unity::SystemType>>,
542 modifiers: impl ::core::convert::Into<::unity::Array<crate::system::reflection::parametermodifier::ParameterModifier>>,
543 ) -> crate::system::reflection::constructorinfo::ConstructorInfo {
544 unsafe {
545 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
546 {
547 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
548 let __vi = *__vt.get(35usize).unwrap_or_else(|| {
549 panic!(
550 "unity: virtual slot {}
551 out of range (vtable len {}
552) on the runtime class behind {}
553 (method `{}
554`)",
555 35usize,
556 __vt.len(),
557 <RuntimeType as ::unity::ClassIdentity>::NAME,
558 "GetConstructorImpl",
559 )
560 });
561 let __inner: extern "C" fn(
562 RuntimeType,
563 crate::system::reflection::bindingflags::BindingFlags,
564 crate::system::reflection::binder::Binder,
565 crate::system::reflection::callingconventions::CallingConventions,
566 ::unity::Array<::unity::SystemType>,
567 ::unity::Array<crate::system::reflection::parametermodifier::ParameterModifier>,
568 ::unity::OptionalMethod,
569 ) -> crate::system::reflection::constructorinfo::ConstructorInfo = ::core::mem::transmute(__vi.method_ptr);
570 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
571 __inner(
572 __receiver,
573 ::core::convert::Into::into(binding_attr),
574 ::core::convert::Into::into(binder),
575 ::core::convert::Into::into(call_convention),
576 ::core::convert::Into::into(types),
577 ::core::convert::Into::into(modifiers),
578 __mi,
579 )
580 }
581 }
582 }
583 #[doc = "`GetPropertyImpl(::unity::Il2CppString, crate::system::reflection::bindingflags::BindingFlags, crate::system::reflection::binder::Binder, ::unity::SystemType, ::unity::Array<::unity::SystemType>, ::unity::Array<crate::system::reflection::parametermodifier::ParameterModifier>)` overload"]
584 fn get_property_impl(
585 self,
586 name: impl ::core::convert::Into<::unity::Il2CppString>,
587 binding_attr: impl ::core::convert::Into<crate::system::reflection::bindingflags::BindingFlags>,
588 binder: impl ::core::convert::Into<crate::system::reflection::binder::Binder>,
589 return_type: impl ::core::convert::Into<::unity::SystemType>,
590 types: impl ::core::convert::Into<::unity::Array<::unity::SystemType>>,
591 modifiers: impl ::core::convert::Into<::unity::Array<crate::system::reflection::parametermodifier::ParameterModifier>>,
592 ) -> crate::system::reflection::propertyinfo::PropertyInfo {
593 unsafe {
594 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
595 {
596 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
597 let __vi = *__vt.get(55usize).unwrap_or_else(|| {
598 panic!(
599 "unity: virtual slot {}
600 out of range (vtable len {}
601) on the runtime class behind {}
602 (method `{}
603`)",
604 55usize,
605 __vt.len(),
606 <RuntimeType as ::unity::ClassIdentity>::NAME,
607 "GetPropertyImpl",
608 )
609 });
610 let __inner: extern "C" fn(
611 RuntimeType,
612 ::unity::Il2CppString,
613 crate::system::reflection::bindingflags::BindingFlags,
614 crate::system::reflection::binder::Binder,
615 ::unity::SystemType,
616 ::unity::Array<::unity::SystemType>,
617 ::unity::Array<crate::system::reflection::parametermodifier::ParameterModifier>,
618 ::unity::OptionalMethod,
619 ) -> crate::system::reflection::propertyinfo::PropertyInfo = ::core::mem::transmute(__vi.method_ptr);
620 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
621 __inner(
622 __receiver,
623 ::core::convert::Into::into(name),
624 ::core::convert::Into::into(binding_attr),
625 ::core::convert::Into::into(binder),
626 ::core::convert::Into::into(return_type),
627 ::core::convert::Into::into(types),
628 ::core::convert::Into::into(modifiers),
629 __mi,
630 )
631 }
632 }
633 }
634 #[doc = "`GetEvent(::unity::Il2CppString, crate::system::reflection::bindingflags::BindingFlags)` overload"]
635 fn get_event(
636 self,
637 name: impl ::core::convert::Into<::unity::Il2CppString>,
638 binding_attr: impl ::core::convert::Into<crate::system::reflection::bindingflags::BindingFlags>,
639 ) -> crate::system::reflection::eventinfo::EventInfo {
640 unsafe {
641 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
642 {
643 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
644 let __vi = *__vt.get(49usize).unwrap_or_else(|| {
645 panic!(
646 "unity: virtual slot {}
647 out of range (vtable len {}
648) on the runtime class behind {}
649 (method `{}
650`)",
651 49usize,
652 __vt.len(),
653 <RuntimeType as ::unity::ClassIdentity>::NAME,
654 "GetEvent",
655 )
656 });
657 let __inner: extern "C" fn(
658 RuntimeType,
659 ::unity::Il2CppString,
660 crate::system::reflection::bindingflags::BindingFlags,
661 ::unity::OptionalMethod,
662 ) -> crate::system::reflection::eventinfo::EventInfo = ::core::mem::transmute(__vi.method_ptr);
663 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
664 __inner(
665 __receiver,
666 ::core::convert::Into::into(name),
667 ::core::convert::Into::into(binding_attr),
668 __mi,
669 )
670 }
671 }
672 }
673 #[doc = "`GetField(::unity::Il2CppString, crate::system::reflection::bindingflags::BindingFlags)` overload"]
674 fn get_field(
675 self,
676 name: impl ::core::convert::Into<::unity::Il2CppString>,
677 binding_attr: impl ::core::convert::Into<crate::system::reflection::bindingflags::BindingFlags>,
678 ) -> crate::system::reflection::fieldinfo::FieldInfo {
679 unsafe {
680 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
681 {
682 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
683 let __vi = *__vt.get(44usize).unwrap_or_else(|| {
684 panic!(
685 "unity: virtual slot {}
686 out of range (vtable len {}
687) on the runtime class behind {}
688 (method `{}
689`)",
690 44usize,
691 __vt.len(),
692 <RuntimeType as ::unity::ClassIdentity>::NAME,
693 "GetField",
694 )
695 });
696 let __inner: extern "C" fn(
697 RuntimeType,
698 ::unity::Il2CppString,
699 crate::system::reflection::bindingflags::BindingFlags,
700 ::unity::OptionalMethod,
701 ) -> crate::system::reflection::fieldinfo::FieldInfo = ::core::mem::transmute(__vi.method_ptr);
702 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
703 __inner(
704 __receiver,
705 ::core::convert::Into::into(name),
706 ::core::convert::Into::into(binding_attr),
707 __mi,
708 )
709 }
710 }
711 }
712 #[doc = "`GetInterface(::unity::Il2CppString, bool)` overload"]
713 fn get_interface(
714 self,
715 fullname: impl ::core::convert::Into<::unity::Il2CppString>,
716 ignore_case: impl ::core::convert::Into<bool>,
717 ) -> ::unity::SystemType {
718 unsafe {
719 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
720 {
721 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
722 let __vi = *__vt.get(47usize).unwrap_or_else(|| {
723 panic!(
724 "unity: virtual slot {}
725 out of range (vtable len {}
726) on the runtime class behind {}
727 (method `{}
728`)",
729 47usize,
730 __vt.len(),
731 <RuntimeType as ::unity::ClassIdentity>::NAME,
732 "GetInterface",
733 )
734 });
735 let __inner: extern "C" fn(RuntimeType, ::unity::Il2CppString, bool, ::unity::OptionalMethod) -> ::unity::SystemType =
736 ::core::mem::transmute(__vi.method_ptr);
737 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
738 __inner(
739 __receiver,
740 ::core::convert::Into::into(fullname),
741 ::core::convert::Into::into(ignore_case),
742 __mi,
743 )
744 }
745 }
746 }
747 #[doc = "`GetNestedType(::unity::Il2CppString, crate::system::reflection::bindingflags::BindingFlags)` overload"]
748 fn get_nested_type(
749 self,
750 fullname: impl ::core::convert::Into<::unity::Il2CppString>,
751 binding_attr: impl ::core::convert::Into<crate::system::reflection::bindingflags::BindingFlags>,
752 ) -> ::unity::SystemType {
753 unsafe {
754 let __receiver = <RuntimeType 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(59usize).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 59usize,
765 __vt.len(),
766 <RuntimeType as ::unity::ClassIdentity>::NAME,
767 "GetNestedType",
768 )
769 });
770 let __inner: extern "C" fn(
771 RuntimeType,
772 ::unity::Il2CppString,
773 crate::system::reflection::bindingflags::BindingFlags,
774 ::unity::OptionalMethod,
775 ) -> ::unity::SystemType = ::core::mem::transmute(__vi.method_ptr);
776 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
777 __inner(
778 __receiver,
779 ::core::convert::Into::into(fullname),
780 ::core::convert::Into::into(binding_attr),
781 __mi,
782 )
783 }
784 }
785 }
786 #[doc = "`GetMember(::unity::Il2CppString, crate::system::reflection::membertypes::MemberTypes, crate::system::reflection::bindingflags::BindingFlags)` overload"]
787 fn get_member(
788 self,
789 name: impl ::core::convert::Into<::unity::Il2CppString>,
790 r#type: impl ::core::convert::Into<crate::system::reflection::membertypes::MemberTypes>,
791 binding_attr: impl ::core::convert::Into<crate::system::reflection::bindingflags::BindingFlags>,
792 ) -> ::unity::Array<crate::system::reflection::memberinfo::MemberInfo> {
793 unsafe {
794 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
795 {
796 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
797 let __vi = *__vt.get(62usize).unwrap_or_else(|| {
798 panic!(
799 "unity: virtual slot {}
800 out of range (vtable len {}
801) on the runtime class behind {}
802 (method `{}
803`)",
804 62usize,
805 __vt.len(),
806 <RuntimeType as ::unity::ClassIdentity>::NAME,
807 "GetMember",
808 )
809 });
810 let __inner: extern "C" fn(
811 RuntimeType,
812 ::unity::Il2CppString,
813 crate::system::reflection::membertypes::MemberTypes,
814 crate::system::reflection::bindingflags::BindingFlags,
815 ::unity::OptionalMethod,
816 ) -> ::unity::Array<crate::system::reflection::memberinfo::MemberInfo> = ::core::mem::transmute(__vi.method_ptr);
817 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
818 __inner(
819 __receiver,
820 ::core::convert::Into::into(name),
821 ::core::convert::Into::into(r#type),
822 ::core::convert::Into::into(binding_attr),
823 __mi,
824 )
825 }
826 }
827 }
828 #[doc = "`get_Module()` overload"]
829 fn get_module(self) -> crate::system::reflection::module::Module {
830 unsafe {
831 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
832 {
833 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
834 let __vi = *__vt.get(15usize).unwrap_or_else(|| {
835 panic!(
836 "unity: virtual slot {}
837 out of range (vtable len {}
838) on the runtime class behind {}
839 (method `{}
840`)",
841 15usize,
842 __vt.len(),
843 <RuntimeType as ::unity::ClassIdentity>::NAME,
844 "get_Module",
845 )
846 });
847 let __inner: extern "C" fn(RuntimeType, ::unity::OptionalMethod) -> crate::system::reflection::module::Module =
848 ::core::mem::transmute(__vi.method_ptr);
849 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
850 __inner(__receiver, __mi)
851 }
852 }
853 }
854 #[doc = "`GetRuntimeModule()` overload"]
855 fn get_runtime_module(self) -> crate::system::reflection::runtimemodule::RuntimeModule {
856 unsafe {
857 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
858 ::unity::il2cpp_call!((::unity::module_base()+0x2fd43c0usize)as*mut u8,crate::system::reflection::runtimemodule::RuntimeModule;
859(RuntimeType)__receiver)
860 }
861 }
862 #[doc = "`get_Assembly()` overload"]
863 fn get_assembly(self) -> crate::system::reflection::assembly::Assembly {
864 unsafe {
865 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
866 {
867 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
868 let __vi = *__vt.get(25usize).unwrap_or_else(|| {
869 panic!(
870 "unity: virtual slot {}
871 out of range (vtable len {}
872) on the runtime class behind {}
873 (method `{}
874`)",
875 25usize,
876 __vt.len(),
877 <RuntimeType as ::unity::ClassIdentity>::NAME,
878 "get_Assembly",
879 )
880 });
881 let __inner: extern "C" fn(RuntimeType, ::unity::OptionalMethod) -> crate::system::reflection::assembly::Assembly =
882 ::core::mem::transmute(__vi.method_ptr);
883 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
884 __inner(__receiver, __mi)
885 }
886 }
887 }
888 #[doc = "`GetRuntimeAssembly()` overload"]
889 fn get_runtime_assembly(self) -> crate::system::reflection::runtimeassembly::RuntimeAssembly {
890 unsafe {
891 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
892 ::unity::il2cpp_call!((::unity::module_base()+0x2fdc880usize)as*mut u8,crate::system::reflection::runtimeassembly::RuntimeAssembly;
893(RuntimeType)__receiver)
894 }
895 }
896 #[doc = "`IsInstanceOfType(crate::system::object::Object)` overload"]
897 fn is_instance_of_type(self, o: impl ::core::convert::Into<crate::system::object::Object>) -> bool {
898 unsafe {
899 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
900 {
901 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
902 let __vi = *__vt.get(118usize).unwrap_or_else(|| {
903 panic!(
904 "unity: virtual slot {}
905 out of range (vtable len {}
906) on the runtime class behind {}
907 (method `{}
908`)",
909 118usize,
910 __vt.len(),
911 <RuntimeType as ::unity::ClassIdentity>::NAME,
912 "IsInstanceOfType",
913 )
914 });
915 let __inner: extern "C" fn(RuntimeType, crate::system::object::Object, ::unity::OptionalMethod) -> bool =
916 ::core::mem::transmute(__vi.method_ptr);
917 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
918 __inner(__receiver, ::core::convert::Into::into(o), __mi)
919 }
920 }
921 }
922 #[doc = "`IsSubclassOf(::unity::SystemType)` overload"]
923 fn is_subclass_of(self, r#type: impl ::core::convert::Into<::unity::SystemType>) -> bool {
924 unsafe {
925 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
926 {
927 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
928 let __vi = *__vt.get(117usize).unwrap_or_else(|| {
929 panic!(
930 "unity: virtual slot {}
931 out of range (vtable len {}
932) on the runtime class behind {}
933 (method `{}
934`)",
935 117usize,
936 __vt.len(),
937 <RuntimeType as ::unity::ClassIdentity>::NAME,
938 "IsSubclassOf",
939 )
940 });
941 let __inner: extern "C" fn(RuntimeType, ::unity::SystemType, ::unity::OptionalMethod) -> bool =
942 ::core::mem::transmute(__vi.method_ptr);
943 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
944 __inner(__receiver, ::core::convert::Into::into(r#type), __mi)
945 }
946 }
947 }
948 #[doc = "`IsAssignableFrom(::unity::SystemType)` overload"]
949 fn is_assignable_from(self, c: impl ::core::convert::Into<::unity::SystemType>) -> bool {
950 unsafe {
951 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
952 {
953 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
954 let __vi = *__vt.get(119usize).unwrap_or_else(|| {
955 panic!(
956 "unity: virtual slot {}
957 out of range (vtable len {}
958) on the runtime class behind {}
959 (method `{}
960`)",
961 119usize,
962 __vt.len(),
963 <RuntimeType as ::unity::ClassIdentity>::NAME,
964 "IsAssignableFrom",
965 )
966 });
967 let __inner: extern "C" fn(RuntimeType, ::unity::SystemType, ::unity::OptionalMethod) -> bool =
968 ::core::mem::transmute(__vi.method_ptr);
969 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
970 __inner(__receiver, ::core::convert::Into::into(c), __mi)
971 }
972 }
973 }
974 #[doc = "`IsEquivalentTo(::unity::SystemType)` overload"]
975 fn is_equivalent_to(self, other: impl ::core::convert::Into<::unity::SystemType>) -> bool {
976 unsafe {
977 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
978 {
979 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
980 let __vi = *__vt.get(120usize).unwrap_or_else(|| {
981 panic!(
982 "unity: virtual slot {}
983 out of range (vtable len {}
984) on the runtime class behind {}
985 (method `{}
986`)",
987 120usize,
988 __vt.len(),
989 <RuntimeType as ::unity::ClassIdentity>::NAME,
990 "IsEquivalentTo",
991 )
992 });
993 let __inner: extern "C" fn(RuntimeType, ::unity::SystemType, ::unity::OptionalMethod) -> bool =
994 ::core::mem::transmute(__vi.method_ptr);
995 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
996 __inner(__receiver, ::core::convert::Into::into(other), __mi)
997 }
998 }
999 }
1000 #[doc = "`get_BaseType()` overload"]
1001 fn get_base_type(self) -> ::unity::SystemType {
1002 unsafe {
1003 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1004 {
1005 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1006 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
1007 panic!(
1008 "unity: virtual slot {}
1009 out of range (vtable len {}
1010) on the runtime class behind {}
1011 (method `{}
1012`)",
1013 31usize,
1014 __vt.len(),
1015 <RuntimeType as ::unity::ClassIdentity>::NAME,
1016 "get_BaseType",
1017 )
1018 });
1019 let __inner: extern "C" fn(RuntimeType, ::unity::OptionalMethod) -> ::unity::SystemType = ::core::mem::transmute(__vi.method_ptr);
1020 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1021 __inner(__receiver, __mi)
1022 }
1023 }
1024 }
1025 #[doc = "`get_UnderlyingSystemType()` overload"]
1026 fn get_underlying_system_type(self) -> ::unity::SystemType {
1027 unsafe {
1028 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1029 {
1030 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1031 let __vi = *__vt.get(116usize).unwrap_or_else(|| {
1032 panic!(
1033 "unity: virtual slot {}
1034 out of range (vtable len {}
1035) on the runtime class behind {}
1036 (method `{}
1037`)",
1038 116usize,
1039 __vt.len(),
1040 <RuntimeType as ::unity::ClassIdentity>::NAME,
1041 "get_UnderlyingSystemType",
1042 )
1043 });
1044 let __inner: extern "C" fn(RuntimeType, ::unity::OptionalMethod) -> ::unity::SystemType = ::core::mem::transmute(__vi.method_ptr);
1045 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1046 __inner(__receiver, __mi)
1047 }
1048 }
1049 }
1050 #[doc = "`GetAttributeFlagsImpl()` overload"]
1051 fn get_attribute_flags_impl(self) -> crate::system::reflection::typeattributes::TypeAttributes {
1052 unsafe {
1053 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1054 {
1055 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1056 let __vi = *__vt.get(98usize).unwrap_or_else(|| {
1057 panic!(
1058 "unity: virtual slot {}
1059 out of range (vtable len {}
1060) on the runtime class behind {}
1061 (method `{}
1062`)",
1063 98usize,
1064 __vt.len(),
1065 <RuntimeType as ::unity::ClassIdentity>::NAME,
1066 "GetAttributeFlagsImpl",
1067 )
1068 });
1069 let __inner: extern "C" fn(RuntimeType, ::unity::OptionalMethod) -> crate::system::reflection::typeattributes::TypeAttributes =
1070 ::core::mem::transmute(__vi.method_ptr);
1071 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1072 __inner(__receiver, __mi)
1073 }
1074 }
1075 }
1076 #[doc = "`IsContextfulImpl()` overload"]
1077 fn is_contextful_impl(self) -> bool {
1078 unsafe {
1079 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1080 {
1081 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1082 let __vi = *__vt.get(105usize).unwrap_or_else(|| {
1083 panic!(
1084 "unity: virtual slot {}
1085 out of range (vtable len {}
1086) on the runtime class behind {}
1087 (method `{}
1088`)",
1089 105usize,
1090 __vt.len(),
1091 <RuntimeType as ::unity::ClassIdentity>::NAME,
1092 "IsContextfulImpl",
1093 )
1094 });
1095 let __inner: extern "C" fn(RuntimeType, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
1096 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1097 __inner(__receiver, __mi)
1098 }
1099 }
1100 }
1101 #[doc = "`IsByRefImpl()` overload"]
1102 fn is_by_ref_impl(self) -> bool {
1103 unsafe {
1104 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1105 {
1106 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1107 let __vi = *__vt.get(100usize).unwrap_or_else(|| {
1108 panic!(
1109 "unity: virtual slot {}
1110 out of range (vtable len {}
1111) on the runtime class behind {}
1112 (method `{}
1113`)",
1114 100usize,
1115 __vt.len(),
1116 <RuntimeType as ::unity::ClassIdentity>::NAME,
1117 "IsByRefImpl",
1118 )
1119 });
1120 let __inner: extern "C" fn(RuntimeType, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
1121 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1122 __inner(__receiver, __mi)
1123 }
1124 }
1125 }
1126 #[doc = "`IsPrimitiveImpl()` overload"]
1127 fn is_primitive_impl(self) -> bool {
1128 unsafe {
1129 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1130 {
1131 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1132 let __vi = *__vt.get(102usize).unwrap_or_else(|| {
1133 panic!(
1134 "unity: virtual slot {}
1135 out of range (vtable len {}
1136) on the runtime class behind {}
1137 (method `{}
1138`)",
1139 102usize,
1140 __vt.len(),
1141 <RuntimeType as ::unity::ClassIdentity>::NAME,
1142 "IsPrimitiveImpl",
1143 )
1144 });
1145 let __inner: extern "C" fn(RuntimeType, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
1146 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1147 __inner(__receiver, __mi)
1148 }
1149 }
1150 }
1151 #[doc = "`IsPointerImpl()` overload"]
1152 fn is_pointer_impl(self) -> bool {
1153 unsafe {
1154 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1155 {
1156 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1157 let __vi = *__vt.get(101usize).unwrap_or_else(|| {
1158 panic!(
1159 "unity: virtual slot {}
1160 out of range (vtable len {}
1161) on the runtime class behind {}
1162 (method `{}
1163`)",
1164 101usize,
1165 __vt.len(),
1166 <RuntimeType as ::unity::ClassIdentity>::NAME,
1167 "IsPointerImpl",
1168 )
1169 });
1170 let __inner: extern "C" fn(RuntimeType, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
1171 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1172 __inner(__receiver, __mi)
1173 }
1174 }
1175 }
1176 #[doc = "`IsCOMObjectImpl()` overload"]
1177 fn is_com_object_impl(self) -> bool {
1178 unsafe {
1179 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1180 {
1181 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1182 let __vi = *__vt.get(103usize).unwrap_or_else(|| {
1183 panic!(
1184 "unity: virtual slot {}
1185 out of range (vtable len {}
1186) on the runtime class behind {}
1187 (method `{}
1188`)",
1189 103usize,
1190 __vt.len(),
1191 <RuntimeType as ::unity::ClassIdentity>::NAME,
1192 "IsCOMObjectImpl",
1193 )
1194 });
1195 let __inner: extern "C" fn(RuntimeType, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
1196 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1197 __inner(__receiver, __mi)
1198 }
1199 }
1200 }
1201 #[doc = "`IsValueTypeImpl()` overload"]
1202 fn is_value_type_impl(self) -> bool {
1203 unsafe {
1204 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1205 {
1206 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1207 let __vi = *__vt.get(97usize).unwrap_or_else(|| {
1208 panic!(
1209 "unity: virtual slot {}
1210 out of range (vtable len {}
1211) on the runtime class behind {}
1212 (method `{}
1213`)",
1214 97usize,
1215 __vt.len(),
1216 <RuntimeType as ::unity::ClassIdentity>::NAME,
1217 "IsValueTypeImpl",
1218 )
1219 });
1220 let __inner: extern "C" fn(RuntimeType, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
1221 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1222 __inner(__receiver, __mi)
1223 }
1224 }
1225 }
1226 #[doc = "`get_IsEnum()` overload"]
1227 fn get_is_enum(self) -> bool {
1228 unsafe {
1229 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1230 {
1231 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1232 let __vi = *__vt.get(79usize).unwrap_or_else(|| {
1233 panic!(
1234 "unity: virtual slot {}
1235 out of range (vtable len {}
1236) on the runtime class behind {}
1237 (method `{}
1238`)",
1239 79usize,
1240 __vt.len(),
1241 <RuntimeType as ::unity::ClassIdentity>::NAME,
1242 "get_IsEnum",
1243 )
1244 });
1245 let __inner: extern "C" fn(RuntimeType, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
1246 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1247 __inner(__receiver, __mi)
1248 }
1249 }
1250 }
1251 #[doc = "`HasElementTypeImpl()` overload"]
1252 fn has_element_type_impl(self) -> bool {
1253 unsafe {
1254 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1255 {
1256 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1257 let __vi = *__vt.get(110usize).unwrap_or_else(|| {
1258 panic!(
1259 "unity: virtual slot {}
1260 out of range (vtable len {}
1261) on the runtime class behind {}
1262 (method `{}
1263`)",
1264 110usize,
1265 __vt.len(),
1266 <RuntimeType as ::unity::ClassIdentity>::NAME,
1267 "HasElementTypeImpl",
1268 )
1269 });
1270 let __inner: extern "C" fn(RuntimeType, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
1271 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1272 __inner(__receiver, __mi)
1273 }
1274 }
1275 }
1276 #[doc = "`get_GenericParameterAttributes()` overload"]
1277 fn get_generic_parameter_attributes(self) -> crate::system::reflection::genericparameterattributes::GenericParameterAttributes {
1278 unsafe {
1279 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1280 {
1281 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1282 let __vi = *__vt.get(64usize).unwrap_or_else(|| {
1283 panic!(
1284 "unity: virtual slot {}
1285 out of range (vtable len {}
1286) on the runtime class behind {}
1287 (method `{}
1288`)",
1289 64usize,
1290 __vt.len(),
1291 <RuntimeType as ::unity::ClassIdentity>::NAME,
1292 "get_GenericParameterAttributes",
1293 )
1294 });
1295 let __inner: extern "C" fn(
1296 RuntimeType,
1297 ::unity::OptionalMethod,
1298 ) -> crate::system::reflection::genericparameterattributes::GenericParameterAttributes = ::core::mem::transmute(__vi.method_ptr);
1299 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1300 __inner(__receiver, __mi)
1301 }
1302 }
1303 }
1304 #[doc = "`get_IsSzArray()` overload"]
1305 fn get_is_sz_array(self) -> bool {
1306 unsafe {
1307 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1308 {
1309 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1310 let __vi = *__vt.get(82usize).unwrap_or_else(|| {
1311 panic!(
1312 "unity: virtual slot {}
1313 out of range (vtable len {}
1314) on the runtime class behind {}
1315 (method `{}
1316`)",
1317 82usize,
1318 __vt.len(),
1319 <RuntimeType as ::unity::ClassIdentity>::NAME,
1320 "get_IsSzArray",
1321 )
1322 });
1323 let __inner: extern "C" fn(RuntimeType, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
1324 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1325 __inner(__receiver, __mi)
1326 }
1327 }
1328 }
1329 #[doc = "`IsArrayImpl()` overload"]
1330 fn is_array_impl(self) -> bool {
1331 unsafe {
1332 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1333 {
1334 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1335 let __vi = *__vt.get(99usize).unwrap_or_else(|| {
1336 panic!(
1337 "unity: virtual slot {}
1338 out of range (vtable len {}
1339) on the runtime class behind {}
1340 (method `{}
1341`)",
1342 99usize,
1343 __vt.len(),
1344 <RuntimeType as ::unity::ClassIdentity>::NAME,
1345 "IsArrayImpl",
1346 )
1347 });
1348 let __inner: extern "C" fn(RuntimeType, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
1349 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1350 __inner(__receiver, __mi)
1351 }
1352 }
1353 }
1354 #[doc = "`GetArrayRank()` overload"]
1355 fn get_array_rank(self) -> i32 {
1356 unsafe {
1357 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1358 {
1359 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1360 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
1361 panic!(
1362 "unity: virtual slot {}
1363 out of range (vtable len {}
1364) on the runtime class behind {}
1365 (method `{}
1366`)",
1367 30usize,
1368 __vt.len(),
1369 <RuntimeType as ::unity::ClassIdentity>::NAME,
1370 "GetArrayRank",
1371 )
1372 });
1373 let __inner: extern "C" fn(RuntimeType, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__vi.method_ptr);
1374 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1375 __inner(__receiver, __mi)
1376 }
1377 }
1378 }
1379 #[doc = "`GetElementType()` overload"]
1380 fn get_element_type(self) -> ::unity::SystemType {
1381 unsafe {
1382 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1383 {
1384 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1385 let __vi = *__vt.get(107usize).unwrap_or_else(|| {
1386 panic!(
1387 "unity: virtual slot {}
1388 out of range (vtable len {}
1389) on the runtime class behind {}
1390 (method `{}
1391`)",
1392 107usize,
1393 __vt.len(),
1394 <RuntimeType as ::unity::ClassIdentity>::NAME,
1395 "GetElementType",
1396 )
1397 });
1398 let __inner: extern "C" fn(RuntimeType, ::unity::OptionalMethod) -> ::unity::SystemType = ::core::mem::transmute(__vi.method_ptr);
1399 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1400 __inner(__receiver, __mi)
1401 }
1402 }
1403 }
1404 #[doc = "`GetEnumNames()` overload"]
1405 fn get_enum_names(self) -> ::unity::Array<::unity::Il2CppString> {
1406 unsafe {
1407 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1408 {
1409 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1410 let __vi = *__vt.get(111usize).unwrap_or_else(|| {
1411 panic!(
1412 "unity: virtual slot {}
1413 out of range (vtable len {}
1414) on the runtime class behind {}
1415 (method `{}
1416`)",
1417 111usize,
1418 __vt.len(),
1419 <RuntimeType as ::unity::ClassIdentity>::NAME,
1420 "GetEnumNames",
1421 )
1422 });
1423 let __inner: extern "C" fn(RuntimeType, ::unity::OptionalMethod) -> ::unity::Array<::unity::Il2CppString> =
1424 ::core::mem::transmute(__vi.method_ptr);
1425 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1426 __inner(__receiver, __mi)
1427 }
1428 }
1429 }
1430 #[doc = "`GetEnumValues()` overload"]
1431 fn get_enum_values(self) -> ::unity::IlInstance {
1432 unsafe {
1433 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1434 {
1435 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1436 let __vi = *__vt.get(112usize).unwrap_or_else(|| {
1437 panic!(
1438 "unity: virtual slot {}
1439 out of range (vtable len {}
1440) on the runtime class behind {}
1441 (method `{}
1442`)",
1443 112usize,
1444 __vt.len(),
1445 <RuntimeType as ::unity::ClassIdentity>::NAME,
1446 "GetEnumValues",
1447 )
1448 });
1449 let __inner: extern "C" fn(RuntimeType, ::unity::OptionalMethod) -> ::unity::IlInstance = ::core::mem::transmute(__vi.method_ptr);
1450 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1451 __inner(__receiver, __mi)
1452 }
1453 }
1454 }
1455 #[doc = "`GetEnumUnderlyingType()` overload"]
1456 fn get_enum_underlying_type(self) -> ::unity::SystemType {
1457 unsafe {
1458 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1459 {
1460 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1461 let __vi = *__vt.get(113usize).unwrap_or_else(|| {
1462 panic!(
1463 "unity: virtual slot {}
1464 out of range (vtable len {}
1465) on the runtime class behind {}
1466 (method `{}
1467`)",
1468 113usize,
1469 __vt.len(),
1470 <RuntimeType as ::unity::ClassIdentity>::NAME,
1471 "GetEnumUnderlyingType",
1472 )
1473 });
1474 let __inner: extern "C" fn(RuntimeType, ::unity::OptionalMethod) -> ::unity::SystemType = ::core::mem::transmute(__vi.method_ptr);
1475 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1476 __inner(__receiver, __mi)
1477 }
1478 }
1479 }
1480 #[doc = "`IsEnumDefined(crate::system::object::Object)` overload"]
1481 fn is_enum_defined(self, value: impl ::core::convert::Into<crate::system::object::Object>) -> bool {
1482 unsafe {
1483 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1484 {
1485 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1486 let __vi = *__vt.get(114usize).unwrap_or_else(|| {
1487 panic!(
1488 "unity: virtual slot {}
1489 out of range (vtable len {}
1490) on the runtime class behind {}
1491 (method `{}
1492`)",
1493 114usize,
1494 __vt.len(),
1495 <RuntimeType as ::unity::ClassIdentity>::NAME,
1496 "IsEnumDefined",
1497 )
1498 });
1499 let __inner: extern "C" fn(RuntimeType, crate::system::object::Object, ::unity::OptionalMethod) -> bool =
1500 ::core::mem::transmute(__vi.method_ptr);
1501 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1502 __inner(__receiver, ::core::convert::Into::into(value), __mi)
1503 }
1504 }
1505 }
1506 #[doc = "`GetEnumName(crate::system::object::Object)` overload"]
1507 fn get_enum_name(self, value: impl ::core::convert::Into<crate::system::object::Object>) -> ::unity::Il2CppString {
1508 unsafe {
1509 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1510 {
1511 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1512 let __vi = *__vt.get(115usize).unwrap_or_else(|| {
1513 panic!(
1514 "unity: virtual slot {}
1515 out of range (vtable len {}
1516) on the runtime class behind {}
1517 (method `{}
1518`)",
1519 115usize,
1520 __vt.len(),
1521 <RuntimeType as ::unity::ClassIdentity>::NAME,
1522 "GetEnumName",
1523 )
1524 });
1525 let __inner: extern "C" fn(RuntimeType, crate::system::object::Object, ::unity::OptionalMethod) -> ::unity::Il2CppString =
1526 ::core::mem::transmute(__vi.method_ptr);
1527 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1528 __inner(__receiver, ::core::convert::Into::into(value), __mi)
1529 }
1530 }
1531 }
1532 #[doc = "`GetGenericArgumentsInternal()` overload"]
1533 fn get_generic_arguments_internal(self) -> ::unity::Array<crate::system::runtimetype::RuntimeType> {
1534 unsafe {
1535 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1536 ::unity::il2cpp_call!((::unity::module_base()+0x2fddb90usize)as*mut u8, ::unity::Array<crate::system::runtimetype::RuntimeType> ;
1537(RuntimeType)__receiver)
1538 }
1539 }
1540 #[doc = "`GetGenericArguments()` overload"]
1541 fn get_generic_arguments(self) -> ::unity::Array<::unity::SystemType> {
1542 unsafe {
1543 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1544 {
1545 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1546 let __vi = *__vt.get(108usize).unwrap_or_else(|| {
1547 panic!(
1548 "unity: virtual slot {}
1549 out of range (vtable len {}
1550) on the runtime class behind {}
1551 (method `{}
1552`)",
1553 108usize,
1554 __vt.len(),
1555 <RuntimeType as ::unity::ClassIdentity>::NAME,
1556 "GetGenericArguments",
1557 )
1558 });
1559 let __inner: extern "C" fn(RuntimeType, ::unity::OptionalMethod) -> ::unity::Array<::unity::SystemType> =
1560 ::core::mem::transmute(__vi.method_ptr);
1561 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1562 __inner(__receiver, __mi)
1563 }
1564 }
1565 }
1566 #[doc = "`MakeGenericType(::unity::Array<::unity::SystemType>)` overload"]
1567 fn make_generic_type(self, instantiation: impl ::core::convert::Into<::unity::Array<::unity::SystemType>>) -> ::unity::SystemType {
1568 unsafe {
1569 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1570 {
1571 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1572 let __vi = *__vt.get(104usize).unwrap_or_else(|| {
1573 panic!(
1574 "unity: virtual slot {}
1575 out of range (vtable len {}
1576) on the runtime class behind {}
1577 (method `{}
1578`)",
1579 104usize,
1580 __vt.len(),
1581 <RuntimeType as ::unity::ClassIdentity>::NAME,
1582 "MakeGenericType",
1583 )
1584 });
1585 let __inner: extern "C" fn(RuntimeType, ::unity::Array<::unity::SystemType>, ::unity::OptionalMethod) -> ::unity::SystemType =
1586 ::core::mem::transmute(__vi.method_ptr);
1587 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1588 __inner(__receiver, ::core::convert::Into::into(instantiation), __mi)
1589 }
1590 }
1591 }
1592 #[doc = "`get_IsGenericTypeDefinition()` overload"]
1593 fn get_is_generic_type_definition(self) -> bool {
1594 unsafe {
1595 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1596 {
1597 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1598 let __vi = *__vt.get(84usize).unwrap_or_else(|| {
1599 panic!(
1600 "unity: virtual slot {}
1601 out of range (vtable len {}
1602) on the runtime class behind {}
1603 (method `{}
1604`)",
1605 84usize,
1606 __vt.len(),
1607 <RuntimeType as ::unity::ClassIdentity>::NAME,
1608 "get_IsGenericTypeDefinition",
1609 )
1610 });
1611 let __inner: extern "C" fn(RuntimeType, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
1612 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1613 __inner(__receiver, __mi)
1614 }
1615 }
1616 }
1617 #[doc = "`get_IsGenericParameter()` overload"]
1618 fn get_is_generic_parameter(self) -> bool {
1619 unsafe {
1620 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1621 {
1622 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1623 let __vi = *__vt.get(86usize).unwrap_or_else(|| {
1624 panic!(
1625 "unity: virtual slot {}
1626 out of range (vtable len {}
1627) on the runtime class behind {}
1628 (method `{}
1629`)",
1630 86usize,
1631 __vt.len(),
1632 <RuntimeType as ::unity::ClassIdentity>::NAME,
1633 "get_IsGenericParameter",
1634 )
1635 });
1636 let __inner: extern "C" fn(RuntimeType, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
1637 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1638 __inner(__receiver, __mi)
1639 }
1640 }
1641 }
1642 #[doc = "`get_GenericParameterPosition()` overload"]
1643 fn get_generic_parameter_position(self) -> i32 {
1644 unsafe {
1645 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1646 {
1647 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1648 let __vi = *__vt.get(87usize).unwrap_or_else(|| {
1649 panic!(
1650 "unity: virtual slot {}
1651 out of range (vtable len {}
1652) on the runtime class behind {}
1653 (method `{}
1654`)",
1655 87usize,
1656 __vt.len(),
1657 <RuntimeType as ::unity::ClassIdentity>::NAME,
1658 "get_GenericParameterPosition",
1659 )
1660 });
1661 let __inner: extern "C" fn(RuntimeType, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__vi.method_ptr);
1662 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1663 __inner(__receiver, __mi)
1664 }
1665 }
1666 }
1667 #[doc = "`GetGenericTypeDefinition()` overload"]
1668 fn get_generic_type_definition(self) -> ::unity::SystemType {
1669 unsafe {
1670 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1671 {
1672 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1673 let __vi = *__vt.get(109usize).unwrap_or_else(|| {
1674 panic!(
1675 "unity: virtual slot {}
1676 out of range (vtable len {}
1677) on the runtime class behind {}
1678 (method `{}
1679`)",
1680 109usize,
1681 __vt.len(),
1682 <RuntimeType as ::unity::ClassIdentity>::NAME,
1683 "GetGenericTypeDefinition",
1684 )
1685 });
1686 let __inner: extern "C" fn(RuntimeType, ::unity::OptionalMethod) -> ::unity::SystemType = ::core::mem::transmute(__vi.method_ptr);
1687 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1688 __inner(__receiver, __mi)
1689 }
1690 }
1691 }
1692 #[doc = "`get_IsGenericType()` overload"]
1693 fn get_is_generic_type(self) -> bool {
1694 unsafe {
1695 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1696 {
1697 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1698 let __vi = *__vt.get(83usize).unwrap_or_else(|| {
1699 panic!(
1700 "unity: virtual slot {}
1701 out of range (vtable len {}
1702) on the runtime class behind {}
1703 (method `{}
1704`)",
1705 83usize,
1706 __vt.len(),
1707 <RuntimeType as ::unity::ClassIdentity>::NAME,
1708 "get_IsGenericType",
1709 )
1710 });
1711 let __inner: extern "C" fn(RuntimeType, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
1712 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1713 __inner(__receiver, __mi)
1714 }
1715 }
1716 }
1717 #[doc = "`get_IsConstructedGenericType()` overload"]
1718 fn get_is_constructed_generic_type(self) -> bool {
1719 unsafe {
1720 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1721 {
1722 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1723 let __vi = *__vt.get(85usize).unwrap_or_else(|| {
1724 panic!(
1725 "unity: virtual slot {}
1726 out of range (vtable len {}
1727) on the runtime class behind {}
1728 (method `{}
1729`)",
1730 85usize,
1731 __vt.len(),
1732 <RuntimeType as ::unity::ClassIdentity>::NAME,
1733 "get_IsConstructedGenericType",
1734 )
1735 });
1736 let __inner: extern "C" fn(RuntimeType, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
1737 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1738 __inner(__receiver, __mi)
1739 }
1740 }
1741 }
1742 #[doc = "`Equals(crate::system::object::Object)` overload"]
1743 fn equals(self, obj: impl ::core::convert::Into<crate::system::object::Object>) -> bool {
1744 unsafe {
1745 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1746 {
1747 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1748 let __vi = *__vt.get(0usize).unwrap_or_else(|| {
1749 panic!(
1750 "unity: virtual slot {}
1751 out of range (vtable len {}
1752) on the runtime class behind {}
1753 (method `{}
1754`)",
1755 0usize,
1756 __vt.len(),
1757 <RuntimeType as ::unity::ClassIdentity>::NAME,
1758 "Equals",
1759 )
1760 });
1761 let __inner: extern "C" fn(RuntimeType, crate::system::object::Object, ::unity::OptionalMethod) -> bool =
1762 ::core::mem::transmute(__vi.method_ptr);
1763 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1764 __inner(__receiver, ::core::convert::Into::into(obj), __mi)
1765 }
1766 }
1767 }
1768 #[doc = "`Clone()` overload"]
1769 fn clone(self) -> crate::system::object::Object {
1770 unsafe {
1771 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1772 {
1773 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1774 let __vi = *__vt.get(128usize).unwrap_or_else(|| {
1775 panic!(
1776 "unity: virtual slot {}
1777 out of range (vtable len {}
1778) on the runtime class behind {}
1779 (method `{}
1780`)",
1781 128usize,
1782 __vt.len(),
1783 <RuntimeType as ::unity::ClassIdentity>::NAME,
1784 "Clone",
1785 )
1786 });
1787 let __inner: extern "C" fn(RuntimeType, ::unity::OptionalMethod) -> crate::system::object::Object =
1788 ::core::mem::transmute(__vi.method_ptr);
1789 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1790 __inner(__receiver, __mi)
1791 }
1792 }
1793 }
1794 #[doc = "`GetCustomAttributes(bool)` overload"]
1795 fn get_custom_attributes(self, inherit: impl ::core::convert::Into<bool>) -> ::unity::Array<crate::system::object::Object> {
1796 unsafe {
1797 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1798 {
1799 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1800 let __vi = *__vt.get(10usize).unwrap_or_else(|| {
1801 panic!(
1802 "unity: virtual slot {}
1803 out of range (vtable len {}
1804) on the runtime class behind {}
1805 (method `{}
1806`)",
1807 10usize,
1808 __vt.len(),
1809 <RuntimeType as ::unity::ClassIdentity>::NAME,
1810 "GetCustomAttributes",
1811 )
1812 });
1813 let __inner: extern "C" fn(RuntimeType, bool, ::unity::OptionalMethod) -> ::unity::Array<crate::system::object::Object> =
1814 ::core::mem::transmute(__vi.method_ptr);
1815 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1816 __inner(__receiver, ::core::convert::Into::into(inherit), __mi)
1817 }
1818 }
1819 }
1820 #[doc = "`GetCustomAttributes(::unity::SystemType, bool)` overload"]
1821 fn get_custom_attributes_2(
1822 self,
1823 attribute_type: impl ::core::convert::Into<::unity::SystemType>,
1824 inherit: impl ::core::convert::Into<bool>,
1825 ) -> ::unity::Array<crate::system::object::Object> {
1826 unsafe {
1827 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1828 {
1829 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1830 let __vi = *__vt.get(11usize).unwrap_or_else(|| {
1831 panic!(
1832 "unity: virtual slot {}
1833 out of range (vtable len {}
1834) on the runtime class behind {}
1835 (method `{}
1836`)",
1837 11usize,
1838 __vt.len(),
1839 <RuntimeType as ::unity::ClassIdentity>::NAME,
1840 "GetCustomAttributes",
1841 )
1842 });
1843 let __inner: extern "C" fn(
1844 RuntimeType,
1845 ::unity::SystemType,
1846 bool,
1847 ::unity::OptionalMethod,
1848 ) -> ::unity::Array<crate::system::object::Object> = ::core::mem::transmute(__vi.method_ptr);
1849 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1850 __inner(
1851 __receiver,
1852 ::core::convert::Into::into(attribute_type),
1853 ::core::convert::Into::into(inherit),
1854 __mi,
1855 )
1856 }
1857 }
1858 }
1859 #[doc = "`IsDefined(::unity::SystemType, bool)` overload"]
1860 fn is_defined(self, attribute_type: impl ::core::convert::Into<::unity::SystemType>, inherit: impl ::core::convert::Into<bool>) -> bool {
1861 unsafe {
1862 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1863 {
1864 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1865 let __vi = *__vt.get(12usize).unwrap_or_else(|| {
1866 panic!(
1867 "unity: virtual slot {}
1868 out of range (vtable len {}
1869) on the runtime class behind {}
1870 (method `{}
1871`)",
1872 12usize,
1873 __vt.len(),
1874 <RuntimeType as ::unity::ClassIdentity>::NAME,
1875 "IsDefined",
1876 )
1877 });
1878 let __inner: extern "C" fn(RuntimeType, ::unity::SystemType, bool, ::unity::OptionalMethod) -> bool =
1879 ::core::mem::transmute(__vi.method_ptr);
1880 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1881 __inner(
1882 __receiver,
1883 ::core::convert::Into::into(attribute_type),
1884 ::core::convert::Into::into(inherit),
1885 __mi,
1886 )
1887 }
1888 }
1889 }
1890 #[doc = "`GetCustomAttributesData()` overload"]
1891 fn get_custom_attributes_data(
1892 self,
1893 ) -> crate::system::collections::generic::ilist_1_interface::IList_1_Interface<crate::system::reflection::customattributedata::CustomAttributeData>
1894 {
1895 unsafe {
1896 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1897 {
1898 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1899 let __vi = *__vt.get(13usize).unwrap_or_else(|| {
1900 panic!(
1901 "unity: virtual slot {}
1902 out of range (vtable len {}
1903) on the runtime class behind {}
1904 (method `{}
1905`)",
1906 13usize,
1907 __vt.len(),
1908 <RuntimeType as ::unity::ClassIdentity>::NAME,
1909 "GetCustomAttributesData",
1910 )
1911 });
1912 let __inner: extern "C" fn(
1913 RuntimeType,
1914 ::unity::OptionalMethod,
1915 ) -> crate::system::collections::generic::ilist_1_interface::IList_1_Interface<
1916 crate::system::reflection::customattributedata::CustomAttributeData,
1917 > = ::core::mem::transmute(__vi.method_ptr);
1918 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1919 __inner(__receiver, __mi)
1920 }
1921 }
1922 }
1923 #[doc = "`FormatTypeName(bool)` overload"]
1924 fn format_type_name(self, serialization: impl ::core::convert::Into<bool>) -> ::unity::Il2CppString {
1925 unsafe {
1926 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1927 {
1928 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1929 let __vi = *__vt.get(121usize).unwrap_or_else(|| {
1930 panic!(
1931 "unity: virtual slot {}
1932 out of range (vtable len {}
1933) on the runtime class behind {}
1934 (method `{}
1935`)",
1936 121usize,
1937 __vt.len(),
1938 <RuntimeType as ::unity::ClassIdentity>::NAME,
1939 "FormatTypeName",
1940 )
1941 });
1942 let __inner: extern "C" fn(RuntimeType, bool, ::unity::OptionalMethod) -> ::unity::Il2CppString =
1943 ::core::mem::transmute(__vi.method_ptr);
1944 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1945 __inner(__receiver, ::core::convert::Into::into(serialization), __mi)
1946 }
1947 }
1948 }
1949 #[doc = "`get_MemberType()` overload"]
1950 fn get_member_type(self) -> crate::system::reflection::membertypes::MemberTypes {
1951 unsafe {
1952 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1953 {
1954 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1955 let __vi = *__vt.get(6usize).unwrap_or_else(|| {
1956 panic!(
1957 "unity: virtual slot {}
1958 out of range (vtable len {}
1959) on the runtime class behind {}
1960 (method `{}
1961`)",
1962 6usize,
1963 __vt.len(),
1964 <RuntimeType as ::unity::ClassIdentity>::NAME,
1965 "get_MemberType",
1966 )
1967 });
1968 let __inner: extern "C" fn(RuntimeType, ::unity::OptionalMethod) -> crate::system::reflection::membertypes::MemberTypes =
1969 ::core::mem::transmute(__vi.method_ptr);
1970 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1971 __inner(__receiver, __mi)
1972 }
1973 }
1974 }
1975 #[doc = "`get_ReflectedType()` overload"]
1976 fn get_reflected_type(self) -> ::unity::SystemType {
1977 unsafe {
1978 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1979 {
1980 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1981 let __vi = *__vt.get(9usize).unwrap_or_else(|| {
1982 panic!(
1983 "unity: virtual slot {}
1984 out of range (vtable len {}
1985) on the runtime class behind {}
1986 (method `{}
1987`)",
1988 9usize,
1989 __vt.len(),
1990 <RuntimeType as ::unity::ClassIdentity>::NAME,
1991 "get_ReflectedType",
1992 )
1993 });
1994 let __inner: extern "C" fn(RuntimeType, ::unity::OptionalMethod) -> ::unity::SystemType = ::core::mem::transmute(__vi.method_ptr);
1995 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1996 __inner(__receiver, __mi)
1997 }
1998 }
1999 }
2000 #[doc = "`get_MetadataToken()` overload"]
2001 fn get_metadata_token(self) -> i32 {
2002 unsafe {
2003 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2004 {
2005 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2006 let __vi = *__vt.get(14usize).unwrap_or_else(|| {
2007 panic!(
2008 "unity: virtual slot {}
2009 out of range (vtable len {}
2010) on the runtime class behind {}
2011 (method `{}
2012`)",
2013 14usize,
2014 __vt.len(),
2015 <RuntimeType as ::unity::ClassIdentity>::NAME,
2016 "get_MetadataToken",
2017 )
2018 });
2019 let __inner: extern "C" fn(RuntimeType, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__vi.method_ptr);
2020 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2021 __inner(__receiver, __mi)
2022 }
2023 }
2024 }
2025 #[doc = "`CreateInstanceCheckThis()` overload"]
2026 fn create_instance_check_this(self) -> () {
2027 unsafe {
2028 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2029 ::unity::il2cpp_call!((::unity::module_base()+0x2fdfc50usize)as*mut u8,();
2030(RuntimeType)__receiver)
2031 }
2032 }
2033 #[doc = "`GetDefaultConstructor()` overload"]
2034 fn get_default_constructor(self) -> crate::system::reflection::monocmethod::MonoCMethod {
2035 unsafe {
2036 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2037 ::unity::il2cpp_call!((::unity::module_base()+0x2fe09f0usize)as*mut u8,crate::system::reflection::monocmethod::MonoCMethod;
2038(RuntimeType)__receiver)
2039 }
2040 }
2041 #[doc = "`GetDefaultMemberName()` overload"]
2042 fn get_default_member_name(self) -> ::unity::Il2CppString {
2043 unsafe {
2044 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2045 ::unity::il2cpp_call!((::unity::module_base()+0x2fdf430usize)as*mut u8, ::unity::Il2CppString;
2046(RuntimeType)__receiver)
2047 }
2048 }
2049 #[doc = "`GetSerializationCtor()` overload"]
2050 fn get_serialization_ctor(self) -> crate::system::reflection::runtimeconstructorinfo::RuntimeConstructorInfo {
2051 unsafe {
2052 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2053 ::unity::il2cpp_call!((::unity::module_base()+0x2fe0bc0usize)as*mut u8,crate::system::reflection::runtimeconstructorinfo::RuntimeConstructorInfo;
2054(RuntimeType)__receiver)
2055 }
2056 }
2057 #[doc = "`CreateInstanceMono(bool)` overload"]
2058 fn create_instance_mono(self, non_public: impl ::core::convert::Into<bool>) -> crate::system::object::Object {
2059 unsafe {
2060 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2061 ::unity::il2cpp_call!((::unity::module_base()+0x2fe0de0usize)as*mut u8,crate::system::object::Object;
2062(RuntimeType)__receiver,(bool)::core::convert::Into::into(non_public))
2063 }
2064 }
2065 #[doc = "`TryConvertToType(crate::system::object::Object, *mutbool)` overload"]
2066 fn try_convert_to_type(self, value: impl ::core::convert::Into<crate::system::object::Object>) -> (crate::system::object::Object, bool) {
2067 unsafe {
2068 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2069 let mut __out_0 = ::core::mem::MaybeUninit::<bool>::uninit();
2070 let __ret = {
2071 ::unity::il2cpp_call!((::unity::module_base()+0x2fe1280usize)as*mut u8,crate::system::object::Object;
2072(RuntimeType)__receiver,(crate::system::object::Object)::core::convert::Into::into(value),(*mut bool)__out_0.as_mut_ptr())
2073 };
2074 (__ret, __out_0.assume_init())
2075 }
2076 }
2077 #[doc = "`make_array_type(i32)` overload"]
2078 fn make_array_type(self, rank: impl ::core::convert::Into<i32>) -> ::unity::SystemType {
2079 unsafe {
2080 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2081 ::unity::il2cpp_call!((::unity::module_base()+0x2fe2050usize)as*mut u8, ::unity::SystemType;
2082(RuntimeType)__receiver,(i32)::core::convert::Into::into(rank))
2083 }
2084 }
2085 #[doc = "`MakeArrayType()` overload"]
2086 fn make_array_type_2(self) -> ::unity::SystemType {
2087 unsafe {
2088 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2089 {
2090 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2091 let __vi = *__vt.get(19usize).unwrap_or_else(|| {
2092 panic!(
2093 "unity: virtual slot {}
2094 out of range (vtable len {}
2095) on the runtime class behind {}
2096 (method `{}
2097`)",
2098 19usize,
2099 __vt.len(),
2100 <RuntimeType as ::unity::ClassIdentity>::NAME,
2101 "MakeArrayType",
2102 )
2103 });
2104 let __inner: extern "C" fn(RuntimeType, ::unity::OptionalMethod) -> ::unity::SystemType = ::core::mem::transmute(__vi.method_ptr);
2105 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2106 __inner(__receiver, __mi)
2107 }
2108 }
2109 }
2110 #[doc = "`make_byref_type()` overload"]
2111 fn make_byref_type(self) -> ::unity::SystemType {
2112 unsafe {
2113 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2114 ::unity::il2cpp_call!((::unity::module_base()+0x2fe20c0usize)as*mut u8, ::unity::SystemType;
2115(RuntimeType)__receiver)
2116 }
2117 }
2118 #[doc = "`MakeByRefType()` overload"]
2119 fn make_by_ref_type(self) -> ::unity::SystemType {
2120 unsafe {
2121 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2122 {
2123 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2124 let __vi = *__vt.get(18usize).unwrap_or_else(|| {
2125 panic!(
2126 "unity: virtual slot {}
2127 out of range (vtable len {}
2128) on the runtime class behind {}
2129 (method `{}
2130`)",
2131 18usize,
2132 __vt.len(),
2133 <RuntimeType as ::unity::ClassIdentity>::NAME,
2134 "MakeByRefType",
2135 )
2136 });
2137 let __inner: extern "C" fn(RuntimeType, ::unity::OptionalMethod) -> ::unity::SystemType = ::core::mem::transmute(__vi.method_ptr);
2138 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2139 __inner(__receiver, __mi)
2140 }
2141 }
2142 }
2143 #[doc = "`MakePointerType()` overload"]
2144 fn make_pointer_type_2(self) -> ::unity::SystemType {
2145 unsafe {
2146 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2147 {
2148 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2149 let __vi = *__vt.get(17usize).unwrap_or_else(|| {
2150 panic!(
2151 "unity: virtual slot {}
2152 out of range (vtable len {}
2153) on the runtime class behind {}
2154 (method `{}
2155`)",
2156 17usize,
2157 __vt.len(),
2158 <RuntimeType as ::unity::ClassIdentity>::NAME,
2159 "MakePointerType",
2160 )
2161 });
2162 let __inner: extern "C" fn(RuntimeType, ::unity::OptionalMethod) -> ::unity::SystemType = ::core::mem::transmute(__vi.method_ptr);
2163 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2164 __inner(__receiver, __mi)
2165 }
2166 }
2167 }
2168 #[doc = "`get_ContainsGenericParameters()` overload"]
2169 fn get_contains_generic_parameters(self) -> bool {
2170 unsafe {
2171 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2172 {
2173 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2174 let __vi = *__vt.get(88usize).unwrap_or_else(|| {
2175 panic!(
2176 "unity: virtual slot {}
2177 out of range (vtable len {}
2178) on the runtime class behind {}
2179 (method `{}
2180`)",
2181 88usize,
2182 __vt.len(),
2183 <RuntimeType as ::unity::ClassIdentity>::NAME,
2184 "get_ContainsGenericParameters",
2185 )
2186 });
2187 let __inner: extern "C" fn(RuntimeType, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
2188 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2189 __inner(__receiver, __mi)
2190 }
2191 }
2192 }
2193 #[doc = "`GetGenericParameterConstraints()` overload"]
2194 fn get_generic_parameter_constraints(self) -> ::unity::Array<::unity::SystemType> {
2195 unsafe {
2196 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2197 {
2198 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2199 let __vi = *__vt.get(89usize).unwrap_or_else(|| {
2200 panic!(
2201 "unity: virtual slot {}
2202 out of range (vtable len {}
2203) on the runtime class behind {}
2204 (method `{}
2205`)",
2206 89usize,
2207 __vt.len(),
2208 <RuntimeType as ::unity::ClassIdentity>::NAME,
2209 "GetGenericParameterConstraints",
2210 )
2211 });
2212 let __inner: extern "C" fn(RuntimeType, ::unity::OptionalMethod) -> ::unity::Array<::unity::SystemType> =
2213 ::core::mem::transmute(__vi.method_ptr);
2214 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2215 __inner(__receiver, __mi)
2216 }
2217 }
2218 }
2219 #[doc = "`GetMethodsByName_native(::unity::IntPtr, crate::system::reflection::bindingflags::BindingFlags, bool)` overload"]
2220 fn get_methods_by_name_native(
2221 self,
2222 name_ptr: impl ::core::convert::Into<::unity::IntPtr>,
2223 binding_attr: impl ::core::convert::Into<crate::system::reflection::bindingflags::BindingFlags>,
2224 ignore_case: impl ::core::convert::Into<bool>,
2225 ) -> ::unity::IntPtr {
2226 unsafe {
2227 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2228 ::unity::il2cpp_call!((::unity::module_base()+0x2fe2540usize)as*mut u8, ::unity::IntPtr;
2229(RuntimeType)__receiver,(::unity::IntPtr)::core::convert::Into::into(name_ptr),(crate::system::reflection::bindingflags::BindingFlags)::core::convert::Into::into(binding_attr),(bool)::core::convert::Into::into(ignore_case))
2230 }
2231 }
2232 #[doc = "`GetMethodsByName(::unity::Il2CppString, crate::system::reflection::bindingflags::BindingFlags, bool, crate::system::runtimetype::RuntimeType)` overload"]
2233 fn get_methods_by_name(
2234 self,
2235 name: impl ::core::convert::Into<::unity::Il2CppString>,
2236 binding_attr: impl ::core::convert::Into<crate::system::reflection::bindingflags::BindingFlags>,
2237 ignore_case: impl ::core::convert::Into<bool>,
2238 reflected_type: impl ::core::convert::Into<crate::system::runtimetype::RuntimeType>,
2239 ) -> ::unity::Array<crate::system::reflection::runtimemethodinfo::RuntimeMethodInfo> {
2240 unsafe {
2241 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2242 ::unity::il2cpp_call!((::unity::module_base()+0x2fd9000usize)as*mut u8, ::unity::Array<crate::system::reflection::runtimemethodinfo::RuntimeMethodInfo> ;
2243(RuntimeType)__receiver,(::unity::Il2CppString)::core::convert::Into::into(name),(crate::system::reflection::bindingflags::BindingFlags)::core::convert::Into::into(binding_attr),(bool)::core::convert::Into::into(ignore_case),(crate::system::runtimetype::RuntimeType)::core::convert::Into::into(reflected_type))
2244 }
2245 }
2246 #[doc = "`GetPropertiesByName_native(::unity::IntPtr, crate::system::reflection::bindingflags::BindingFlags, bool)` overload"]
2247 fn get_properties_by_name_native(
2248 self,
2249 name: impl ::core::convert::Into<::unity::IntPtr>,
2250 binding_attr: impl ::core::convert::Into<crate::system::reflection::bindingflags::BindingFlags>,
2251 icase: impl ::core::convert::Into<bool>,
2252 ) -> ::unity::IntPtr {
2253 unsafe {
2254 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2255 ::unity::il2cpp_call!((::unity::module_base()+0x2fe2550usize)as*mut u8, ::unity::IntPtr;
2256(RuntimeType)__receiver,(::unity::IntPtr)::core::convert::Into::into(name),(crate::system::reflection::bindingflags::BindingFlags)::core::convert::Into::into(binding_attr),(bool)::core::convert::Into::into(icase))
2257 }
2258 }
2259 #[doc = "`GetConstructors_native(crate::system::reflection::bindingflags::BindingFlags)` overload"]
2260 fn get_constructors_native(
2261 self,
2262 binding_attr: impl ::core::convert::Into<crate::system::reflection::bindingflags::BindingFlags>,
2263 ) -> ::unity::IntPtr {
2264 unsafe {
2265 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2266 ::unity::il2cpp_call!((::unity::module_base()+0x2fe2560usize)as*mut u8, ::unity::IntPtr;
2267(RuntimeType)__receiver,(crate::system::reflection::bindingflags::BindingFlags)::core::convert::Into::into(binding_attr))
2268 }
2269 }
2270 #[doc = "`GetConstructors_internal(crate::system::reflection::bindingflags::BindingFlags, crate::system::runtimetype::RuntimeType)` overload"]
2271 fn get_constructors_internal(
2272 self,
2273 binding_attr: impl ::core::convert::Into<crate::system::reflection::bindingflags::BindingFlags>,
2274 reflected_type: impl ::core::convert::Into<crate::system::runtimetype::RuntimeType>,
2275 ) -> ::unity::Array<crate::system::reflection::runtimeconstructorinfo::RuntimeConstructorInfo> {
2276 unsafe {
2277 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2278 ::unity::il2cpp_call!((::unity::module_base()+0x2fd96a0usize)as*mut u8, ::unity::Array<crate::system::reflection::runtimeconstructorinfo::RuntimeConstructorInfo> ;
2279(RuntimeType)__receiver,(crate::system::reflection::bindingflags::BindingFlags)::core::convert::Into::into(binding_attr),(crate::system::runtimetype::RuntimeType)::core::convert::Into::into(reflected_type))
2280 }
2281 }
2282 #[doc = "`GetPropertiesByName(::unity::Il2CppString, crate::system::reflection::bindingflags::BindingFlags, bool, crate::system::runtimetype::RuntimeType)` overload"]
2283 fn get_properties_by_name(
2284 self,
2285 name: impl ::core::convert::Into<::unity::Il2CppString>,
2286 binding_attr: impl ::core::convert::Into<crate::system::reflection::bindingflags::BindingFlags>,
2287 icase: impl ::core::convert::Into<bool>,
2288 reflected_type: impl ::core::convert::Into<crate::system::runtimetype::RuntimeType>,
2289 ) -> ::unity::Array<crate::system::reflection::runtimepropertyinfo::RuntimePropertyInfo> {
2290 unsafe {
2291 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2292 ::unity::il2cpp_call!((::unity::module_base()+0x2fd9b50usize)as*mut u8, ::unity::Array<crate::system::reflection::runtimepropertyinfo::RuntimePropertyInfo> ;
2293(RuntimeType)__receiver,(::unity::Il2CppString)::core::convert::Into::into(name),(crate::system::reflection::bindingflags::BindingFlags)::core::convert::Into::into(binding_attr),(bool)::core::convert::Into::into(icase),(crate::system::runtimetype::RuntimeType)::core::convert::Into::into(reflected_type))
2294 }
2295 }
2296 #[doc = "`ToString()` overload"]
2297 fn to_string(self) -> ::unity::Il2CppString {
2298 unsafe {
2299 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2300 {
2301 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2302 let __vi = *__vt.get(3usize).unwrap_or_else(|| {
2303 panic!(
2304 "unity: virtual slot {}
2305 out of range (vtable len {}
2306) on the runtime class behind {}
2307 (method `{}
2308`)",
2309 3usize,
2310 __vt.len(),
2311 <RuntimeType as ::unity::ClassIdentity>::NAME,
2312 "ToString",
2313 )
2314 });
2315 let __inner: extern "C" fn(RuntimeType, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__vi.method_ptr);
2316 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2317 __inner(__receiver, __mi)
2318 }
2319 }
2320 }
2321 #[doc = "`IsGenericCOMObjectImpl()` overload"]
2322 fn is_generic_com_object_impl(self) -> bool {
2323 unsafe {
2324 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2325 ::unity::il2cpp_call!((::unity::module_base()+0x2fe0870usize)as*mut u8,bool;
2326(RuntimeType)__receiver)
2327 }
2328 }
2329 #[doc = "`get_DeclaringMethod()` overload"]
2330 fn get_declaring_method(self) -> crate::system::reflection::methodbase::MethodBase {
2331 unsafe {
2332 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2333 {
2334 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2335 let __vi = *__vt.get(16usize).unwrap_or_else(|| {
2336 panic!(
2337 "unity: virtual slot {}
2338 out of range (vtable len {}
2339) on the runtime class behind {}
2340 (method `{}
2341`)",
2342 16usize,
2343 __vt.len(),
2344 <RuntimeType as ::unity::ClassIdentity>::NAME,
2345 "get_DeclaringMethod",
2346 )
2347 });
2348 let __inner: extern "C" fn(RuntimeType, ::unity::OptionalMethod) -> crate::system::reflection::methodbase::MethodBase =
2349 ::core::mem::transmute(__vi.method_ptr);
2350 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2351 __inner(__receiver, __mi)
2352 }
2353 }
2354 }
2355 #[doc = "`getFullName(bool, bool)` overload"]
2356 fn get_full_name(
2357 self,
2358 full_name: impl ::core::convert::Into<bool>,
2359 assembly_qualified: impl ::core::convert::Into<bool>,
2360 ) -> ::unity::Il2CppString {
2361 unsafe {
2362 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2363 ::unity::il2cpp_call!((::unity::module_base()+0x2fe27b0usize)as*mut u8, ::unity::Il2CppString;
2364(RuntimeType)__receiver,(bool)::core::convert::Into::into(full_name),(bool)::core::convert::Into::into(assembly_qualified))
2365 }
2366 }
2367 #[doc = "`GetGenericArgumentsInternal(bool)` overload"]
2368 fn get_generic_arguments_internal_2(self, runtime_array: impl ::core::convert::Into<bool>) -> ::unity::Array<::unity::SystemType> {
2369 unsafe {
2370 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2371 ::unity::il2cpp_call!((::unity::module_base()+0x2fddc10usize)as*mut u8, ::unity::Array< ::unity::SystemType> ;
2372(RuntimeType)__receiver,(bool)::core::convert::Into::into(runtime_array))
2373 }
2374 }
2375 #[doc = "`GetEvents_native(::unity::IntPtr, crate::system::reflection::bindingflags::BindingFlags)` overload"]
2376 fn get_events_native(
2377 self,
2378 name: impl ::core::convert::Into<::unity::IntPtr>,
2379 binding_attr: impl ::core::convert::Into<crate::system::reflection::bindingflags::BindingFlags>,
2380 ) -> ::unity::IntPtr {
2381 unsafe {
2382 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2383 ::unity::il2cpp_call!((::unity::module_base()+0x2fe27d0usize)as*mut u8, ::unity::IntPtr;
2384(RuntimeType)__receiver,(::unity::IntPtr)::core::convert::Into::into(name),(crate::system::reflection::bindingflags::BindingFlags)::core::convert::Into::into(binding_attr))
2385 }
2386 }
2387 #[doc = "`GetFields_native(::unity::IntPtr, crate::system::reflection::bindingflags::BindingFlags)` overload"]
2388 fn get_fields_native(
2389 self,
2390 name: impl ::core::convert::Into<::unity::IntPtr>,
2391 binding_attr: impl ::core::convert::Into<crate::system::reflection::bindingflags::BindingFlags>,
2392 ) -> ::unity::IntPtr {
2393 unsafe {
2394 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2395 ::unity::il2cpp_call!((::unity::module_base()+0x2fe27e0usize)as*mut u8, ::unity::IntPtr;
2396(RuntimeType)__receiver,(::unity::IntPtr)::core::convert::Into::into(name),(crate::system::reflection::bindingflags::BindingFlags)::core::convert::Into::into(binding_attr))
2397 }
2398 }
2399 #[doc = "`GetFields_internal(::unity::Il2CppString, crate::system::reflection::bindingflags::BindingFlags, crate::system::runtimetype::RuntimeType)` overload"]
2400 fn get_fields_internal(
2401 self,
2402 name: impl ::core::convert::Into<::unity::Il2CppString>,
2403 binding_attr: impl ::core::convert::Into<crate::system::reflection::bindingflags::BindingFlags>,
2404 reflected_type: impl ::core::convert::Into<crate::system::runtimetype::RuntimeType>,
2405 ) -> ::unity::Array<crate::system::reflection::runtimefieldinfo::RuntimeFieldInfo> {
2406 unsafe {
2407 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2408 ::unity::il2cpp_call!((::unity::module_base()+0x2fda620usize)as*mut u8, ::unity::Array<crate::system::reflection::runtimefieldinfo::RuntimeFieldInfo> ;
2409(RuntimeType)__receiver,(::unity::Il2CppString)::core::convert::Into::into(name),(crate::system::reflection::bindingflags::BindingFlags)::core::convert::Into::into(binding_attr),(crate::system::runtimetype::RuntimeType)::core::convert::Into::into(reflected_type))
2410 }
2411 }
2412 #[doc = "`GetEvents_internal(::unity::Il2CppString, crate::system::reflection::bindingflags::BindingFlags, crate::system::runtimetype::RuntimeType)` overload"]
2413 fn get_events_internal(
2414 self,
2415 name: impl ::core::convert::Into<::unity::Il2CppString>,
2416 binding_attr: impl ::core::convert::Into<crate::system::reflection::bindingflags::BindingFlags>,
2417 reflected_type: impl ::core::convert::Into<crate::system::runtimetype::RuntimeType>,
2418 ) -> ::unity::Array<crate::system::reflection::runtimeeventinfo::RuntimeEventInfo> {
2419 unsafe {
2420 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2421 ::unity::il2cpp_call!((::unity::module_base()+0x2fda0c0usize)as*mut u8, ::unity::Array<crate::system::reflection::runtimeeventinfo::RuntimeEventInfo> ;
2422(RuntimeType)__receiver,(::unity::Il2CppString)::core::convert::Into::into(name),(crate::system::reflection::bindingflags::BindingFlags)::core::convert::Into::into(binding_attr),(crate::system::runtimetype::RuntimeType)::core::convert::Into::into(reflected_type))
2423 }
2424 }
2425 #[doc = "`GetInterfaces()` overload"]
2426 fn get_interfaces(self) -> ::unity::Array<::unity::SystemType> {
2427 unsafe {
2428 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2429 {
2430 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2431 let __vi = *__vt.get(48usize).unwrap_or_else(|| {
2432 panic!(
2433 "unity: virtual slot {}
2434 out of range (vtable len {}
2435) on the runtime class behind {}
2436 (method `{}
2437`)",
2438 48usize,
2439 __vt.len(),
2440 <RuntimeType as ::unity::ClassIdentity>::NAME,
2441 "GetInterfaces",
2442 )
2443 });
2444 let __inner: extern "C" fn(RuntimeType, ::unity::OptionalMethod) -> ::unity::Array<::unity::SystemType> =
2445 ::core::mem::transmute(__vi.method_ptr);
2446 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2447 __inner(__receiver, __mi)
2448 }
2449 }
2450 }
2451 #[doc = "`GetNestedTypes_native(::unity::IntPtr, crate::system::reflection::bindingflags::BindingFlags)` overload"]
2452 fn get_nested_types_native(
2453 self,
2454 name: impl ::core::convert::Into<::unity::IntPtr>,
2455 binding_attr: impl ::core::convert::Into<crate::system::reflection::bindingflags::BindingFlags>,
2456 ) -> ::unity::IntPtr {
2457 unsafe {
2458 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2459 ::unity::il2cpp_call!((::unity::module_base()+0x2fe2800usize)as*mut u8, ::unity::IntPtr;
2460(RuntimeType)__receiver,(::unity::IntPtr)::core::convert::Into::into(name),(crate::system::reflection::bindingflags::BindingFlags)::core::convert::Into::into(binding_attr))
2461 }
2462 }
2463 #[doc = "`GetNestedTypes_internal(::unity::Il2CppString, crate::system::reflection::bindingflags::BindingFlags)` overload"]
2464 fn get_nested_types_internal(
2465 self,
2466 display_name: impl ::core::convert::Into<::unity::Il2CppString>,
2467 binding_attr: impl ::core::convert::Into<crate::system::reflection::bindingflags::BindingFlags>,
2468 ) -> ::unity::Array<crate::system::runtimetype::RuntimeType> {
2469 unsafe {
2470 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2471 ::unity::il2cpp_call!((::unity::module_base()+0x2fdaad0usize)as*mut u8, ::unity::Array<crate::system::runtimetype::RuntimeType> ;
2472(RuntimeType)__receiver,(::unity::Il2CppString)::core::convert::Into::into(display_name),(crate::system::reflection::bindingflags::BindingFlags)::core::convert::Into::into(binding_attr))
2473 }
2474 }
2475 #[doc = "`get_AssemblyQualifiedName()` overload"]
2476 fn get_assembly_qualified_name(self) -> ::unity::Il2CppString {
2477 unsafe {
2478 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2479 {
2480 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2481 let __vi = *__vt.get(29usize).unwrap_or_else(|| {
2482 panic!(
2483 "unity: virtual slot {}
2484 out of range (vtable len {}
2485) on the runtime class behind {}
2486 (method `{}
2487`)",
2488 29usize,
2489 __vt.len(),
2490 <RuntimeType as ::unity::ClassIdentity>::NAME,
2491 "get_AssemblyQualifiedName",
2492 )
2493 });
2494 let __inner: extern "C" fn(RuntimeType, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__vi.method_ptr);
2495 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2496 __inner(__receiver, __mi)
2497 }
2498 }
2499 }
2500 #[doc = "`get_DeclaringType()` overload"]
2501 fn get_declaring_type(self) -> ::unity::SystemType {
2502 unsafe {
2503 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2504 {
2505 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2506 let __vi = *__vt.get(8usize).unwrap_or_else(|| {
2507 panic!(
2508 "unity: virtual slot {}
2509 out of range (vtable len {}
2510) on the runtime class behind {}
2511 (method `{}
2512`)",
2513 8usize,
2514 __vt.len(),
2515 <RuntimeType as ::unity::ClassIdentity>::NAME,
2516 "get_DeclaringType",
2517 )
2518 });
2519 let __inner: extern "C" fn(RuntimeType, ::unity::OptionalMethod) -> ::unity::SystemType = ::core::mem::transmute(__vi.method_ptr);
2520 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2521 __inner(__receiver, __mi)
2522 }
2523 }
2524 }
2525 #[doc = "`get_Name()` overload"]
2526 fn get_name(self) -> ::unity::Il2CppString {
2527 unsafe {
2528 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2529 {
2530 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2531 let __vi = *__vt.get(7usize).unwrap_or_else(|| {
2532 panic!(
2533 "unity: virtual slot {}
2534 out of range (vtable len {}
2535) on the runtime class behind {}
2536 (method `{}
2537`)",
2538 7usize,
2539 __vt.len(),
2540 <RuntimeType as ::unity::ClassIdentity>::NAME,
2541 "get_Name",
2542 )
2543 });
2544 let __inner: extern "C" fn(RuntimeType, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__vi.method_ptr);
2545 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2546 __inner(__receiver, __mi)
2547 }
2548 }
2549 }
2550 #[doc = "`get_Namespace()` overload"]
2551 fn get_namespace(self) -> ::unity::Il2CppString {
2552 unsafe {
2553 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2554 {
2555 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2556 let __vi = *__vt.get(28usize).unwrap_or_else(|| {
2557 panic!(
2558 "unity: virtual slot {}
2559 out of range (vtable len {}
2560) on the runtime class behind {}
2561 (method `{}
2562`)",
2563 28usize,
2564 __vt.len(),
2565 <RuntimeType as ::unity::ClassIdentity>::NAME,
2566 "get_Namespace",
2567 )
2568 });
2569 let __inner: extern "C" fn(RuntimeType, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__vi.method_ptr);
2570 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2571 __inner(__receiver, __mi)
2572 }
2573 }
2574 }
2575 #[doc = "`GetHashCode()` overload"]
2576 fn get_hash_code(self) -> i32 {
2577 unsafe {
2578 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2579 {
2580 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2581 let __vi = *__vt.get(2usize).unwrap_or_else(|| {
2582 panic!(
2583 "unity: virtual slot {}
2584 out of range (vtable len {}
2585) on the runtime class behind {}
2586 (method `{}
2587`)",
2588 2usize,
2589 __vt.len(),
2590 <RuntimeType as ::unity::ClassIdentity>::NAME,
2591 "GetHashCode",
2592 )
2593 });
2594 let __inner: extern "C" fn(RuntimeType, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__vi.method_ptr);
2595 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2596 __inner(__receiver, __mi)
2597 }
2598 }
2599 }
2600 #[doc = "`get_FullName()` overload"]
2601 fn get_full_name_2(self) -> ::unity::Il2CppString {
2602 unsafe {
2603 let __receiver = <RuntimeType as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2604 {
2605 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2606 let __vi = *__vt.get(27usize).unwrap_or_else(|| {
2607 panic!(
2608 "unity: virtual slot {}
2609 out of range (vtable len {}
2610) on the runtime class behind {}
2611 (method `{}
2612`)",
2613 27usize,
2614 __vt.len(),
2615 <RuntimeType as ::unity::ClassIdentity>::NAME,
2616 "get_FullName",
2617 )
2618 });
2619 let __inner: extern "C" fn(RuntimeType, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__vi.method_ptr);
2620 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2621 __inner(__receiver, __mi)
2622 }
2623 }
2624 }
2625}
2626
2627#[cfg(feature = "system-runtimetype")]
2628impl<__T: IRuntimeType> IRuntimeTypeMethods for __T {}
2629
2630#[cfg(feature = "system-runtimetype")]
2631impl RuntimeType {
2632 pub fn throw_if_type_never_valid_generic_argument_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2633 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
2634 }
2635
2636 pub fn sanity_check_generic_arguments_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2637 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
2638 }
2639
2640 pub fn split_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2641 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
2642 }
2643
2644 pub fn filter_apply_prefix_lookup_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2645 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
2646 }
2647
2648 pub fn filter_apply_base_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2649 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
2650 }
2651
2652 pub fn filter_apply_type_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2653 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
2654 }
2655
2656 pub fn filter_apply_method_info_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2657 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[8]
2658 }
2659
2660 pub fn filter_apply_constructor_info_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2661 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[9]
2662 }
2663
2664 pub fn filter_apply_method_base_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2665 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[10]
2666 }
2667
2668 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2669 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[11]
2670 }
2671
2672 pub fn is_special_serializable_type_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2673 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[12]
2674 }
2675
2676 pub fn get_methods_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2677 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[19]
2678 }
2679
2680 pub fn get_constructors_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2681 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[20]
2682 }
2683
2684 pub fn get_properties_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2685 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[21]
2686 }
2687
2688 pub fn get_events_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2689 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[22]
2690 }
2691
2692 pub fn get_fields_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2693 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[23]
2694 }
2695
2696 pub fn get_nested_types_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2697 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[24]
2698 }
2699
2700 pub fn get_method_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2701 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[25]
2702 }
2703
2704 pub fn get_constructor_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2705 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[26]
2706 }
2707
2708 pub fn get_property_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2709 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[27]
2710 }
2711
2712 pub fn get_event_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2713 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[28]
2714 }
2715
2716 pub fn get_field_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2717 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[29]
2718 }
2719
2720 pub fn get_interface_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2721 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[30]
2722 }
2723
2724 pub fn get_nested_type_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2725 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[31]
2726 }
2727
2728 pub fn get_member_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2729 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[32]
2730 }
2731
2732 pub fn get_module_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2733 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[33]
2734 }
2735
2736 pub fn get_runtime_module_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2737 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[34]
2738 }
2739
2740 pub fn get_assembly_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2741 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[35]
2742 }
2743
2744 pub fn get_runtime_assembly_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2745 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[36]
2746 }
2747
2748 pub fn is_instance_of_type_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2749 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[38]
2750 }
2751
2752 pub fn is_subclass_of_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2753 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[39]
2754 }
2755
2756 pub fn is_assignable_from_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2757 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[40]
2758 }
2759
2760 pub fn is_equivalent_to_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2761 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[41]
2762 }
2763
2764 pub fn get_base_type_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2765 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[42]
2766 }
2767
2768 pub fn get_underlying_system_type_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2769 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[44]
2770 }
2771
2772 pub fn get_attribute_flags_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2773 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[45]
2774 }
2775
2776 pub fn is_contextful_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2777 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[46]
2778 }
2779
2780 pub fn is_by_ref_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2781 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[47]
2782 }
2783
2784 pub fn is_primitive_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2785 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[48]
2786 }
2787
2788 pub fn is_pointer_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2789 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[49]
2790 }
2791
2792 pub fn is_com_object_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2793 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[50]
2794 }
2795
2796 pub fn is_value_type_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2797 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[51]
2798 }
2799
2800 pub fn get_is_enum_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2801 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[52]
2802 }
2803
2804 pub fn has_element_type_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2805 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[53]
2806 }
2807
2808 pub fn get_generic_parameter_attributes_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2809 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[54]
2810 }
2811
2812 pub fn get_is_sz_array_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2813 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[55]
2814 }
2815
2816 pub fn is_array_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2817 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[56]
2818 }
2819
2820 pub fn get_array_rank_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2821 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[57]
2822 }
2823
2824 pub fn get_element_type_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2825 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[58]
2826 }
2827
2828 pub fn get_enum_names_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2829 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[59]
2830 }
2831
2832 pub fn get_enum_values_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2833 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[60]
2834 }
2835
2836 pub fn get_enum_underlying_type_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2837 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[61]
2838 }
2839
2840 pub fn is_enum_defined_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2841 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[62]
2842 }
2843
2844 pub fn get_enum_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2845 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[63]
2846 }
2847
2848 pub fn get_generic_arguments_internal_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2849 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[64]
2850 }
2851
2852 pub fn get_generic_arguments_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2853 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[65]
2854 }
2855
2856 pub fn make_generic_type_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2857 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[66]
2858 }
2859
2860 pub fn get_is_generic_type_definition_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2861 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[67]
2862 }
2863
2864 pub fn get_is_generic_parameter_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2865 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[68]
2866 }
2867
2868 pub fn get_generic_parameter_position_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2869 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[69]
2870 }
2871
2872 pub fn get_generic_type_definition_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2873 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[70]
2874 }
2875
2876 pub fn get_is_generic_type_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2877 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[71]
2878 }
2879
2880 pub fn get_is_constructed_generic_type_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2881 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[72]
2882 }
2883
2884 pub fn equals_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2885 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[74]
2886 }
2887
2888 pub fn op_equality_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2889 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[75]
2890 }
2891
2892 pub fn op_inequality_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2893 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[76]
2894 }
2895
2896 pub fn clone_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2897 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[77]
2898 }
2899
2900 pub fn get_custom_attributes_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2901 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[79]
2902 }
2903
2904 pub fn get_custom_attributes_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2905 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[80]
2906 }
2907
2908 pub fn is_defined_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2909 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[81]
2910 }
2911
2912 pub fn get_custom_attributes_data_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2913 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[82]
2914 }
2915
2916 pub fn format_type_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2917 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[83]
2918 }
2919
2920 pub fn get_member_type_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2921 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[84]
2922 }
2923
2924 pub fn get_reflected_type_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2925 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[85]
2926 }
2927
2928 pub fn get_metadata_token_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2929 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[86]
2930 }
2931
2932 pub fn create_instance_check_this_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2933 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[87]
2934 }
2935
2936 pub fn get_default_constructor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2937 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[90]
2938 }
2939
2940 pub fn get_default_member_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2941 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[91]
2942 }
2943
2944 pub fn get_serialization_ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2945 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[92]
2946 }
2947
2948 pub fn create_instance_mono_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2949 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[94]
2950 }
2951
2952 pub fn try_convert_to_type_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2953 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[96]
2954 }
2955
2956 pub fn is_convertible_to_primitive_type_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2957 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[97]
2958 }
2959
2960 pub fn make_array_type_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2961 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[99]
2962 }
2963
2964 pub fn make_array_type_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2965 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[100]
2966 }
2967
2968 pub fn make_byref_type_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2969 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[102]
2970 }
2971
2972 pub fn make_by_ref_type_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2973 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[103]
2974 }
2975
2976 pub fn make_pointer_type_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2977 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[104]
2978 }
2979
2980 pub fn make_pointer_type_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2981 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[105]
2982 }
2983
2984 pub fn get_contains_generic_parameters_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2985 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[106]
2986 }
2987
2988 pub fn get_generic_parameter_constraints_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2989 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[107]
2990 }
2991
2992 pub fn create_instance_for_another_generic_parameter_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2993 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[108]
2994 }
2995
2996 pub fn make_generic_type_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2997 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[109]
2998 }
2999
3000 pub fn get_methods_by_name_native_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3001 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[110]
3002 }
3003
3004 pub fn get_methods_by_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3005 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[111]
3006 }
3007
3008 pub fn get_properties_by_name_native_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3009 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[112]
3010 }
3011
3012 pub fn get_constructors_native_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3013 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[113]
3014 }
3015
3016 pub fn get_constructors_internal_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3017 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[114]
3018 }
3019
3020 pub fn get_properties_by_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3021 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[115]
3022 }
3023
3024 pub fn to_string_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3025 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[120]
3026 }
3027
3028 pub fn is_generic_com_object_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3029 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[121]
3030 }
3031
3032 pub fn create_instance_internal_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3033 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[122]
3034 }
3035
3036 pub fn get_declaring_method_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3037 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[123]
3038 }
3039
3040 pub fn get_full_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3041 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[124]
3042 }
3043
3044 pub fn get_generic_arguments_internal_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3045 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[125]
3046 }
3047
3048 pub fn get_events_native_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3049 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[128]
3050 }
3051
3052 pub fn get_fields_native_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3053 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[129]
3054 }
3055
3056 pub fn get_fields_internal_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3057 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[130]
3058 }
3059
3060 pub fn get_events_internal_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3061 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[131]
3062 }
3063
3064 pub fn get_interfaces_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3065 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[132]
3066 }
3067
3068 pub fn get_nested_types_native_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3069 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[133]
3070 }
3071
3072 pub fn get_nested_types_internal_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3073 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[134]
3074 }
3075
3076 pub fn get_assembly_qualified_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3077 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[135]
3078 }
3079
3080 pub fn get_declaring_type_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3081 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[136]
3082 }
3083
3084 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3085 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[137]
3086 }
3087
3088 pub fn get_namespace_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3089 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[138]
3090 }
3091
3092 pub fn get_hash_code_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3093 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[139]
3094 }
3095
3096 pub fn get_full_name_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3097 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[140]
3098 }
3099
3100 pub fn cctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3101 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[142]
3102 }
3103}
3104
3105#[cfg(feature = "system-runtimetype")]
3106impl RuntimeType {
3107 #[doc = "Direct (non-virtual) call to `RuntimeType`'s own `GetMethods`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3108 pub unsafe fn get_methods(
3109 this: impl ::core::convert::Into<::unity::IlInstance>,
3110 binding_attr: crate::system::reflection::bindingflags::BindingFlags,
3111 ) -> ::unity::Array<crate::system::reflection::methodinfo::MethodInfo> {
3112 let __mi = Self::get_methods_method_info();
3113 let __inner: extern "C" fn(
3114 ::unity::IlInstance,
3115 crate::system::reflection::bindingflags::BindingFlags,
3116 ::unity::OptionalMethod,
3117 ) -> ::unity::Array<crate::system::reflection::methodinfo::MethodInfo> = ::core::mem::transmute(__mi.method_ptr);
3118 __inner(this.into(), binding_attr, ::core::option::Option::None)
3119 }
3120
3121 #[doc = "Direct (non-virtual) call to `RuntimeType`'s own `GetConstructors`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3122 pub unsafe fn get_constructors(
3123 this: impl ::core::convert::Into<::unity::IlInstance>,
3124 binding_attr: crate::system::reflection::bindingflags::BindingFlags,
3125 ) -> ::unity::Array<crate::system::reflection::constructorinfo::ConstructorInfo> {
3126 let __mi = Self::get_constructors_method_info();
3127 let __inner: extern "C" fn(
3128 ::unity::IlInstance,
3129 crate::system::reflection::bindingflags::BindingFlags,
3130 ::unity::OptionalMethod,
3131 ) -> ::unity::Array<crate::system::reflection::constructorinfo::ConstructorInfo> = ::core::mem::transmute(__mi.method_ptr);
3132 __inner(this.into(), binding_attr, ::core::option::Option::None)
3133 }
3134
3135 #[doc = "Direct (non-virtual) call to `RuntimeType`'s own `GetProperties`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3136 pub unsafe fn get_properties(
3137 this: impl ::core::convert::Into<::unity::IlInstance>,
3138 binding_attr: crate::system::reflection::bindingflags::BindingFlags,
3139 ) -> ::unity::Array<crate::system::reflection::propertyinfo::PropertyInfo> {
3140 let __mi = Self::get_properties_method_info();
3141 let __inner: extern "C" fn(
3142 ::unity::IlInstance,
3143 crate::system::reflection::bindingflags::BindingFlags,
3144 ::unity::OptionalMethod,
3145 ) -> ::unity::Array<crate::system::reflection::propertyinfo::PropertyInfo> = ::core::mem::transmute(__mi.method_ptr);
3146 __inner(this.into(), binding_attr, ::core::option::Option::None)
3147 }
3148
3149 #[doc = "Direct (non-virtual) call to `RuntimeType`'s own `GetEvents`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3150 pub unsafe fn get_events(
3151 this: impl ::core::convert::Into<::unity::IlInstance>,
3152 binding_attr: crate::system::reflection::bindingflags::BindingFlags,
3153 ) -> ::unity::Array<crate::system::reflection::eventinfo::EventInfo> {
3154 let __mi = Self::get_events_method_info();
3155 let __inner: extern "C" fn(
3156 ::unity::IlInstance,
3157 crate::system::reflection::bindingflags::BindingFlags,
3158 ::unity::OptionalMethod,
3159 ) -> ::unity::Array<crate::system::reflection::eventinfo::EventInfo> = ::core::mem::transmute(__mi.method_ptr);
3160 __inner(this.into(), binding_attr, ::core::option::Option::None)
3161 }
3162
3163 #[doc = "Direct (non-virtual) call to `RuntimeType`'s own `GetFields`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3164 pub unsafe fn get_fields(
3165 this: impl ::core::convert::Into<::unity::IlInstance>,
3166 binding_attr: crate::system::reflection::bindingflags::BindingFlags,
3167 ) -> ::unity::Array<crate::system::reflection::fieldinfo::FieldInfo> {
3168 let __mi = Self::get_fields_method_info();
3169 let __inner: extern "C" fn(
3170 ::unity::IlInstance,
3171 crate::system::reflection::bindingflags::BindingFlags,
3172 ::unity::OptionalMethod,
3173 ) -> ::unity::Array<crate::system::reflection::fieldinfo::FieldInfo> = ::core::mem::transmute(__mi.method_ptr);
3174 __inner(this.into(), binding_attr, ::core::option::Option::None)
3175 }
3176
3177 #[doc = "Direct (non-virtual) call to `RuntimeType`'s own `GetNestedTypes`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3178 pub unsafe fn get_nested_types(
3179 this: impl ::core::convert::Into<::unity::IlInstance>,
3180 binding_attr: crate::system::reflection::bindingflags::BindingFlags,
3181 ) -> ::unity::Array<::unity::SystemType> {
3182 let __mi = Self::get_nested_types_method_info();
3183 let __inner: extern "C" fn(
3184 ::unity::IlInstance,
3185 crate::system::reflection::bindingflags::BindingFlags,
3186 ::unity::OptionalMethod,
3187 ) -> ::unity::Array<::unity::SystemType> = ::core::mem::transmute(__mi.method_ptr);
3188 __inner(this.into(), binding_attr, ::core::option::Option::None)
3189 }
3190
3191 #[doc = "Direct (non-virtual) call to `RuntimeType`'s own `GetMethodImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3192 pub unsafe fn get_method_impl(
3193 this: impl ::core::convert::Into<::unity::IlInstance>,
3194 name: ::unity::Il2CppString,
3195 binding_attr: crate::system::reflection::bindingflags::BindingFlags,
3196 binder: crate::system::reflection::binder::Binder,
3197 call_conv: crate::system::reflection::callingconventions::CallingConventions,
3198 types: ::unity::Array<::unity::SystemType>,
3199 modifiers: ::unity::Array<crate::system::reflection::parametermodifier::ParameterModifier>,
3200 ) -> crate::system::reflection::methodinfo::MethodInfo {
3201 let __mi = Self::get_method_impl_method_info();
3202 let __inner: extern "C" fn(
3203 ::unity::IlInstance,
3204 ::unity::Il2CppString,
3205 crate::system::reflection::bindingflags::BindingFlags,
3206 crate::system::reflection::binder::Binder,
3207 crate::system::reflection::callingconventions::CallingConventions,
3208 ::unity::Array<::unity::SystemType>,
3209 ::unity::Array<crate::system::reflection::parametermodifier::ParameterModifier>,
3210 ::unity::OptionalMethod,
3211 ) -> crate::system::reflection::methodinfo::MethodInfo = ::core::mem::transmute(__mi.method_ptr);
3212 __inner(
3213 this.into(),
3214 name,
3215 binding_attr,
3216 binder,
3217 call_conv,
3218 types,
3219 modifiers,
3220 ::core::option::Option::None,
3221 )
3222 }
3223
3224 #[doc = "Direct (non-virtual) call to `RuntimeType`'s own `GetConstructorImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3225 pub unsafe fn get_constructor_impl(
3226 this: impl ::core::convert::Into<::unity::IlInstance>,
3227 binding_attr: crate::system::reflection::bindingflags::BindingFlags,
3228 binder: crate::system::reflection::binder::Binder,
3229 call_convention: crate::system::reflection::callingconventions::CallingConventions,
3230 types: ::unity::Array<::unity::SystemType>,
3231 modifiers: ::unity::Array<crate::system::reflection::parametermodifier::ParameterModifier>,
3232 ) -> crate::system::reflection::constructorinfo::ConstructorInfo {
3233 let __mi = Self::get_constructor_impl_method_info();
3234 let __inner: extern "C" fn(
3235 ::unity::IlInstance,
3236 crate::system::reflection::bindingflags::BindingFlags,
3237 crate::system::reflection::binder::Binder,
3238 crate::system::reflection::callingconventions::CallingConventions,
3239 ::unity::Array<::unity::SystemType>,
3240 ::unity::Array<crate::system::reflection::parametermodifier::ParameterModifier>,
3241 ::unity::OptionalMethod,
3242 ) -> crate::system::reflection::constructorinfo::ConstructorInfo = ::core::mem::transmute(__mi.method_ptr);
3243 __inner(
3244 this.into(),
3245 binding_attr,
3246 binder,
3247 call_convention,
3248 types,
3249 modifiers,
3250 ::core::option::Option::None,
3251 )
3252 }
3253
3254 #[doc = "Direct (non-virtual) call to `RuntimeType`'s own `GetPropertyImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3255 pub unsafe fn get_property_impl(
3256 this: impl ::core::convert::Into<::unity::IlInstance>,
3257 name: ::unity::Il2CppString,
3258 binding_attr: crate::system::reflection::bindingflags::BindingFlags,
3259 binder: crate::system::reflection::binder::Binder,
3260 return_type: ::unity::SystemType,
3261 types: ::unity::Array<::unity::SystemType>,
3262 modifiers: ::unity::Array<crate::system::reflection::parametermodifier::ParameterModifier>,
3263 ) -> crate::system::reflection::propertyinfo::PropertyInfo {
3264 let __mi = Self::get_property_impl_method_info();
3265 let __inner: extern "C" fn(
3266 ::unity::IlInstance,
3267 ::unity::Il2CppString,
3268 crate::system::reflection::bindingflags::BindingFlags,
3269 crate::system::reflection::binder::Binder,
3270 ::unity::SystemType,
3271 ::unity::Array<::unity::SystemType>,
3272 ::unity::Array<crate::system::reflection::parametermodifier::ParameterModifier>,
3273 ::unity::OptionalMethod,
3274 ) -> crate::system::reflection::propertyinfo::PropertyInfo = ::core::mem::transmute(__mi.method_ptr);
3275 __inner(
3276 this.into(),
3277 name,
3278 binding_attr,
3279 binder,
3280 return_type,
3281 types,
3282 modifiers,
3283 ::core::option::Option::None,
3284 )
3285 }
3286
3287 #[doc = "Direct (non-virtual) call to `RuntimeType`'s own `GetEvent`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3288 pub unsafe fn get_event(
3289 this: impl ::core::convert::Into<::unity::IlInstance>,
3290 name: ::unity::Il2CppString,
3291 binding_attr: crate::system::reflection::bindingflags::BindingFlags,
3292 ) -> crate::system::reflection::eventinfo::EventInfo {
3293 let __mi = Self::get_event_method_info();
3294 let __inner: extern "C" fn(
3295 ::unity::IlInstance,
3296 ::unity::Il2CppString,
3297 crate::system::reflection::bindingflags::BindingFlags,
3298 ::unity::OptionalMethod,
3299 ) -> crate::system::reflection::eventinfo::EventInfo = ::core::mem::transmute(__mi.method_ptr);
3300 __inner(this.into(), name, binding_attr, ::core::option::Option::None)
3301 }
3302
3303 #[doc = "Direct (non-virtual) call to `RuntimeType`'s own `GetField`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3304 pub unsafe fn get_field(
3305 this: impl ::core::convert::Into<::unity::IlInstance>,
3306 name: ::unity::Il2CppString,
3307 binding_attr: crate::system::reflection::bindingflags::BindingFlags,
3308 ) -> crate::system::reflection::fieldinfo::FieldInfo {
3309 let __mi = Self::get_field_method_info();
3310 let __inner: extern "C" fn(
3311 ::unity::IlInstance,
3312 ::unity::Il2CppString,
3313 crate::system::reflection::bindingflags::BindingFlags,
3314 ::unity::OptionalMethod,
3315 ) -> crate::system::reflection::fieldinfo::FieldInfo = ::core::mem::transmute(__mi.method_ptr);
3316 __inner(this.into(), name, binding_attr, ::core::option::Option::None)
3317 }
3318
3319 #[doc = "Direct (non-virtual) call to `RuntimeType`'s own `GetInterface`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3320 pub unsafe fn get_interface(
3321 this: impl ::core::convert::Into<::unity::IlInstance>,
3322 fullname: ::unity::Il2CppString,
3323 ignore_case: bool,
3324 ) -> ::unity::SystemType {
3325 let __mi = Self::get_interface_method_info();
3326 let __inner: extern "C" fn(::unity::IlInstance, ::unity::Il2CppString, bool, ::unity::OptionalMethod) -> ::unity::SystemType =
3327 ::core::mem::transmute(__mi.method_ptr);
3328 __inner(this.into(), fullname, ignore_case, ::core::option::Option::None)
3329 }
3330
3331 #[doc = "Direct (non-virtual) call to `RuntimeType`'s own `GetNestedType`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3332 pub unsafe fn get_nested_type(
3333 this: impl ::core::convert::Into<::unity::IlInstance>,
3334 fullname: ::unity::Il2CppString,
3335 binding_attr: crate::system::reflection::bindingflags::BindingFlags,
3336 ) -> ::unity::SystemType {
3337 let __mi = Self::get_nested_type_method_info();
3338 let __inner: extern "C" fn(
3339 ::unity::IlInstance,
3340 ::unity::Il2CppString,
3341 crate::system::reflection::bindingflags::BindingFlags,
3342 ::unity::OptionalMethod,
3343 ) -> ::unity::SystemType = ::core::mem::transmute(__mi.method_ptr);
3344 __inner(this.into(), fullname, binding_attr, ::core::option::Option::None)
3345 }
3346
3347 #[doc = "Direct (non-virtual) call to `RuntimeType`'s own `GetMember`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3348 pub unsafe fn get_member(
3349 this: impl ::core::convert::Into<::unity::IlInstance>,
3350 name: ::unity::Il2CppString,
3351 r#type: crate::system::reflection::membertypes::MemberTypes,
3352 binding_attr: crate::system::reflection::bindingflags::BindingFlags,
3353 ) -> ::unity::Array<crate::system::reflection::memberinfo::MemberInfo> {
3354 let __mi = Self::get_member_method_info();
3355 let __inner: extern "C" fn(
3356 ::unity::IlInstance,
3357 ::unity::Il2CppString,
3358 crate::system::reflection::membertypes::MemberTypes,
3359 crate::system::reflection::bindingflags::BindingFlags,
3360 ::unity::OptionalMethod,
3361 ) -> ::unity::Array<crate::system::reflection::memberinfo::MemberInfo> = ::core::mem::transmute(__mi.method_ptr);
3362 __inner(this.into(), name, r#type, binding_attr, ::core::option::Option::None)
3363 }
3364
3365 #[doc = "Direct (non-virtual) call to `RuntimeType`'s own `get_Module`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3366 pub unsafe fn get_module(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::system::reflection::module::Module {
3367 let __mi = Self::get_module_method_info();
3368 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::system::reflection::module::Module =
3369 ::core::mem::transmute(__mi.method_ptr);
3370 __inner(this.into(), ::core::option::Option::None)
3371 }
3372
3373 #[doc = "Direct (non-virtual) call to `RuntimeType`'s own `get_Assembly`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3374 pub unsafe fn get_assembly(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::system::reflection::assembly::Assembly {
3375 let __mi = Self::get_assembly_method_info();
3376 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::system::reflection::assembly::Assembly =
3377 ::core::mem::transmute(__mi.method_ptr);
3378 __inner(this.into(), ::core::option::Option::None)
3379 }
3380
3381 #[doc = "Direct (non-virtual) call to `RuntimeType`'s own `IsInstanceOfType`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3382 pub unsafe fn is_instance_of_type(this: impl ::core::convert::Into<::unity::IlInstance>, o: crate::system::object::Object) -> bool {
3383 let __mi = Self::is_instance_of_type_method_info();
3384 let __inner: extern "C" fn(::unity::IlInstance, crate::system::object::Object, ::unity::OptionalMethod) -> bool =
3385 ::core::mem::transmute(__mi.method_ptr);
3386 __inner(this.into(), o, ::core::option::Option::None)
3387 }
3388
3389 #[doc = "Direct (non-virtual) call to `RuntimeType`'s own `IsSubclassOf`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3390 pub unsafe fn is_subclass_of(this: impl ::core::convert::Into<::unity::IlInstance>, r#type: ::unity::SystemType) -> bool {
3391 let __mi = Self::is_subclass_of_method_info();
3392 let __inner: extern "C" fn(::unity::IlInstance, ::unity::SystemType, ::unity::OptionalMethod) -> bool =
3393 ::core::mem::transmute(__mi.method_ptr);
3394 __inner(this.into(), r#type, ::core::option::Option::None)
3395 }
3396
3397 #[doc = "Direct (non-virtual) call to `RuntimeType`'s own `IsAssignableFrom`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3398 pub unsafe fn is_assignable_from(this: impl ::core::convert::Into<::unity::IlInstance>, c: ::unity::SystemType) -> bool {
3399 let __mi = Self::is_assignable_from_method_info();
3400 let __inner: extern "C" fn(::unity::IlInstance, ::unity::SystemType, ::unity::OptionalMethod) -> bool =
3401 ::core::mem::transmute(__mi.method_ptr);
3402 __inner(this.into(), c, ::core::option::Option::None)
3403 }
3404
3405 #[doc = "Direct (non-virtual) call to `RuntimeType`'s own `IsEquivalentTo`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3406 pub unsafe fn is_equivalent_to(this: impl ::core::convert::Into<::unity::IlInstance>, other: ::unity::SystemType) -> bool {
3407 let __mi = Self::is_equivalent_to_method_info();
3408 let __inner: extern "C" fn(::unity::IlInstance, ::unity::SystemType, ::unity::OptionalMethod) -> bool =
3409 ::core::mem::transmute(__mi.method_ptr);
3410 __inner(this.into(), other, ::core::option::Option::None)
3411 }
3412
3413 #[doc = "Direct (non-virtual) call to `RuntimeType`'s own `get_BaseType`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3414 pub unsafe fn get_base_type(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::SystemType {
3415 let __mi = Self::get_base_type_method_info();
3416 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::SystemType = ::core::mem::transmute(__mi.method_ptr);
3417 __inner(this.into(), ::core::option::Option::None)
3418 }
3419
3420 #[doc = "Direct (non-virtual) call to `RuntimeType`'s own `get_UnderlyingSystemType`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3421 pub unsafe fn get_underlying_system_type(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::SystemType {
3422 let __mi = Self::get_underlying_system_type_method_info();
3423 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::SystemType = ::core::mem::transmute(__mi.method_ptr);
3424 __inner(this.into(), ::core::option::Option::None)
3425 }
3426
3427 #[doc = "Direct (non-virtual) call to `RuntimeType`'s own `GetAttributeFlagsImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3428 pub unsafe fn get_attribute_flags_impl(
3429 this: impl ::core::convert::Into<::unity::IlInstance>,
3430 ) -> crate::system::reflection::typeattributes::TypeAttributes {
3431 let __mi = Self::get_attribute_flags_impl_method_info();
3432 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::system::reflection::typeattributes::TypeAttributes =
3433 ::core::mem::transmute(__mi.method_ptr);
3434 __inner(this.into(), ::core::option::Option::None)
3435 }
3436
3437 #[doc = "Direct (non-virtual) call to `RuntimeType`'s own `IsContextfulImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3438 pub unsafe fn is_contextful_impl(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
3439 let __mi = Self::is_contextful_impl_method_info();
3440 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
3441 __inner(this.into(), ::core::option::Option::None)
3442 }
3443
3444 #[doc = "Direct (non-virtual) call to `RuntimeType`'s own `IsByRefImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3445 pub unsafe fn is_by_ref_impl(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
3446 let __mi = Self::is_by_ref_impl_method_info();
3447 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
3448 __inner(this.into(), ::core::option::Option::None)
3449 }
3450
3451 #[doc = "Direct (non-virtual) call to `RuntimeType`'s own `IsPrimitiveImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3452 pub unsafe fn is_primitive_impl(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
3453 let __mi = Self::is_primitive_impl_method_info();
3454 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
3455 __inner(this.into(), ::core::option::Option::None)
3456 }
3457
3458 #[doc = "Direct (non-virtual) call to `RuntimeType`'s own `IsPointerImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3459 pub unsafe fn is_pointer_impl(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
3460 let __mi = Self::is_pointer_impl_method_info();
3461 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
3462 __inner(this.into(), ::core::option::Option::None)
3463 }
3464
3465 #[doc = "Direct (non-virtual) call to `RuntimeType`'s own `IsCOMObjectImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3466 pub unsafe fn is_com_object_impl(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
3467 let __mi = Self::is_com_object_impl_method_info();
3468 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
3469 __inner(this.into(), ::core::option::Option::None)
3470 }
3471
3472 #[doc = "Direct (non-virtual) call to `RuntimeType`'s own `IsValueTypeImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3473 pub unsafe fn is_value_type_impl(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
3474 let __mi = Self::is_value_type_impl_method_info();
3475 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
3476 __inner(this.into(), ::core::option::Option::None)
3477 }
3478
3479 #[doc = "Direct (non-virtual) call to `RuntimeType`'s own `get_IsEnum`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3480 pub unsafe fn get_is_enum(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
3481 let __mi = Self::get_is_enum_method_info();
3482 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
3483 __inner(this.into(), ::core::option::Option::None)
3484 }
3485
3486 #[doc = "Direct (non-virtual) call to `RuntimeType`'s own `HasElementTypeImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3487 pub unsafe fn has_element_type_impl(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
3488 let __mi = Self::has_element_type_impl_method_info();
3489 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
3490 __inner(this.into(), ::core::option::Option::None)
3491 }
3492
3493 #[doc = "Direct (non-virtual) call to `RuntimeType`'s own `get_GenericParameterAttributes`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3494 pub unsafe fn get_generic_parameter_attributes(
3495 this: impl ::core::convert::Into<::unity::IlInstance>,
3496 ) -> crate::system::reflection::genericparameterattributes::GenericParameterAttributes {
3497 let __mi = Self::get_generic_parameter_attributes_method_info();
3498 let __inner: extern "C" fn(
3499 ::unity::IlInstance,
3500 ::unity::OptionalMethod,
3501 ) -> crate::system::reflection::genericparameterattributes::GenericParameterAttributes = ::core::mem::transmute(__mi.method_ptr);
3502 __inner(this.into(), ::core::option::Option::None)
3503 }
3504
3505 #[doc = "Direct (non-virtual) call to `RuntimeType`'s own `get_IsSzArray`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3506 pub unsafe fn get_is_sz_array(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
3507 let __mi = Self::get_is_sz_array_method_info();
3508 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
3509 __inner(this.into(), ::core::option::Option::None)
3510 }
3511
3512 #[doc = "Direct (non-virtual) call to `RuntimeType`'s own `IsArrayImpl`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3513 pub unsafe fn is_array_impl(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
3514 let __mi = Self::is_array_impl_method_info();
3515 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
3516 __inner(this.into(), ::core::option::Option::None)
3517 }
3518
3519 #[doc = "Direct (non-virtual) call to `RuntimeType`'s own `GetArrayRank`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3520 pub unsafe fn get_array_rank(this: impl ::core::convert::Into<::unity::IlInstance>) -> i32 {
3521 let __mi = Self::get_array_rank_method_info();
3522 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__mi.method_ptr);
3523 __inner(this.into(), ::core::option::Option::None)
3524 }
3525
3526 #[doc = "Direct (non-virtual) call to `RuntimeType`'s own `GetElementType`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3527 pub unsafe fn get_element_type(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::SystemType {
3528 let __mi = Self::get_element_type_method_info();
3529 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::SystemType = ::core::mem::transmute(__mi.method_ptr);
3530 __inner(this.into(), ::core::option::Option::None)
3531 }
3532
3533 #[doc = "Direct (non-virtual) call to `RuntimeType`'s own `GetEnumNames`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3534 pub unsafe fn get_enum_names(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Array<::unity::Il2CppString> {
3535 let __mi = Self::get_enum_names_method_info();
3536 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Array<::unity::Il2CppString> =
3537 ::core::mem::transmute(__mi.method_ptr);
3538 __inner(this.into(), ::core::option::Option::None)
3539 }
3540
3541 #[doc = "Direct (non-virtual) call to `RuntimeType`'s own `GetEnumValues`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3542 pub unsafe fn get_enum_values(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::IlInstance {
3543 let __mi = Self::get_enum_values_method_info();
3544 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::IlInstance = ::core::mem::transmute(__mi.method_ptr);
3545 __inner(this.into(), ::core::option::Option::None)
3546 }
3547
3548 #[doc = "Direct (non-virtual) call to `RuntimeType`'s own `GetEnumUnderlyingType`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3549 pub unsafe fn get_enum_underlying_type(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::SystemType {
3550 let __mi = Self::get_enum_underlying_type_method_info();
3551 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::SystemType = ::core::mem::transmute(__mi.method_ptr);
3552 __inner(this.into(), ::core::option::Option::None)
3553 }
3554
3555 #[doc = "Direct (non-virtual) call to `RuntimeType`'s own `IsEnumDefined`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3556 pub unsafe fn is_enum_defined(this: impl ::core::convert::Into<::unity::IlInstance>, value: crate::system::object::Object) -> bool {
3557 let __mi = Self::is_enum_defined_method_info();
3558 let __inner: extern "C" fn(::unity::IlInstance, crate::system::object::Object, ::unity::OptionalMethod) -> bool =
3559 ::core::mem::transmute(__mi.method_ptr);
3560 __inner(this.into(), value, ::core::option::Option::None)
3561 }
3562
3563 #[doc = "Direct (non-virtual) call to `RuntimeType`'s own `GetEnumName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3564 pub unsafe fn get_enum_name(
3565 this: impl ::core::convert::Into<::unity::IlInstance>,
3566 value: crate::system::object::Object,
3567 ) -> ::unity::Il2CppString {
3568 let __mi = Self::get_enum_name_method_info();
3569 let __inner: extern "C" fn(::unity::IlInstance, crate::system::object::Object, ::unity::OptionalMethod) -> ::unity::Il2CppString =
3570 ::core::mem::transmute(__mi.method_ptr);
3571 __inner(this.into(), value, ::core::option::Option::None)
3572 }
3573
3574 #[doc = "Direct (non-virtual) call to `RuntimeType`'s own `GetGenericArguments`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3575 pub unsafe fn get_generic_arguments(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Array<::unity::SystemType> {
3576 let __mi = Self::get_generic_arguments_method_info();
3577 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Array<::unity::SystemType> =
3578 ::core::mem::transmute(__mi.method_ptr);
3579 __inner(this.into(), ::core::option::Option::None)
3580 }
3581
3582 #[doc = "Direct (non-virtual) call to `RuntimeType`'s own `MakeGenericType`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3583 pub unsafe fn make_generic_type(
3584 this: impl ::core::convert::Into<::unity::IlInstance>,
3585 instantiation: ::unity::Array<::unity::SystemType>,
3586 ) -> ::unity::SystemType {
3587 let __mi = Self::make_generic_type_method_info();
3588 let __inner: extern "C" fn(::unity::IlInstance, ::unity::Array<::unity::SystemType>, ::unity::OptionalMethod) -> ::unity::SystemType =
3589 ::core::mem::transmute(__mi.method_ptr);
3590 __inner(this.into(), instantiation, ::core::option::Option::None)
3591 }
3592
3593 #[doc = "Direct (non-virtual) call to `RuntimeType`'s own `get_IsGenericTypeDefinition`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3594 pub unsafe fn get_is_generic_type_definition(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
3595 let __mi = Self::get_is_generic_type_definition_method_info();
3596 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
3597 __inner(this.into(), ::core::option::Option::None)
3598 }
3599
3600 #[doc = "Direct (non-virtual) call to `RuntimeType`'s own `get_IsGenericParameter`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3601 pub unsafe fn get_is_generic_parameter(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
3602 let __mi = Self::get_is_generic_parameter_method_info();
3603 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
3604 __inner(this.into(), ::core::option::Option::None)
3605 }
3606
3607 #[doc = "Direct (non-virtual) call to `RuntimeType`'s own `get_GenericParameterPosition`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3608 pub unsafe fn get_generic_parameter_position(this: impl ::core::convert::Into<::unity::IlInstance>) -> i32 {
3609 let __mi = Self::get_generic_parameter_position_method_info();
3610 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__mi.method_ptr);
3611 __inner(this.into(), ::core::option::Option::None)
3612 }
3613
3614 #[doc = "Direct (non-virtual) call to `RuntimeType`'s own `GetGenericTypeDefinition`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3615 pub unsafe fn get_generic_type_definition(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::SystemType {
3616 let __mi = Self::get_generic_type_definition_method_info();
3617 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::SystemType = ::core::mem::transmute(__mi.method_ptr);
3618 __inner(this.into(), ::core::option::Option::None)
3619 }
3620
3621 #[doc = "Direct (non-virtual) call to `RuntimeType`'s own `get_IsGenericType`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3622 pub unsafe fn get_is_generic_type(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
3623 let __mi = Self::get_is_generic_type_method_info();
3624 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
3625 __inner(this.into(), ::core::option::Option::None)
3626 }
3627
3628 #[doc = "Direct (non-virtual) call to `RuntimeType`'s own `get_IsConstructedGenericType`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3629 pub unsafe fn get_is_constructed_generic_type(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
3630 let __mi = Self::get_is_constructed_generic_type_method_info();
3631 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
3632 __inner(this.into(), ::core::option::Option::None)
3633 }
3634
3635 #[doc = "Direct (non-virtual) call to `RuntimeType`'s own `Equals`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3636 pub unsafe fn equals(this: impl ::core::convert::Into<::unity::IlInstance>, obj: crate::system::object::Object) -> bool {
3637 let __mi = Self::equals_method_info();
3638 let __inner: extern "C" fn(::unity::IlInstance, crate::system::object::Object, ::unity::OptionalMethod) -> bool =
3639 ::core::mem::transmute(__mi.method_ptr);
3640 __inner(this.into(), obj, ::core::option::Option::None)
3641 }
3642
3643 #[doc = "Direct (non-virtual) call to `RuntimeType`'s own `Clone`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3644 pub unsafe fn clone(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::system::object::Object {
3645 let __mi = Self::clone_method_info();
3646 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::system::object::Object =
3647 ::core::mem::transmute(__mi.method_ptr);
3648 __inner(this.into(), ::core::option::Option::None)
3649 }
3650
3651 #[doc = "Direct (non-virtual) call to `RuntimeType`'s own `GetCustomAttributes`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3652 pub unsafe fn get_custom_attributes(
3653 this: impl ::core::convert::Into<::unity::IlInstance>,
3654 inherit: bool,
3655 ) -> ::unity::Array<crate::system::object::Object> {
3656 let __mi = Self::get_custom_attributes_method_info();
3657 let __inner: extern "C" fn(::unity::IlInstance, bool, ::unity::OptionalMethod) -> ::unity::Array<crate::system::object::Object> =
3658 ::core::mem::transmute(__mi.method_ptr);
3659 __inner(this.into(), inherit, ::core::option::Option::None)
3660 }
3661
3662 #[doc = "Direct (non-virtual) call to `RuntimeType`'s own `GetCustomAttributes`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3663 pub unsafe fn get_custom_attributes_2(
3664 this: impl ::core::convert::Into<::unity::IlInstance>,
3665 attribute_type: ::unity::SystemType,
3666 inherit: bool,
3667 ) -> ::unity::Array<crate::system::object::Object> {
3668 let __mi = Self::get_custom_attributes_2_method_info();
3669 let __inner: extern "C" fn(
3670 ::unity::IlInstance,
3671 ::unity::SystemType,
3672 bool,
3673 ::unity::OptionalMethod,
3674 ) -> ::unity::Array<crate::system::object::Object> = ::core::mem::transmute(__mi.method_ptr);
3675 __inner(this.into(), attribute_type, inherit, ::core::option::Option::None)
3676 }
3677
3678 #[doc = "Direct (non-virtual) call to `RuntimeType`'s own `IsDefined`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3679 pub unsafe fn is_defined(this: impl ::core::convert::Into<::unity::IlInstance>, attribute_type: ::unity::SystemType, inherit: bool) -> bool {
3680 let __mi = Self::is_defined_method_info();
3681 let __inner: extern "C" fn(::unity::IlInstance, ::unity::SystemType, bool, ::unity::OptionalMethod) -> bool =
3682 ::core::mem::transmute(__mi.method_ptr);
3683 __inner(this.into(), attribute_type, inherit, ::core::option::Option::None)
3684 }
3685
3686 #[doc = "Direct (non-virtual) call to `RuntimeType`'s own `GetCustomAttributesData`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3687 pub unsafe fn get_custom_attributes_data(
3688 this: impl ::core::convert::Into<::unity::IlInstance>,
3689 ) -> crate::system::collections::generic::ilist_1_interface::IList_1_Interface<crate::system::reflection::customattributedata::CustomAttributeData>
3690 {
3691 let __mi = Self::get_custom_attributes_data_method_info();
3692 let __inner: extern "C" fn(
3693 ::unity::IlInstance,
3694 ::unity::OptionalMethod,
3695 ) -> crate::system::collections::generic::ilist_1_interface::IList_1_Interface<
3696 crate::system::reflection::customattributedata::CustomAttributeData,
3697 > = ::core::mem::transmute(__mi.method_ptr);
3698 __inner(this.into(), ::core::option::Option::None)
3699 }
3700
3701 #[doc = "Direct (non-virtual) call to `RuntimeType`'s own `FormatTypeName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3702 pub unsafe fn format_type_name(this: impl ::core::convert::Into<::unity::IlInstance>, serialization: bool) -> ::unity::Il2CppString {
3703 let __mi = Self::format_type_name_method_info();
3704 let __inner: extern "C" fn(::unity::IlInstance, bool, ::unity::OptionalMethod) -> ::unity::Il2CppString =
3705 ::core::mem::transmute(__mi.method_ptr);
3706 __inner(this.into(), serialization, ::core::option::Option::None)
3707 }
3708
3709 #[doc = "Direct (non-virtual) call to `RuntimeType`'s own `get_MemberType`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3710 pub unsafe fn get_member_type(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::system::reflection::membertypes::MemberTypes {
3711 let __mi = Self::get_member_type_method_info();
3712 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::system::reflection::membertypes::MemberTypes =
3713 ::core::mem::transmute(__mi.method_ptr);
3714 __inner(this.into(), ::core::option::Option::None)
3715 }
3716
3717 #[doc = "Direct (non-virtual) call to `RuntimeType`'s own `get_ReflectedType`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3718 pub unsafe fn get_reflected_type(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::SystemType {
3719 let __mi = Self::get_reflected_type_method_info();
3720 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::SystemType = ::core::mem::transmute(__mi.method_ptr);
3721 __inner(this.into(), ::core::option::Option::None)
3722 }
3723
3724 #[doc = "Direct (non-virtual) call to `RuntimeType`'s own `get_MetadataToken`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3725 pub unsafe fn get_metadata_token(this: impl ::core::convert::Into<::unity::IlInstance>) -> i32 {
3726 let __mi = Self::get_metadata_token_method_info();
3727 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__mi.method_ptr);
3728 __inner(this.into(), ::core::option::Option::None)
3729 }
3730
3731 #[doc = "Direct (non-virtual) call to `RuntimeType`'s own `MakeArrayType`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3732 pub unsafe fn make_array_type_2(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::SystemType {
3733 let __mi = Self::make_array_type_2_method_info();
3734 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::SystemType = ::core::mem::transmute(__mi.method_ptr);
3735 __inner(this.into(), ::core::option::Option::None)
3736 }
3737
3738 #[doc = "Direct (non-virtual) call to `RuntimeType`'s own `MakeByRefType`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3739 pub unsafe fn make_by_ref_type(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::SystemType {
3740 let __mi = Self::make_by_ref_type_method_info();
3741 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::SystemType = ::core::mem::transmute(__mi.method_ptr);
3742 __inner(this.into(), ::core::option::Option::None)
3743 }
3744
3745 #[doc = "Direct (non-virtual) call to `RuntimeType`'s own `MakePointerType`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3746 pub unsafe fn make_pointer_type_2(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::SystemType {
3747 let __mi = Self::make_pointer_type_2_method_info();
3748 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::SystemType = ::core::mem::transmute(__mi.method_ptr);
3749 __inner(this.into(), ::core::option::Option::None)
3750 }
3751
3752 #[doc = "Direct (non-virtual) call to `RuntimeType`'s own `get_ContainsGenericParameters`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3753 pub unsafe fn get_contains_generic_parameters(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
3754 let __mi = Self::get_contains_generic_parameters_method_info();
3755 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
3756 __inner(this.into(), ::core::option::Option::None)
3757 }
3758
3759 #[doc = "Direct (non-virtual) call to `RuntimeType`'s own `GetGenericParameterConstraints`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3760 pub unsafe fn get_generic_parameter_constraints(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Array<::unity::SystemType> {
3761 let __mi = Self::get_generic_parameter_constraints_method_info();
3762 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Array<::unity::SystemType> =
3763 ::core::mem::transmute(__mi.method_ptr);
3764 __inner(this.into(), ::core::option::Option::None)
3765 }
3766
3767 #[doc = "Direct (non-virtual) call to `RuntimeType`'s own `ToString`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3768 pub unsafe fn to_string(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
3769 let __mi = Self::to_string_method_info();
3770 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
3771 __inner(this.into(), ::core::option::Option::None)
3772 }
3773
3774 #[doc = "Direct (non-virtual) call to `RuntimeType`'s own `get_DeclaringMethod`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3775 pub unsafe fn get_declaring_method(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::system::reflection::methodbase::MethodBase {
3776 let __mi = Self::get_declaring_method_method_info();
3777 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::system::reflection::methodbase::MethodBase =
3778 ::core::mem::transmute(__mi.method_ptr);
3779 __inner(this.into(), ::core::option::Option::None)
3780 }
3781
3782 #[doc = "Direct (non-virtual) call to `RuntimeType`'s own `GetInterfaces`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3783 pub unsafe fn get_interfaces(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Array<::unity::SystemType> {
3784 let __mi = Self::get_interfaces_method_info();
3785 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Array<::unity::SystemType> =
3786 ::core::mem::transmute(__mi.method_ptr);
3787 __inner(this.into(), ::core::option::Option::None)
3788 }
3789
3790 #[doc = "Direct (non-virtual) call to `RuntimeType`'s own `get_AssemblyQualifiedName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3791 pub unsafe fn get_assembly_qualified_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
3792 let __mi = Self::get_assembly_qualified_name_method_info();
3793 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
3794 __inner(this.into(), ::core::option::Option::None)
3795 }
3796
3797 #[doc = "Direct (non-virtual) call to `RuntimeType`'s own `get_DeclaringType`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3798 pub unsafe fn get_declaring_type(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::SystemType {
3799 let __mi = Self::get_declaring_type_method_info();
3800 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::SystemType = ::core::mem::transmute(__mi.method_ptr);
3801 __inner(this.into(), ::core::option::Option::None)
3802 }
3803
3804 #[doc = "Direct (non-virtual) call to `RuntimeType`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3805 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
3806 let __mi = Self::get_name_method_info();
3807 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
3808 __inner(this.into(), ::core::option::Option::None)
3809 }
3810
3811 #[doc = "Direct (non-virtual) call to `RuntimeType`'s own `get_Namespace`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3812 pub unsafe fn get_namespace(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
3813 let __mi = Self::get_namespace_method_info();
3814 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
3815 __inner(this.into(), ::core::option::Option::None)
3816 }
3817
3818 #[doc = "Direct (non-virtual) call to `RuntimeType`'s own `GetHashCode`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3819 pub unsafe fn get_hash_code(this: impl ::core::convert::Into<::unity::IlInstance>) -> i32 {
3820 let __mi = Self::get_hash_code_method_info();
3821 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__mi.method_ptr);
3822 __inner(this.into(), ::core::option::Option::None)
3823 }
3824
3825 #[doc = "Direct (non-virtual) call to `RuntimeType`'s own `get_FullName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3826 pub unsafe fn get_full_name_2(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
3827 let __mi = Self::get_full_name_2_method_info();
3828 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
3829 __inner(this.into(), ::core::option::Option::None)
3830 }
3831}
3832
3833#[cfg(feature = "system-runtimetype")]
3834impl RuntimeType {
3835 #[doc = "`.ctor()` — no args"]
3836 pub fn new() -> Self {
3837 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
3838 panic!(
3839 "{}
3840::{}
3841 failed to instantiate",
3842 ::core::stringify!(RuntimeType),
3843 ::core::stringify!(new),
3844 )
3845 });
3846 <Self as IRuntimeTypeMethods>::ctor(this);
3847 this
3848 }
3849}
3850
3851#[cfg(feature = "system-runtimetype")]
3852#[doc(hidden)]
3853pub mod prelude {
3854 pub use super::{IRuntimeType, IRuntimeTypeMethods, RuntimeType};
3855 #[cfg(feature = "system-object")]
3856 pub use crate::system::object::IObjectMethods;
3857 #[cfg(feature = "system-reflection-memberinfo")]
3858 pub use crate::system::reflection::memberinfo::IMemberInfoMethods;
3859 #[cfg(feature = "system-reflection-typeinfo")]
3860 pub use crate::system::reflection::typeinfo::ITypeInfoMethods;
3861 pub use crate::system::{
3862 object::IObject,
3863 reflection::{memberinfo::IMemberInfo, typeinfo::ITypeInfo},
3864 };
3865}