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