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