1#[cfg(feature = "app-pool-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/pool/Pool_Node.md"))]
11 #[::unity::class(namespace = "App", name = "Pool.Node")]
12 #[parent(crate::system::object::Object)]
13 pub struct Pool_Node {}
14
15 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/pool/Pool_LockStack_1.md"))]
16 #[::unity::class(namespace = "App", name = "Pool.LockStack`1")]
17 #[parent(crate::app::pool::Pool_Stack_1<T0>)]
18 #[parent(crate::system::object::Object)]
19 pub struct Pool_LockStack_1<T0: ::unity::ClassIdentity> {
20 #[rename(name = "lockObject")]
21 pub lock_object: ::unity::IlInstance,
22 }
23
24 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/pool/Pool_List_1.md"))]
25 #[::unity::class(namespace = "App", name = "Pool.List`1")]
26 #[parent(crate::system::object::Object)]
27 pub struct Pool_List_1<T0: ::unity::ClassIdentity> {
28 #[rename(name = "m_List")]
29 pub m_list: crate::system::collections::generic::list_1::List_1<T0>,
30 #[rename(name = "m_Pool")]
31 pub m_pool: crate::system::collections::generic::stack_1::Stack_1<T0>,
32 }
33
34 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/pool/Pool_Hierarchy_1.md"))]
35 #[::unity::class(namespace = "App", name = "Pool.Hierarchy`1")]
36 #[parent(crate::system::object::Object)]
37 pub struct Pool_Hierarchy_1<T0: ::unity::ClassIdentity> {
38 #[rename(name = "m_Pool")]
39 pub m_pool: crate::system::collections::generic::stack_1::Stack_1<T0>,
40 #[rename(name = "m_Used")]
41 pub m_used: crate::system::collections::generic::stack_1::Stack_1<T0>,
42 }
43
44 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/pool/Pool_Stack_1.md"))]
45 #[::unity::class(namespace = "App", name = "Pool.Stack`1")]
46 #[parent(crate::system::object::Object)]
47 pub struct Pool_Stack_1<T0: ::unity::ClassIdentity> {
48 #[rename(name = "m_Pool")]
49 pub m_pool: crate::system::collections::generic::stack_1::Stack_1<T0>,
50 }
51
52 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/pool/Pool.md"))]
53 #[::unity::class(namespace = "App", name = "Pool")]
54 #[parent(crate::system::object::Object)]
55 pub struct Pool {}
56}
57
58#[cfg(feature = "app-pool-types")]
59pub use __types::*;
60
61#[cfg(feature = "app-pool")]
62pub trait IPool_NodeMethods: IPool_Node {
63 #[doc = "`OnEnter()` overload"]
64 fn on_enter(self) -> () {
65 unsafe {
66 let __receiver = <Pool_Node as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
67 {
68 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
69 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
70 panic!(
71 "unity: virtual slot {}
72 out of range (vtable len {}
73) on the runtime class behind {}
74 (method `{}
75`)",
76 4usize,
77 __vt.len(),
78 <Pool_Node as ::unity::ClassIdentity>::NAME,
79 "OnEnter",
80 )
81 });
82 let __inner: extern "C" fn(Pool_Node, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
83 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
84 __inner(__receiver, __mi)
85 }
86 }
87 }
88 #[doc = "`OnExit()` overload"]
89 fn on_exit(self) -> () {
90 unsafe {
91 let __receiver = <Pool_Node as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
92 {
93 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
94 let __vi = *__vt.get(5usize).unwrap_or_else(|| {
95 panic!(
96 "unity: virtual slot {}
97 out of range (vtable len {}
98) on the runtime class behind {}
99 (method `{}
100`)",
101 5usize,
102 __vt.len(),
103 <Pool_Node as ::unity::ClassIdentity>::NAME,
104 "OnExit",
105 )
106 });
107 let __inner: extern "C" fn(Pool_Node, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
108 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
109 __inner(__receiver, __mi)
110 }
111 }
112 }
113 #[doc = "`get_SortKey()` overload"]
114 fn get_sort_key(self) -> i32 {
115 unsafe {
116 let __receiver = <Pool_Node as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
117 {
118 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
119 let __vi = *__vt.get(6usize).unwrap_or_else(|| {
120 panic!(
121 "unity: virtual slot {}
122 out of range (vtable len {}
123) on the runtime class behind {}
124 (method `{}
125`)",
126 6usize,
127 __vt.len(),
128 <Pool_Node as ::unity::ClassIdentity>::NAME,
129 "get_SortKey",
130 )
131 });
132 let __inner: extern "C" fn(Pool_Node, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__vi.method_ptr);
133 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
134 __inner(__receiver, __mi)
135 }
136 }
137 }
138 #[doc = "`.ctor()` overload"]
139 fn ctor(self) -> () {
140 unsafe {
141 let __receiver = <Pool_Node as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
142 ::unity::il2cpp_call!((::unity::module_base()+0x2264cb0usize)as*mut u8,();
143(Pool_Node)__receiver)
144 }
145 }
146}
147
148#[cfg(feature = "app-pool")]
149impl<__T: IPool_Node> IPool_NodeMethods for __T {}
150
151#[cfg(feature = "app-pool")]
152impl Pool_Node {
153 pub fn on_enter_method_info() -> &'static ::unity::il2cpp::MethodInfo {
154 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
155 }
156
157 pub fn on_exit_method_info() -> &'static ::unity::il2cpp::MethodInfo {
158 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
159 }
160
161 pub fn get_sort_key_method_info() -> &'static ::unity::il2cpp::MethodInfo {
162 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
163 }
164
165 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
166 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
167 }
168}
169
170#[cfg(feature = "app-pool")]
171impl Pool_Node {
172 #[doc = "Direct (non-virtual) call to `Pool_Node`'s own `OnEnter`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
173 pub unsafe fn on_enter(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
174 let __mi = Self::on_enter_method_info();
175 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
176 __inner(this.into(), ::core::option::Option::None)
177 }
178
179 #[doc = "Direct (non-virtual) call to `Pool_Node`'s own `OnExit`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
180 pub unsafe fn on_exit(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
181 let __mi = Self::on_exit_method_info();
182 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
183 __inner(this.into(), ::core::option::Option::None)
184 }
185
186 #[doc = "Direct (non-virtual) call to `Pool_Node`'s own `get_SortKey`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
187 pub unsafe fn get_sort_key(this: impl ::core::convert::Into<::unity::IlInstance>) -> i32 {
188 let __mi = Self::get_sort_key_method_info();
189 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__mi.method_ptr);
190 __inner(this.into(), ::core::option::Option::None)
191 }
192}
193
194#[cfg(feature = "app-pool")]
195impl Pool_Node {
196 #[doc = "`.ctor()` — no args"]
197 pub fn new() -> Self {
198 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
199 panic!(
200 "{}
201::{}
202 failed to instantiate",
203 ::core::stringify!(Pool_Node),
204 ::core::stringify!(new),
205 )
206 });
207 <Self as IPool_NodeMethods>::ctor(this);
208 this
209 }
210}
211
212#[cfg(feature = "app-pool")]
213#[::unity::methods]
214impl<T0: ::unity::ClassIdentity> Pool_LockStack_1<T0> {
215 #[doc = "`.ctor(i32)` overload"]
216 #[method(name = ".ctor", args = 1)]
217 pub fn ctor(self, max: i32) -> ();
218
219 #[doc = "`Pop()` overload"]
220 #[method(name = "Pop", args = 0)]
221 pub fn pop(self) -> T0;
222
223 #[doc = "`Push(T0)` overload"]
224 #[method(name = "Push", args = 1)]
225 pub fn push(self, p: T0) -> ();
226}
227
228#[cfg(feature = "app-pool")]
229impl<T0: ::unity::ClassIdentity> Pool_LockStack_1<T0> {
230 #[doc = "`.ctor(i32)` — overload selector"]
231 pub fn new(max: i32) -> Self {
232 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
233 panic!(
234 "{}
235::{}
236 failed to instantiate",
237 ::core::stringify!(Pool_LockStack_1),
238 ::core::stringify!(new),
239 )
240 });
241 <Self as IPool_LockStack_1Methods<T0>>::ctor(this, max);
242 this
243 }
244}
245
246#[cfg(feature = "app-pool")]
247#[::unity::methods]
248impl<T0: ::unity::ClassIdentity> Pool_List_1<T0> {
249 #[doc = "`.ctor(i32)` overload"]
250 #[method(name = ".ctor", args = 1)]
251 pub fn ctor(self, max: i32) -> ();
252
253 #[doc = "`get_Count()` overload"]
254 #[method(name = "get_Count", args = 0)]
255 pub fn get_count(self) -> i32;
256
257 #[doc = "`get_Item(i32)` overload"]
258 #[method(name = "get_Item", args = 1)]
259 pub fn get_item(self, i: i32) -> T0;
260
261 #[doc = "`Get(i32)` overload"]
262 #[method(name = "Get", args = 1)]
263 pub fn get(self, i: i32) -> T0;
264
265 #[doc = "`Swap(i32, i32)` overload"]
266 #[method(name = "Swap", args = 2)]
267 pub fn swap(self, index_a: i32, index_b: i32) -> ();
268
269 #[doc = "`Create()` overload"]
270 #[method(name = "Create", args = 0)]
271 pub fn create(self) -> T0;
272
273 #[doc = "`Delete(T0)` overload"]
274 #[method(name = "Delete", args = 1)]
275 pub fn delete(self, p: T0) -> ();
276
277 #[doc = "`Clear()` overload"]
278 #[method(name = "Clear", args = 0)]
279 pub fn clear(self) -> ();
280
281 #[doc = "`Sort()` overload"]
282 #[method(name = "Sort", args = 0)]
283 pub fn sort(self) -> ();
284
285 #[doc = "`GetEnumerator()` overload"]
286 #[method(name = "GetEnumerator", args = 0)]
287 pub fn get_enumerator(self) -> crate::system::collections::generic::ienumerator_1::IEnumerator_1<T0>;
288}
289
290#[cfg(feature = "app-pool")]
291impl<T0: ::unity::ClassIdentity> Pool_List_1<T0> {
292 #[doc = "`.ctor(i32)` — overload selector"]
293 pub fn new(max: i32) -> Self {
294 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
295 panic!(
296 "{}
297::{}
298 failed to instantiate",
299 ::core::stringify!(Pool_List_1),
300 ::core::stringify!(new),
301 )
302 });
303 <Self as IPool_List_1Methods<T0>>::ctor(this, max);
304 this
305 }
306}
307
308#[cfg(feature = "app-pool")]
309#[::unity::methods]
310impl<T0: ::unity::ClassIdentity> Pool_Hierarchy_1<T0> {
311 #[doc = "`.ctor(i32)` overload"]
312 #[method(name = ".ctor", args = 1)]
313 pub fn ctor(self, max: i32) -> ();
314
315 #[doc = "`Push()` overload"]
316 #[method(name = "Push", args = 0)]
317 pub fn push(self) -> T0;
318
319 #[doc = "`Pop()` overload"]
320 #[method(name = "Pop", args = 0)]
321 pub fn pop(self) -> T0;
322}
323
324#[cfg(feature = "app-pool")]
325impl<T0: ::unity::ClassIdentity> Pool_Hierarchy_1<T0> {
326 #[doc = "`.ctor(i32)` — overload selector"]
327 pub fn new(max: i32) -> Self {
328 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
329 panic!(
330 "{}
331::{}
332 failed to instantiate",
333 ::core::stringify!(Pool_Hierarchy_1),
334 ::core::stringify!(new),
335 )
336 });
337 <Self as IPool_Hierarchy_1Methods<T0>>::ctor(this, max);
338 this
339 }
340}
341
342#[cfg(feature = "app-pool")]
343#[::unity::methods]
344impl<T0: ::unity::ClassIdentity> Pool_Stack_1<T0> {
345 #[doc = "`.ctor(i32)` overload"]
346 #[method(name = ".ctor", args = 1)]
347 pub fn ctor(self, max: i32) -> ();
348
349 #[doc = "`Pop()` overload"]
350 #[method(name = "Pop", args = 0)]
351 pub fn pop(self) -> T0;
352
353 #[doc = "`Push(T0)` overload"]
354 #[method(name = "Push", args = 1)]
355 pub fn push(self, p: T0) -> ();
356}
357
358#[cfg(feature = "app-pool")]
359impl<T0: ::unity::ClassIdentity> Pool_Stack_1<T0> {
360 #[doc = "`.ctor(i32)` — overload selector"]
361 pub fn new(max: i32) -> Self {
362 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
363 panic!(
364 "{}
365::{}
366 failed to instantiate",
367 ::core::stringify!(Pool_Stack_1),
368 ::core::stringify!(new),
369 )
370 });
371 <Self as IPool_Stack_1Methods<T0>>::ctor(this, max);
372 this
373 }
374}
375
376#[cfg(feature = "app-pool")]
377pub trait IPoolMethods: IPool {
378 #[doc = "`.ctor()` overload"]
379 fn ctor(self) -> () {
380 unsafe {
381 let __receiver = <Pool as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
382 ::unity::il2cpp_call!((::unity::module_base()+0x2815560usize)as*mut u8,();
383(Pool)__receiver)
384 }
385 }
386}
387
388#[cfg(feature = "app-pool")]
389impl<__T: IPool> IPoolMethods for __T {}
390
391#[cfg(feature = "app-pool")]
392impl Pool {
393 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
394 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
395 }
396}
397
398#[cfg(feature = "app-pool")]
399impl Pool {
400 #[doc = "`.ctor()` — no args"]
401 pub fn new() -> Self {
402 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
403 panic!(
404 "{}
405::{}
406 failed to instantiate",
407 ::core::stringify!(Pool),
408 ::core::stringify!(new),
409 )
410 });
411 <Self as IPoolMethods>::ctor(this);
412 this
413 }
414}
415
416#[cfg(feature = "app-pool")]
417#[doc(hidden)]
418pub mod prelude {
419 pub use super::{
420 IPool, IPoolMethods, IPool_Hierarchy_1, IPool_Hierarchy_1Methods, IPool_List_1, IPool_List_1Methods, IPool_LockStack_1,
421 IPool_LockStack_1Methods, IPool_Node, IPool_NodeMethods, IPool_Stack_1, IPool_Stack_1Methods, Pool, Pool_Hierarchy_1, Pool_List_1,
422 Pool_LockStack_1, Pool_Node, Pool_Stack_1,
423 };
424 pub use crate::system::object::IObject;
425 #[cfg(feature = "system-object")]
426 pub use crate::system::object::IObjectMethods;
427}