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