1#[cfg(feature = "system-collections-arraylist-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/system/collections/arraylist/ArrayList_ArrayListDebugView.md"))]
11 #[::unity::class(namespace = "System.Collections", name = "ArrayList.ArrayListDebugView")]
12 #[parent(crate::system::object::Object)]
13 pub struct ArrayList_ArrayListDebugView {}
14
15 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/system/collections/arraylist/ArrayList.md"))]
16 #[::unity::class(namespace = "System.Collections", name = "ArrayList")]
17 #[parent(crate::system::object::Object)]
18 pub struct ArrayList {
19 #[offset(16)]
20 #[rename(name = "_items")]
21 pub items: ::unity::Array<crate::system::object::Object>,
22 #[offset(24)]
23 #[rename(name = "_size")]
24 pub size: i32,
25 #[offset(28)]
26 #[rename(name = "_version")]
27 pub version: i32,
28 #[offset(32)]
29 #[rename(name = "_syncRoot")]
30 pub sync_root: ::unity::IlInstance,
31 #[static_field]
32 #[rename(name = "emptyArray")]
33 pub empty_array: ::unity::Array<crate::system::object::Object>,
34 }
35
36 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/system/collections/arraylist/ArrayList_ArrayListEnumeratorSimple.md"))]
37 #[::unity::class(namespace = "System.Collections", name = "ArrayList.ArrayListEnumeratorSimple")]
38 #[parent(crate::system::object::Object)]
39 pub struct ArrayList_ArrayListEnumeratorSimple {
40 #[offset(16)]
41 #[rename(name = "list")]
42 pub list: crate::system::collections::arraylist::ArrayList,
43 #[offset(24)]
44 #[rename(name = "index")]
45 pub index: i32,
46 #[offset(28)]
47 #[rename(name = "version")]
48 pub version: i32,
49 #[offset(32)]
50 #[rename(name = "currentElement")]
51 pub current_element: ::unity::IlInstance,
52 #[offset(40)]
53 #[rename(name = "isArrayList")]
54 pub is_array_list: bool,
55 #[static_field]
56 #[rename(name = "dummyObject")]
57 pub dummy_object: ::unity::IlInstance,
58 }
59
60 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/system/collections/arraylist/ArrayList_ReadOnlyArrayList.md"))]
61 #[::unity::class(namespace = "System.Collections", name = "ArrayList.ReadOnlyArrayList")]
62 #[parent(crate::system::collections::arraylist::ArrayList)]
63 pub struct ArrayList_ReadOnlyArrayList {
64 #[offset(40)]
65 #[rename(name = "_list")]
66 pub list: crate::system::collections::arraylist::ArrayList,
67 }
68}
69
70#[cfg(feature = "system-collections-arraylist-types")]
71pub use __types::*;
72
73#[cfg(feature = "system-collections-arraylist")]
74impl ArrayList {
75 #[doc = "`ReadOnly(crate::system::collections::arraylist::ArrayList)` overload"]
76 pub fn read_only(
77 list: impl ::core::convert::Into<crate::system::collections::arraylist::ArrayList>,
78 ) -> crate::system::collections::arraylist::ArrayList {
79 unsafe {
80 ::unity::il2cpp_call!((::unity::module_base()+0x3400620usize)as*mut u8,crate::system::collections::arraylist::ArrayList;
81(crate::system::collections::arraylist::ArrayList)::core::convert::Into::into(list))
82 }
83 }
84
85 #[doc = "`.cctor()` overload"]
86 pub fn cctor() -> () {
87 unsafe {
88 ::unity::il2cpp_call!((::unity::module_base()+0x3400b40usize)as*mut u8,();
89 )
90 }
91 }
92}
93
94#[cfg(feature = "system-collections-arraylist")]
95pub trait IArrayListMethods: IArrayList {
96 #[doc = "`.ctor()` overload"]
97 fn ctor(self) -> () {
98 unsafe {
99 let __receiver = <ArrayList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
100 ::unity::il2cpp_call!((::unity::module_base()+0x33f2360usize)as*mut u8,();
101(ArrayList)__receiver)
102 }
103 }
104 #[doc = "`.ctor(i32)` overload"]
105 fn ctor_2(self, capacity: impl ::core::convert::Into<i32>) -> () {
106 unsafe {
107 let __receiver = <ArrayList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
108 ::unity::il2cpp_call!((::unity::module_base()+0x33ff5d0usize)as*mut u8,();
109(ArrayList)__receiver,(i32)::core::convert::Into::into(capacity))
110 }
111 }
112 #[doc = "`.ctor(crate::system::collections::icollection::ICollection)` overload"]
113 fn ctor_3(self, c: impl ::core::convert::Into<crate::system::collections::icollection::ICollection>) -> () {
114 unsafe {
115 let __receiver = <ArrayList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
116 ::unity::il2cpp_call!((::unity::module_base()+0x33ff740usize)as*mut u8,();
117(ArrayList)__receiver,(crate::system::collections::icollection::ICollection)::core::convert::Into::into(c))
118 }
119 }
120 #[doc = "`set_Capacity(i32)` overload"]
121 fn set_capacity(self, value: impl ::core::convert::Into<i32>) -> () {
122 unsafe {
123 let __receiver = <ArrayList 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(20usize).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 20usize,
134 __vt.len(),
135 <ArrayList as ::unity::ClassIdentity>::NAME,
136 "set_Capacity",
137 )
138 });
139 let __inner: extern "C" fn(ArrayList, i32, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
140 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
141 __inner(__receiver, ::core::convert::Into::into(value), __mi)
142 }
143 }
144 }
145 #[doc = "`get_Count()` overload"]
146 fn get_count(self) -> i32 {
147 unsafe {
148 let __receiver = <ArrayList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
149 {
150 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
151 let __vi = *__vt.get(21usize).unwrap_or_else(|| {
152 panic!(
153 "unity: virtual slot {}
154 out of range (vtable len {}
155) on the runtime class behind {}
156 (method `{}
157`)",
158 21usize,
159 __vt.len(),
160 <ArrayList as ::unity::ClassIdentity>::NAME,
161 "get_Count",
162 )
163 });
164 let __inner: extern "C" fn(ArrayList, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__vi.method_ptr);
165 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
166 __inner(__receiver, __mi)
167 }
168 }
169 }
170 #[doc = "`get_IsReadOnly()` overload"]
171 fn get_is_read_only(self) -> bool {
172 unsafe {
173 let __receiver = <ArrayList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
174 {
175 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
176 let __vi = *__vt.get(22usize).unwrap_or_else(|| {
177 panic!(
178 "unity: virtual slot {}
179 out of range (vtable len {}
180) on the runtime class behind {}
181 (method `{}
182`)",
183 22usize,
184 __vt.len(),
185 <ArrayList as ::unity::ClassIdentity>::NAME,
186 "get_IsReadOnly",
187 )
188 });
189 let __inner: extern "C" fn(ArrayList, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
190 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
191 __inner(__receiver, __mi)
192 }
193 }
194 }
195 #[doc = "`get_IsSynchronized()` overload"]
196 fn get_is_synchronized(self) -> bool {
197 unsafe {
198 let __receiver = <ArrayList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
199 {
200 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
201 let __vi = *__vt.get(23usize).unwrap_or_else(|| {
202 panic!(
203 "unity: virtual slot {}
204 out of range (vtable len {}
205) on the runtime class behind {}
206 (method `{}
207`)",
208 23usize,
209 __vt.len(),
210 <ArrayList as ::unity::ClassIdentity>::NAME,
211 "get_IsSynchronized",
212 )
213 });
214 let __inner: extern "C" fn(ArrayList, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
215 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
216 __inner(__receiver, __mi)
217 }
218 }
219 }
220 #[doc = "`get_SyncRoot()` overload"]
221 fn get_sync_root(self) -> crate::system::object::Object {
222 unsafe {
223 let __receiver = <ArrayList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
224 {
225 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
226 let __vi = *__vt.get(24usize).unwrap_or_else(|| {
227 panic!(
228 "unity: virtual slot {}
229 out of range (vtable len {}
230) on the runtime class behind {}
231 (method `{}
232`)",
233 24usize,
234 __vt.len(),
235 <ArrayList as ::unity::ClassIdentity>::NAME,
236 "get_SyncRoot",
237 )
238 });
239 let __inner: extern "C" fn(ArrayList, ::unity::OptionalMethod) -> crate::system::object::Object =
240 ::core::mem::transmute(__vi.method_ptr);
241 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
242 __inner(__receiver, __mi)
243 }
244 }
245 }
246 #[doc = "`get_Item(i32)` overload"]
247 fn get_item(self, index: impl ::core::convert::Into<i32>) -> crate::system::object::Object {
248 unsafe {
249 let __receiver = <ArrayList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
250 {
251 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
252 let __vi = *__vt.get(25usize).unwrap_or_else(|| {
253 panic!(
254 "unity: virtual slot {}
255 out of range (vtable len {}
256) on the runtime class behind {}
257 (method `{}
258`)",
259 25usize,
260 __vt.len(),
261 <ArrayList as ::unity::ClassIdentity>::NAME,
262 "get_Item",
263 )
264 });
265 let __inner: extern "C" fn(ArrayList, i32, ::unity::OptionalMethod) -> crate::system::object::Object =
266 ::core::mem::transmute(__vi.method_ptr);
267 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
268 __inner(__receiver, ::core::convert::Into::into(index), __mi)
269 }
270 }
271 }
272 #[doc = "`set_Item(i32, crate::system::object::Object)` overload"]
273 fn set_item(self, index: impl ::core::convert::Into<i32>, value: impl ::core::convert::Into<crate::system::object::Object>) -> () {
274 unsafe {
275 let __receiver = <ArrayList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
276 {
277 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
278 let __vi = *__vt.get(26usize).unwrap_or_else(|| {
279 panic!(
280 "unity: virtual slot {}
281 out of range (vtable len {}
282) on the runtime class behind {}
283 (method `{}
284`)",
285 26usize,
286 __vt.len(),
287 <ArrayList as ::unity::ClassIdentity>::NAME,
288 "set_Item",
289 )
290 });
291 let __inner: extern "C" fn(ArrayList, i32, crate::system::object::Object, ::unity::OptionalMethod) -> () =
292 ::core::mem::transmute(__vi.method_ptr);
293 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
294 __inner(__receiver, ::core::convert::Into::into(index), ::core::convert::Into::into(value), __mi)
295 }
296 }
297 }
298 #[doc = "`Add(crate::system::object::Object)` overload"]
299 fn add(self, value: impl ::core::convert::Into<crate::system::object::Object>) -> i32 {
300 unsafe {
301 let __receiver = <ArrayList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
302 {
303 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
304 let __vi = *__vt.get(27usize).unwrap_or_else(|| {
305 panic!(
306 "unity: virtual slot {}
307 out of range (vtable len {}
308) on the runtime class behind {}
309 (method `{}
310`)",
311 27usize,
312 __vt.len(),
313 <ArrayList as ::unity::ClassIdentity>::NAME,
314 "Add",
315 )
316 });
317 let __inner: extern "C" fn(ArrayList, crate::system::object::Object, ::unity::OptionalMethod) -> i32 =
318 ::core::mem::transmute(__vi.method_ptr);
319 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
320 __inner(__receiver, ::core::convert::Into::into(value), __mi)
321 }
322 }
323 }
324 #[doc = "`AddRange(crate::system::collections::icollection::ICollection)` overload"]
325 fn add_range(self, c: impl ::core::convert::Into<crate::system::collections::icollection::ICollection>) -> () {
326 unsafe {
327 let __receiver = <ArrayList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
328 {
329 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
330 let __vi = *__vt.get(28usize).unwrap_or_else(|| {
331 panic!(
332 "unity: virtual slot {}
333 out of range (vtable len {}
334) on the runtime class behind {}
335 (method `{}
336`)",
337 28usize,
338 __vt.len(),
339 <ArrayList as ::unity::ClassIdentity>::NAME,
340 "AddRange",
341 )
342 });
343 let __inner: extern "C" fn(ArrayList, crate::system::collections::icollection::ICollection, ::unity::OptionalMethod) -> () =
344 ::core::mem::transmute(__vi.method_ptr);
345 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
346 __inner(__receiver, ::core::convert::Into::into(c), __mi)
347 }
348 }
349 }
350 #[doc = "`Clear()` overload"]
351 fn clear(self) -> () {
352 unsafe {
353 let __receiver = <ArrayList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
354 {
355 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
356 let __vi = *__vt.get(29usize).unwrap_or_else(|| {
357 panic!(
358 "unity: virtual slot {}
359 out of range (vtable len {}
360) on the runtime class behind {}
361 (method `{}
362`)",
363 29usize,
364 __vt.len(),
365 <ArrayList as ::unity::ClassIdentity>::NAME,
366 "Clear",
367 )
368 });
369 let __inner: extern "C" fn(ArrayList, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
370 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
371 __inner(__receiver, __mi)
372 }
373 }
374 }
375 #[doc = "`Clone()` overload"]
376 fn clone(self) -> crate::system::object::Object {
377 unsafe {
378 let __receiver = <ArrayList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
379 {
380 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
381 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
382 panic!(
383 "unity: virtual slot {}
384 out of range (vtable len {}
385) on the runtime class behind {}
386 (method `{}
387`)",
388 30usize,
389 __vt.len(),
390 <ArrayList as ::unity::ClassIdentity>::NAME,
391 "Clone",
392 )
393 });
394 let __inner: extern "C" fn(ArrayList, ::unity::OptionalMethod) -> crate::system::object::Object =
395 ::core::mem::transmute(__vi.method_ptr);
396 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
397 __inner(__receiver, __mi)
398 }
399 }
400 }
401 #[doc = "`Contains(crate::system::object::Object)` overload"]
402 fn contains(self, item: impl ::core::convert::Into<crate::system::object::Object>) -> bool {
403 unsafe {
404 let __receiver = <ArrayList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
405 {
406 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
407 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
408 panic!(
409 "unity: virtual slot {}
410 out of range (vtable len {}
411) on the runtime class behind {}
412 (method `{}
413`)",
414 31usize,
415 __vt.len(),
416 <ArrayList as ::unity::ClassIdentity>::NAME,
417 "Contains",
418 )
419 });
420 let __inner: extern "C" fn(ArrayList, crate::system::object::Object, ::unity::OptionalMethod) -> bool =
421 ::core::mem::transmute(__vi.method_ptr);
422 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
423 __inner(__receiver, ::core::convert::Into::into(item), __mi)
424 }
425 }
426 }
427 #[doc = "`CopyTo(::unity::IlInstance)` overload"]
428 fn copy_to(self, array: impl ::core::convert::Into<::unity::IlInstance>) -> () {
429 unsafe {
430 let __receiver = <ArrayList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
431 {
432 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
433 let __vi = *__vt.get(32usize).unwrap_or_else(|| {
434 panic!(
435 "unity: virtual slot {}
436 out of range (vtable len {}
437) on the runtime class behind {}
438 (method `{}
439`)",
440 32usize,
441 __vt.len(),
442 <ArrayList as ::unity::ClassIdentity>::NAME,
443 "CopyTo",
444 )
445 });
446 let __inner: extern "C" fn(ArrayList, ::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
447 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
448 __inner(__receiver, ::core::convert::Into::into(array), __mi)
449 }
450 }
451 }
452 #[doc = "`CopyTo(::unity::IlInstance, i32)` overload"]
453 fn copy_to_2(self, array: impl ::core::convert::Into<::unity::IlInstance>, array_index: impl ::core::convert::Into<i32>) -> () {
454 unsafe {
455 let __receiver = <ArrayList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
456 {
457 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
458 let __vi = *__vt.get(33usize).unwrap_or_else(|| {
459 panic!(
460 "unity: virtual slot {}
461 out of range (vtable len {}
462) on the runtime class behind {}
463 (method `{}
464`)",
465 33usize,
466 __vt.len(),
467 <ArrayList as ::unity::ClassIdentity>::NAME,
468 "CopyTo",
469 )
470 });
471 let __inner: extern "C" fn(ArrayList, ::unity::IlInstance, i32, ::unity::OptionalMethod) -> () =
472 ::core::mem::transmute(__vi.method_ptr);
473 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
474 __inner(
475 __receiver,
476 ::core::convert::Into::into(array),
477 ::core::convert::Into::into(array_index),
478 __mi,
479 )
480 }
481 }
482 }
483 #[doc = "`CopyTo(i32, ::unity::IlInstance, i32, i32)` overload"]
484 fn copy_to_3(
485 self,
486 index: impl ::core::convert::Into<i32>,
487 array: impl ::core::convert::Into<::unity::IlInstance>,
488 array_index: impl ::core::convert::Into<i32>,
489 count: impl ::core::convert::Into<i32>,
490 ) -> () {
491 unsafe {
492 let __receiver = <ArrayList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
493 {
494 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
495 let __vi = *__vt.get(34usize).unwrap_or_else(|| {
496 panic!(
497 "unity: virtual slot {}
498 out of range (vtable len {}
499) on the runtime class behind {}
500 (method `{}
501`)",
502 34usize,
503 __vt.len(),
504 <ArrayList as ::unity::ClassIdentity>::NAME,
505 "CopyTo",
506 )
507 });
508 let __inner: extern "C" fn(ArrayList, i32, ::unity::IlInstance, i32, i32, ::unity::OptionalMethod) -> () =
509 ::core::mem::transmute(__vi.method_ptr);
510 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
511 __inner(
512 __receiver,
513 ::core::convert::Into::into(index),
514 ::core::convert::Into::into(array),
515 ::core::convert::Into::into(array_index),
516 ::core::convert::Into::into(count),
517 __mi,
518 )
519 }
520 }
521 }
522 #[doc = "`EnsureCapacity(i32)` overload"]
523 fn ensure_capacity(self, min: impl ::core::convert::Into<i32>) -> () {
524 unsafe {
525 let __receiver = <ArrayList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
526 ::unity::il2cpp_call!((::unity::module_base()+0x33ffdb0usize)as*mut u8,();
527(ArrayList)__receiver,(i32)::core::convert::Into::into(min))
528 }
529 }
530 #[doc = "`GetEnumerator()` overload"]
531 fn get_enumerator(self) -> crate::system::collections::ienumerator::IEnumerator {
532 unsafe {
533 let __receiver = <ArrayList 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(35usize).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 35usize,
544 __vt.len(),
545 <ArrayList as ::unity::ClassIdentity>::NAME,
546 "GetEnumerator",
547 )
548 });
549 let __inner: extern "C" fn(ArrayList, ::unity::OptionalMethod) -> crate::system::collections::ienumerator::IEnumerator =
550 ::core::mem::transmute(__vi.method_ptr);
551 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
552 __inner(__receiver, __mi)
553 }
554 }
555 }
556 #[doc = "`IndexOf(crate::system::object::Object)` overload"]
557 fn index_of(self, value: impl ::core::convert::Into<crate::system::object::Object>) -> i32 {
558 unsafe {
559 let __receiver = <ArrayList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
560 {
561 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
562 let __vi = *__vt.get(36usize).unwrap_or_else(|| {
563 panic!(
564 "unity: virtual slot {}
565 out of range (vtable len {}
566) on the runtime class behind {}
567 (method `{}
568`)",
569 36usize,
570 __vt.len(),
571 <ArrayList as ::unity::ClassIdentity>::NAME,
572 "IndexOf",
573 )
574 });
575 let __inner: extern "C" fn(ArrayList, crate::system::object::Object, ::unity::OptionalMethod) -> i32 =
576 ::core::mem::transmute(__vi.method_ptr);
577 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
578 __inner(__receiver, ::core::convert::Into::into(value), __mi)
579 }
580 }
581 }
582 #[doc = "`Insert(i32, crate::system::object::Object)` overload"]
583 fn insert(self, index: impl ::core::convert::Into<i32>, value: impl ::core::convert::Into<crate::system::object::Object>) -> () {
584 unsafe {
585 let __receiver = <ArrayList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
586 {
587 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
588 let __vi = *__vt.get(37usize).unwrap_or_else(|| {
589 panic!(
590 "unity: virtual slot {}
591 out of range (vtable len {}
592) on the runtime class behind {}
593 (method `{}
594`)",
595 37usize,
596 __vt.len(),
597 <ArrayList as ::unity::ClassIdentity>::NAME,
598 "Insert",
599 )
600 });
601 let __inner: extern "C" fn(ArrayList, i32, crate::system::object::Object, ::unity::OptionalMethod) -> () =
602 ::core::mem::transmute(__vi.method_ptr);
603 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
604 __inner(__receiver, ::core::convert::Into::into(index), ::core::convert::Into::into(value), __mi)
605 }
606 }
607 }
608 #[doc = "`InsertRange(i32, crate::system::collections::icollection::ICollection)` overload"]
609 fn insert_range(
610 self,
611 index: impl ::core::convert::Into<i32>,
612 c: impl ::core::convert::Into<crate::system::collections::icollection::ICollection>,
613 ) -> () {
614 unsafe {
615 let __receiver = <ArrayList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
616 {
617 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
618 let __vi = *__vt.get(38usize).unwrap_or_else(|| {
619 panic!(
620 "unity: virtual slot {}
621 out of range (vtable len {}
622) on the runtime class behind {}
623 (method `{}
624`)",
625 38usize,
626 __vt.len(),
627 <ArrayList as ::unity::ClassIdentity>::NAME,
628 "InsertRange",
629 )
630 });
631 let __inner: extern "C" fn(ArrayList, i32, crate::system::collections::icollection::ICollection, ::unity::OptionalMethod) -> () =
632 ::core::mem::transmute(__vi.method_ptr);
633 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
634 __inner(__receiver, ::core::convert::Into::into(index), ::core::convert::Into::into(c), __mi)
635 }
636 }
637 }
638 #[doc = "`Remove(crate::system::object::Object)` overload"]
639 fn remove(self, obj: impl ::core::convert::Into<crate::system::object::Object>) -> () {
640 unsafe {
641 let __receiver = <ArrayList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
642 {
643 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
644 let __vi = *__vt.get(39usize).unwrap_or_else(|| {
645 panic!(
646 "unity: virtual slot {}
647 out of range (vtable len {}
648) on the runtime class behind {}
649 (method `{}
650`)",
651 39usize,
652 __vt.len(),
653 <ArrayList as ::unity::ClassIdentity>::NAME,
654 "Remove",
655 )
656 });
657 let __inner: extern "C" fn(ArrayList, crate::system::object::Object, ::unity::OptionalMethod) -> () =
658 ::core::mem::transmute(__vi.method_ptr);
659 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
660 __inner(__receiver, ::core::convert::Into::into(obj), __mi)
661 }
662 }
663 }
664 #[doc = "`RemoveAt(i32)` overload"]
665 fn remove_at(self, index: impl ::core::convert::Into<i32>) -> () {
666 unsafe {
667 let __receiver = <ArrayList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
668 {
669 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
670 let __vi = *__vt.get(40usize).unwrap_or_else(|| {
671 panic!(
672 "unity: virtual slot {}
673 out of range (vtable len {}
674) on the runtime class behind {}
675 (method `{}
676`)",
677 40usize,
678 __vt.len(),
679 <ArrayList as ::unity::ClassIdentity>::NAME,
680 "RemoveAt",
681 )
682 });
683 let __inner: extern "C" fn(ArrayList, i32, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
684 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
685 __inner(__receiver, ::core::convert::Into::into(index), __mi)
686 }
687 }
688 }
689 #[doc = "`RemoveRange(i32, i32)` overload"]
690 fn remove_range(self, index: impl ::core::convert::Into<i32>, count: impl ::core::convert::Into<i32>) -> () {
691 unsafe {
692 let __receiver = <ArrayList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
693 {
694 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
695 let __vi = *__vt.get(41usize).unwrap_or_else(|| {
696 panic!(
697 "unity: virtual slot {}
698 out of range (vtable len {}
699) on the runtime class behind {}
700 (method `{}
701`)",
702 41usize,
703 __vt.len(),
704 <ArrayList as ::unity::ClassIdentity>::NAME,
705 "RemoveRange",
706 )
707 });
708 let __inner: extern "C" fn(ArrayList, i32, i32, ::unity::OptionalMethod) -> () = ::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(__receiver, ::core::convert::Into::into(index), ::core::convert::Into::into(count), __mi)
711 }
712 }
713 }
714 #[doc = "`ToArray()` overload"]
715 fn to_array(self) -> ::unity::Array<crate::system::object::Object> {
716 unsafe {
717 let __receiver = <ArrayList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
718 {
719 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
720 let __vi = *__vt.get(42usize).unwrap_or_else(|| {
721 panic!(
722 "unity: virtual slot {}
723 out of range (vtable len {}
724) on the runtime class behind {}
725 (method `{}
726`)",
727 42usize,
728 __vt.len(),
729 <ArrayList as ::unity::ClassIdentity>::NAME,
730 "ToArray",
731 )
732 });
733 let __inner: extern "C" fn(ArrayList, ::unity::OptionalMethod) -> ::unity::Array<crate::system::object::Object> =
734 ::core::mem::transmute(__vi.method_ptr);
735 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
736 __inner(__receiver, __mi)
737 }
738 }
739 }
740 #[doc = "`ToArray(::unity::SystemType)` overload"]
741 fn to_array_2(self, r#type: impl ::core::convert::Into<::unity::SystemType>) -> ::unity::IlInstance {
742 unsafe {
743 let __receiver = <ArrayList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
744 {
745 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
746 let __vi = *__vt.get(43usize).unwrap_or_else(|| {
747 panic!(
748 "unity: virtual slot {}
749 out of range (vtable len {}
750) on the runtime class behind {}
751 (method `{}
752`)",
753 43usize,
754 __vt.len(),
755 <ArrayList as ::unity::ClassIdentity>::NAME,
756 "ToArray",
757 )
758 });
759 let __inner: extern "C" fn(ArrayList, ::unity::SystemType, ::unity::OptionalMethod) -> ::unity::IlInstance =
760 ::core::mem::transmute(__vi.method_ptr);
761 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
762 __inner(__receiver, ::core::convert::Into::into(r#type), __mi)
763 }
764 }
765 }
766}
767
768#[cfg(feature = "system-collections-arraylist")]
769impl<__T: IArrayList> IArrayListMethods for __T {}
770
771#[cfg(feature = "system-collections-arraylist")]
772impl ArrayList {
773 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
774 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
775 }
776
777 pub fn ctor_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
778 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
779 }
780
781 pub fn ctor_3_method_info() -> &'static ::unity::il2cpp::MethodInfo {
782 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
783 }
784
785 pub fn set_capacity_method_info() -> &'static ::unity::il2cpp::MethodInfo {
786 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
787 }
788
789 pub fn get_count_method_info() -> &'static ::unity::il2cpp::MethodInfo {
790 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
791 }
792
793 pub fn get_is_read_only_method_info() -> &'static ::unity::il2cpp::MethodInfo {
794 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
795 }
796
797 pub fn get_is_synchronized_method_info() -> &'static ::unity::il2cpp::MethodInfo {
798 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
799 }
800
801 pub fn get_sync_root_method_info() -> &'static ::unity::il2cpp::MethodInfo {
802 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
803 }
804
805 pub fn get_item_method_info() -> &'static ::unity::il2cpp::MethodInfo {
806 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[8]
807 }
808
809 pub fn set_item_method_info() -> &'static ::unity::il2cpp::MethodInfo {
810 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[9]
811 }
812
813 pub fn add_method_info() -> &'static ::unity::il2cpp::MethodInfo {
814 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[10]
815 }
816
817 pub fn add_range_method_info() -> &'static ::unity::il2cpp::MethodInfo {
818 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[11]
819 }
820
821 pub fn clear_method_info() -> &'static ::unity::il2cpp::MethodInfo {
822 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[12]
823 }
824
825 pub fn clone_method_info() -> &'static ::unity::il2cpp::MethodInfo {
826 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[13]
827 }
828
829 pub fn contains_method_info() -> &'static ::unity::il2cpp::MethodInfo {
830 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[14]
831 }
832
833 pub fn copy_to_method_info() -> &'static ::unity::il2cpp::MethodInfo {
834 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[15]
835 }
836
837 pub fn copy_to_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
838 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[16]
839 }
840
841 pub fn copy_to_3_method_info() -> &'static ::unity::il2cpp::MethodInfo {
842 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[17]
843 }
844
845 pub fn ensure_capacity_method_info() -> &'static ::unity::il2cpp::MethodInfo {
846 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[18]
847 }
848
849 pub fn get_enumerator_method_info() -> &'static ::unity::il2cpp::MethodInfo {
850 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[19]
851 }
852
853 pub fn index_of_method_info() -> &'static ::unity::il2cpp::MethodInfo {
854 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[20]
855 }
856
857 pub fn insert_method_info() -> &'static ::unity::il2cpp::MethodInfo {
858 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[21]
859 }
860
861 pub fn insert_range_method_info() -> &'static ::unity::il2cpp::MethodInfo {
862 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[22]
863 }
864
865 pub fn read_only_method_info() -> &'static ::unity::il2cpp::MethodInfo {
866 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[23]
867 }
868
869 pub fn remove_method_info() -> &'static ::unity::il2cpp::MethodInfo {
870 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[24]
871 }
872
873 pub fn remove_at_method_info() -> &'static ::unity::il2cpp::MethodInfo {
874 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[25]
875 }
876
877 pub fn remove_range_method_info() -> &'static ::unity::il2cpp::MethodInfo {
878 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[26]
879 }
880
881 pub fn to_array_method_info() -> &'static ::unity::il2cpp::MethodInfo {
882 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[27]
883 }
884
885 pub fn to_array_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
886 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[28]
887 }
888
889 pub fn cctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
890 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[29]
891 }
892}
893
894#[cfg(feature = "system-collections-arraylist")]
895impl ArrayList {
896 #[doc = "Direct (non-virtual) call to `ArrayList`'s own `set_Capacity`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
897 pub unsafe fn set_capacity(this: impl ::core::convert::Into<::unity::IlInstance>, value: i32) -> () {
898 let __mi = Self::set_capacity_method_info();
899 let __inner: extern "C" fn(::unity::IlInstance, i32, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
900 __inner(this.into(), value, ::core::option::Option::None)
901 }
902
903 #[doc = "Direct (non-virtual) call to `ArrayList`'s own `get_Count`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
904 pub unsafe fn get_count(this: impl ::core::convert::Into<::unity::IlInstance>) -> i32 {
905 let __mi = Self::get_count_method_info();
906 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__mi.method_ptr);
907 __inner(this.into(), ::core::option::Option::None)
908 }
909
910 #[doc = "Direct (non-virtual) call to `ArrayList`'s own `get_IsReadOnly`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
911 pub unsafe fn get_is_read_only(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
912 let __mi = Self::get_is_read_only_method_info();
913 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
914 __inner(this.into(), ::core::option::Option::None)
915 }
916
917 #[doc = "Direct (non-virtual) call to `ArrayList`'s own `get_IsSynchronized`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
918 pub unsafe fn get_is_synchronized(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
919 let __mi = Self::get_is_synchronized_method_info();
920 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
921 __inner(this.into(), ::core::option::Option::None)
922 }
923
924 #[doc = "Direct (non-virtual) call to `ArrayList`'s own `get_SyncRoot`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
925 pub unsafe fn get_sync_root(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::system::object::Object {
926 let __mi = Self::get_sync_root_method_info();
927 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::system::object::Object =
928 ::core::mem::transmute(__mi.method_ptr);
929 __inner(this.into(), ::core::option::Option::None)
930 }
931
932 #[doc = "Direct (non-virtual) call to `ArrayList`'s own `get_Item`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
933 pub unsafe fn get_item(this: impl ::core::convert::Into<::unity::IlInstance>, index: i32) -> crate::system::object::Object {
934 let __mi = Self::get_item_method_info();
935 let __inner: extern "C" fn(::unity::IlInstance, i32, ::unity::OptionalMethod) -> crate::system::object::Object =
936 ::core::mem::transmute(__mi.method_ptr);
937 __inner(this.into(), index, ::core::option::Option::None)
938 }
939
940 #[doc = "Direct (non-virtual) call to `ArrayList`'s own `set_Item`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
941 pub unsafe fn set_item(this: impl ::core::convert::Into<::unity::IlInstance>, index: i32, value: crate::system::object::Object) -> () {
942 let __mi = Self::set_item_method_info();
943 let __inner: extern "C" fn(::unity::IlInstance, i32, crate::system::object::Object, ::unity::OptionalMethod) -> () =
944 ::core::mem::transmute(__mi.method_ptr);
945 __inner(this.into(), index, value, ::core::option::Option::None)
946 }
947
948 #[doc = "Direct (non-virtual) call to `ArrayList`'s own `Add`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
949 pub unsafe fn add(this: impl ::core::convert::Into<::unity::IlInstance>, value: crate::system::object::Object) -> i32 {
950 let __mi = Self::add_method_info();
951 let __inner: extern "C" fn(::unity::IlInstance, crate::system::object::Object, ::unity::OptionalMethod) -> i32 =
952 ::core::mem::transmute(__mi.method_ptr);
953 __inner(this.into(), value, ::core::option::Option::None)
954 }
955
956 #[doc = "Direct (non-virtual) call to `ArrayList`'s own `AddRange`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
957 pub unsafe fn add_range(this: impl ::core::convert::Into<::unity::IlInstance>, c: crate::system::collections::icollection::ICollection) -> () {
958 let __mi = Self::add_range_method_info();
959 let __inner: extern "C" fn(::unity::IlInstance, crate::system::collections::icollection::ICollection, ::unity::OptionalMethod) -> () =
960 ::core::mem::transmute(__mi.method_ptr);
961 __inner(this.into(), c, ::core::option::Option::None)
962 }
963
964 #[doc = "Direct (non-virtual) call to `ArrayList`'s own `Clear`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
965 pub unsafe fn clear(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
966 let __mi = Self::clear_method_info();
967 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
968 __inner(this.into(), ::core::option::Option::None)
969 }
970
971 #[doc = "Direct (non-virtual) call to `ArrayList`'s own `Clone`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
972 pub unsafe fn clone(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::system::object::Object {
973 let __mi = Self::clone_method_info();
974 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::system::object::Object =
975 ::core::mem::transmute(__mi.method_ptr);
976 __inner(this.into(), ::core::option::Option::None)
977 }
978
979 #[doc = "Direct (non-virtual) call to `ArrayList`'s own `Contains`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
980 pub unsafe fn contains(this: impl ::core::convert::Into<::unity::IlInstance>, item: crate::system::object::Object) -> bool {
981 let __mi = Self::contains_method_info();
982 let __inner: extern "C" fn(::unity::IlInstance, crate::system::object::Object, ::unity::OptionalMethod) -> bool =
983 ::core::mem::transmute(__mi.method_ptr);
984 __inner(this.into(), item, ::core::option::Option::None)
985 }
986
987 #[doc = "Direct (non-virtual) call to `ArrayList`'s own `CopyTo`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
988 pub unsafe fn copy_to(this: impl ::core::convert::Into<::unity::IlInstance>, array: ::unity::IlInstance) -> () {
989 let __mi = Self::copy_to_method_info();
990 let __inner: extern "C" fn(::unity::IlInstance, ::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
991 __inner(this.into(), array, ::core::option::Option::None)
992 }
993
994 #[doc = "Direct (non-virtual) call to `ArrayList`'s own `CopyTo`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
995 pub unsafe fn copy_to_2(this: impl ::core::convert::Into<::unity::IlInstance>, array: ::unity::IlInstance, array_index: i32) -> () {
996 let __mi = Self::copy_to_2_method_info();
997 let __inner: extern "C" fn(::unity::IlInstance, ::unity::IlInstance, i32, ::unity::OptionalMethod) -> () =
998 ::core::mem::transmute(__mi.method_ptr);
999 __inner(this.into(), array, array_index, ::core::option::Option::None)
1000 }
1001
1002 #[doc = "Direct (non-virtual) call to `ArrayList`'s own `CopyTo`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1003 pub unsafe fn copy_to_3(
1004 this: impl ::core::convert::Into<::unity::IlInstance>,
1005 index: i32,
1006 array: ::unity::IlInstance,
1007 array_index: i32,
1008 count: i32,
1009 ) -> () {
1010 let __mi = Self::copy_to_3_method_info();
1011 let __inner: extern "C" fn(::unity::IlInstance, i32, ::unity::IlInstance, i32, i32, ::unity::OptionalMethod) -> () =
1012 ::core::mem::transmute(__mi.method_ptr);
1013 __inner(this.into(), index, array, array_index, count, ::core::option::Option::None)
1014 }
1015
1016 #[doc = "Direct (non-virtual) call to `ArrayList`'s own `GetEnumerator`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1017 pub unsafe fn get_enumerator(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::system::collections::ienumerator::IEnumerator {
1018 let __mi = Self::get_enumerator_method_info();
1019 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::system::collections::ienumerator::IEnumerator =
1020 ::core::mem::transmute(__mi.method_ptr);
1021 __inner(this.into(), ::core::option::Option::None)
1022 }
1023
1024 #[doc = "Direct (non-virtual) call to `ArrayList`'s own `IndexOf`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1025 pub unsafe fn index_of(this: impl ::core::convert::Into<::unity::IlInstance>, value: crate::system::object::Object) -> i32 {
1026 let __mi = Self::index_of_method_info();
1027 let __inner: extern "C" fn(::unity::IlInstance, crate::system::object::Object, ::unity::OptionalMethod) -> i32 =
1028 ::core::mem::transmute(__mi.method_ptr);
1029 __inner(this.into(), value, ::core::option::Option::None)
1030 }
1031
1032 #[doc = "Direct (non-virtual) call to `ArrayList`'s own `Insert`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1033 pub unsafe fn insert(this: impl ::core::convert::Into<::unity::IlInstance>, index: i32, value: crate::system::object::Object) -> () {
1034 let __mi = Self::insert_method_info();
1035 let __inner: extern "C" fn(::unity::IlInstance, i32, crate::system::object::Object, ::unity::OptionalMethod) -> () =
1036 ::core::mem::transmute(__mi.method_ptr);
1037 __inner(this.into(), index, value, ::core::option::Option::None)
1038 }
1039
1040 #[doc = "Direct (non-virtual) call to `ArrayList`'s own `InsertRange`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1041 pub unsafe fn insert_range(
1042 this: impl ::core::convert::Into<::unity::IlInstance>,
1043 index: i32,
1044 c: crate::system::collections::icollection::ICollection,
1045 ) -> () {
1046 let __mi = Self::insert_range_method_info();
1047 let __inner: extern "C" fn(::unity::IlInstance, i32, crate::system::collections::icollection::ICollection, ::unity::OptionalMethod) -> () =
1048 ::core::mem::transmute(__mi.method_ptr);
1049 __inner(this.into(), index, c, ::core::option::Option::None)
1050 }
1051
1052 #[doc = "Direct (non-virtual) call to `ArrayList`'s own `Remove`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1053 pub unsafe fn remove(this: impl ::core::convert::Into<::unity::IlInstance>, obj: crate::system::object::Object) -> () {
1054 let __mi = Self::remove_method_info();
1055 let __inner: extern "C" fn(::unity::IlInstance, crate::system::object::Object, ::unity::OptionalMethod) -> () =
1056 ::core::mem::transmute(__mi.method_ptr);
1057 __inner(this.into(), obj, ::core::option::Option::None)
1058 }
1059
1060 #[doc = "Direct (non-virtual) call to `ArrayList`'s own `RemoveAt`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1061 pub unsafe fn remove_at(this: impl ::core::convert::Into<::unity::IlInstance>, index: i32) -> () {
1062 let __mi = Self::remove_at_method_info();
1063 let __inner: extern "C" fn(::unity::IlInstance, i32, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
1064 __inner(this.into(), index, ::core::option::Option::None)
1065 }
1066
1067 #[doc = "Direct (non-virtual) call to `ArrayList`'s own `RemoveRange`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1068 pub unsafe fn remove_range(this: impl ::core::convert::Into<::unity::IlInstance>, index: i32, count: i32) -> () {
1069 let __mi = Self::remove_range_method_info();
1070 let __inner: extern "C" fn(::unity::IlInstance, i32, i32, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
1071 __inner(this.into(), index, count, ::core::option::Option::None)
1072 }
1073
1074 #[doc = "Direct (non-virtual) call to `ArrayList`'s own `ToArray`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1075 pub unsafe fn to_array(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Array<crate::system::object::Object> {
1076 let __mi = Self::to_array_method_info();
1077 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Array<crate::system::object::Object> =
1078 ::core::mem::transmute(__mi.method_ptr);
1079 __inner(this.into(), ::core::option::Option::None)
1080 }
1081
1082 #[doc = "Direct (non-virtual) call to `ArrayList`'s own `ToArray`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1083 pub unsafe fn to_array_2(this: impl ::core::convert::Into<::unity::IlInstance>, r#type: ::unity::SystemType) -> ::unity::IlInstance {
1084 let __mi = Self::to_array_2_method_info();
1085 let __inner: extern "C" fn(::unity::IlInstance, ::unity::SystemType, ::unity::OptionalMethod) -> ::unity::IlInstance =
1086 ::core::mem::transmute(__mi.method_ptr);
1087 __inner(this.into(), r#type, ::core::option::Option::None)
1088 }
1089}
1090
1091#[cfg(feature = "system-collections-arraylist")]
1092impl ArrayList {
1093 #[doc = "`.ctor()` — no args"]
1094 pub fn new() -> Self {
1095 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1096 panic!(
1097 "{}
1098::{}
1099 failed to instantiate",
1100 ::core::stringify!(ArrayList),
1101 ::core::stringify!(new),
1102 )
1103 });
1104 <Self as IArrayListMethods>::ctor(this);
1105 this
1106 }
1107
1108 #[doc = "`.ctor(i32)` — overload selector"]
1109 pub fn new_2(capacity: i32) -> Self {
1110 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1111 panic!(
1112 "{}
1113::{}
1114 failed to instantiate",
1115 ::core::stringify!(ArrayList),
1116 ::core::stringify!(new_2),
1117 )
1118 });
1119 <Self as IArrayListMethods>::ctor_2(this, capacity);
1120 this
1121 }
1122
1123 #[doc = "`.ctor(crate::system::collections::icollection::ICollection)` — overload selector"]
1124 pub fn new_3(c: crate::system::collections::icollection::ICollection) -> Self {
1125 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1126 panic!(
1127 "{}
1128::{}
1129 failed to instantiate",
1130 ::core::stringify!(ArrayList),
1131 ::core::stringify!(new_3),
1132 )
1133 });
1134 <Self as IArrayListMethods>::ctor_3(this, c);
1135 this
1136 }
1137}
1138
1139#[cfg(feature = "system-collections-arraylist")]
1140impl ArrayList_ArrayListEnumeratorSimple {
1141 #[doc = "`.cctor()` overload"]
1142 pub fn cctor() -> () {
1143 unsafe {
1144 ::unity::il2cpp_call!((::unity::module_base()+0x34cd4d0usize)as*mut u8,();
1145 )
1146 }
1147 }
1148}
1149
1150#[cfg(feature = "system-collections-arraylist")]
1151pub trait IArrayList_ArrayListEnumeratorSimpleMethods: IArrayList_ArrayListEnumeratorSimple {
1152 #[doc = "`.ctor(crate::system::collections::arraylist::ArrayList)` overload"]
1153 fn ctor(self, list: impl ::core::convert::Into<crate::system::collections::arraylist::ArrayList>) -> () {
1154 unsafe {
1155 let __receiver = <ArrayList_ArrayListEnumeratorSimple as ::unity::FromIlInstance>::from_il_instance(
1156 <Self as ::unity::SystemObject>::as_instance(self),
1157 );
1158 ::unity::il2cpp_call!((::unity::module_base()+0x34ccfd0usize)as*mut u8,();
1159(ArrayList_ArrayListEnumeratorSimple)__receiver,(crate::system::collections::arraylist::ArrayList)::core::convert::Into::into(list))
1160 }
1161 }
1162 #[doc = "`Clone()` overload"]
1163 fn clone(self) -> crate::system::object::Object {
1164 unsafe {
1165 let __receiver = <ArrayList_ArrayListEnumeratorSimple as ::unity::FromIlInstance>::from_il_instance(
1166 <Self as ::unity::SystemObject>::as_instance(self),
1167 );
1168 {
1169 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1170 let __vi = *__vt.get(7usize).unwrap_or_else(|| {
1171 panic!(
1172 "unity: virtual slot {}
1173 out of range (vtable len {}
1174) on the runtime class behind {}
1175 (method `{}
1176`)",
1177 7usize,
1178 __vt.len(),
1179 <ArrayList_ArrayListEnumeratorSimple as ::unity::ClassIdentity>::NAME,
1180 "Clone",
1181 )
1182 });
1183 let __inner: extern "C" fn(ArrayList_ArrayListEnumeratorSimple, ::unity::OptionalMethod) -> crate::system::object::Object =
1184 ::core::mem::transmute(__vi.method_ptr);
1185 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1186 __inner(__receiver, __mi)
1187 }
1188 }
1189 }
1190 #[doc = "`MoveNext()` overload"]
1191 fn move_next(self) -> bool {
1192 unsafe {
1193 let __receiver = <ArrayList_ArrayListEnumeratorSimple as ::unity::FromIlInstance>::from_il_instance(
1194 <Self as ::unity::SystemObject>::as_instance(self),
1195 );
1196 {
1197 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1198 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
1199 panic!(
1200 "unity: virtual slot {}
1201 out of range (vtable len {}
1202) on the runtime class behind {}
1203 (method `{}
1204`)",
1205 4usize,
1206 __vt.len(),
1207 <ArrayList_ArrayListEnumeratorSimple as ::unity::ClassIdentity>::NAME,
1208 "MoveNext",
1209 )
1210 });
1211 let __inner: extern "C" fn(ArrayList_ArrayListEnumeratorSimple, ::unity::OptionalMethod) -> bool =
1212 ::core::mem::transmute(__vi.method_ptr);
1213 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1214 __inner(__receiver, __mi)
1215 }
1216 }
1217 }
1218 #[doc = "`get_Current()` overload"]
1219 fn get_current(self) -> crate::system::object::Object {
1220 unsafe {
1221 let __receiver = <ArrayList_ArrayListEnumeratorSimple as ::unity::FromIlInstance>::from_il_instance(
1222 <Self as ::unity::SystemObject>::as_instance(self),
1223 );
1224 {
1225 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1226 let __vi = *__vt.get(5usize).unwrap_or_else(|| {
1227 panic!(
1228 "unity: virtual slot {}
1229 out of range (vtable len {}
1230) on the runtime class behind {}
1231 (method `{}
1232`)",
1233 5usize,
1234 __vt.len(),
1235 <ArrayList_ArrayListEnumeratorSimple as ::unity::ClassIdentity>::NAME,
1236 "get_Current",
1237 )
1238 });
1239 let __inner: extern "C" fn(ArrayList_ArrayListEnumeratorSimple, ::unity::OptionalMethod) -> crate::system::object::Object =
1240 ::core::mem::transmute(__vi.method_ptr);
1241 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1242 __inner(__receiver, __mi)
1243 }
1244 }
1245 }
1246 #[doc = "`Reset()` overload"]
1247 fn reset(self) -> () {
1248 unsafe {
1249 let __receiver = <ArrayList_ArrayListEnumeratorSimple as ::unity::FromIlInstance>::from_il_instance(
1250 <Self as ::unity::SystemObject>::as_instance(self),
1251 );
1252 {
1253 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1254 let __vi = *__vt.get(6usize).unwrap_or_else(|| {
1255 panic!(
1256 "unity: virtual slot {}
1257 out of range (vtable len {}
1258) on the runtime class behind {}
1259 (method `{}
1260`)",
1261 6usize,
1262 __vt.len(),
1263 <ArrayList_ArrayListEnumeratorSimple as ::unity::ClassIdentity>::NAME,
1264 "Reset",
1265 )
1266 });
1267 let __inner: extern "C" fn(ArrayList_ArrayListEnumeratorSimple, ::unity::OptionalMethod) -> () =
1268 ::core::mem::transmute(__vi.method_ptr);
1269 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1270 __inner(__receiver, __mi)
1271 }
1272 }
1273 }
1274}
1275
1276#[cfg(feature = "system-collections-arraylist")]
1277impl<__T: IArrayList_ArrayListEnumeratorSimple> IArrayList_ArrayListEnumeratorSimpleMethods for __T {}
1278
1279#[cfg(feature = "system-collections-arraylist")]
1280impl ArrayList_ArrayListEnumeratorSimple {
1281 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1282 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
1283 }
1284
1285 pub fn clone_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1286 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
1287 }
1288
1289 pub fn move_next_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1290 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
1291 }
1292
1293 pub fn get_current_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1294 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
1295 }
1296
1297 pub fn reset_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1298 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
1299 }
1300
1301 pub fn cctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1302 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
1303 }
1304}
1305
1306#[cfg(feature = "system-collections-arraylist")]
1307impl ArrayList_ArrayListEnumeratorSimple {
1308 #[doc = "Direct (non-virtual) call to `ArrayList_ArrayListEnumeratorSimple`'s own `Clone`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1309 pub unsafe fn clone(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::system::object::Object {
1310 let __mi = Self::clone_method_info();
1311 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::system::object::Object =
1312 ::core::mem::transmute(__mi.method_ptr);
1313 __inner(this.into(), ::core::option::Option::None)
1314 }
1315
1316 #[doc = "Direct (non-virtual) call to `ArrayList_ArrayListEnumeratorSimple`'s own `MoveNext`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1317 pub unsafe fn move_next(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
1318 let __mi = Self::move_next_method_info();
1319 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
1320 __inner(this.into(), ::core::option::Option::None)
1321 }
1322
1323 #[doc = "Direct (non-virtual) call to `ArrayList_ArrayListEnumeratorSimple`'s own `get_Current`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1324 pub unsafe fn get_current(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::system::object::Object {
1325 let __mi = Self::get_current_method_info();
1326 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::system::object::Object =
1327 ::core::mem::transmute(__mi.method_ptr);
1328 __inner(this.into(), ::core::option::Option::None)
1329 }
1330
1331 #[doc = "Direct (non-virtual) call to `ArrayList_ArrayListEnumeratorSimple`'s own `Reset`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1332 pub unsafe fn reset(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
1333 let __mi = Self::reset_method_info();
1334 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
1335 __inner(this.into(), ::core::option::Option::None)
1336 }
1337}
1338
1339#[cfg(feature = "system-collections-arraylist")]
1340impl ArrayList_ArrayListEnumeratorSimple {
1341 #[doc = "`.ctor(crate::system::collections::arraylist::ArrayList)` — overload selector"]
1342 pub fn new(list: crate::system::collections::arraylist::ArrayList) -> Self {
1343 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1344 panic!(
1345 "{}
1346::{}
1347 failed to instantiate",
1348 ::core::stringify!(ArrayList_ArrayListEnumeratorSimple),
1349 ::core::stringify!(new),
1350 )
1351 });
1352 <Self as IArrayList_ArrayListEnumeratorSimpleMethods>::ctor(this, list);
1353 this
1354 }
1355}
1356
1357#[cfg(feature = "system-collections-arraylist")]
1358pub trait IArrayList_ReadOnlyArrayListMethods: IArrayList_ReadOnlyArrayList {
1359 #[doc = "`.ctor(crate::system::collections::arraylist::ArrayList)` overload"]
1360 fn ctor(self, l: impl ::core::convert::Into<crate::system::collections::arraylist::ArrayList>) -> () {
1361 unsafe {
1362 let __receiver =
1363 <ArrayList_ReadOnlyArrayList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1364 ::unity::il2cpp_call!((::unity::module_base()+0x34cd550usize)as*mut u8,();
1365(ArrayList_ReadOnlyArrayList)__receiver,(crate::system::collections::arraylist::ArrayList)::core::convert::Into::into(l))
1366 }
1367 }
1368 #[doc = "`get_Count()` overload"]
1369 fn get_count(self) -> i32 {
1370 unsafe {
1371 let __receiver =
1372 <ArrayList_ReadOnlyArrayList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1373 {
1374 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1375 let __vi = *__vt.get(21usize).unwrap_or_else(|| {
1376 panic!(
1377 "unity: virtual slot {}
1378 out of range (vtable len {}
1379) on the runtime class behind {}
1380 (method `{}
1381`)",
1382 21usize,
1383 __vt.len(),
1384 <ArrayList_ReadOnlyArrayList as ::unity::ClassIdentity>::NAME,
1385 "get_Count",
1386 )
1387 });
1388 let __inner: extern "C" fn(ArrayList_ReadOnlyArrayList, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__vi.method_ptr);
1389 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1390 __inner(__receiver, __mi)
1391 }
1392 }
1393 }
1394 #[doc = "`get_IsReadOnly()` overload"]
1395 fn get_is_read_only(self) -> bool {
1396 unsafe {
1397 let __receiver =
1398 <ArrayList_ReadOnlyArrayList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1399 {
1400 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1401 let __vi = *__vt.get(22usize).unwrap_or_else(|| {
1402 panic!(
1403 "unity: virtual slot {}
1404 out of range (vtable len {}
1405) on the runtime class behind {}
1406 (method `{}
1407`)",
1408 22usize,
1409 __vt.len(),
1410 <ArrayList_ReadOnlyArrayList as ::unity::ClassIdentity>::NAME,
1411 "get_IsReadOnly",
1412 )
1413 });
1414 let __inner: extern "C" fn(ArrayList_ReadOnlyArrayList, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
1415 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1416 __inner(__receiver, __mi)
1417 }
1418 }
1419 }
1420 #[doc = "`get_IsSynchronized()` overload"]
1421 fn get_is_synchronized(self) -> bool {
1422 unsafe {
1423 let __receiver =
1424 <ArrayList_ReadOnlyArrayList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1425 {
1426 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1427 let __vi = *__vt.get(23usize).unwrap_or_else(|| {
1428 panic!(
1429 "unity: virtual slot {}
1430 out of range (vtable len {}
1431) on the runtime class behind {}
1432 (method `{}
1433`)",
1434 23usize,
1435 __vt.len(),
1436 <ArrayList_ReadOnlyArrayList as ::unity::ClassIdentity>::NAME,
1437 "get_IsSynchronized",
1438 )
1439 });
1440 let __inner: extern "C" fn(ArrayList_ReadOnlyArrayList, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
1441 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1442 __inner(__receiver, __mi)
1443 }
1444 }
1445 }
1446 #[doc = "`get_Item(i32)` overload"]
1447 fn get_item(self, index: impl ::core::convert::Into<i32>) -> crate::system::object::Object {
1448 unsafe {
1449 let __receiver =
1450 <ArrayList_ReadOnlyArrayList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1451 {
1452 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1453 let __vi = *__vt.get(25usize).unwrap_or_else(|| {
1454 panic!(
1455 "unity: virtual slot {}
1456 out of range (vtable len {}
1457) on the runtime class behind {}
1458 (method `{}
1459`)",
1460 25usize,
1461 __vt.len(),
1462 <ArrayList_ReadOnlyArrayList as ::unity::ClassIdentity>::NAME,
1463 "get_Item",
1464 )
1465 });
1466 let __inner: extern "C" fn(ArrayList_ReadOnlyArrayList, i32, ::unity::OptionalMethod) -> crate::system::object::Object =
1467 ::core::mem::transmute(__vi.method_ptr);
1468 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1469 __inner(__receiver, ::core::convert::Into::into(index), __mi)
1470 }
1471 }
1472 }
1473 #[doc = "`set_Item(i32, crate::system::object::Object)` overload"]
1474 fn set_item(self, index: impl ::core::convert::Into<i32>, value: impl ::core::convert::Into<crate::system::object::Object>) -> () {
1475 unsafe {
1476 let __receiver =
1477 <ArrayList_ReadOnlyArrayList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1478 {
1479 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1480 let __vi = *__vt.get(26usize).unwrap_or_else(|| {
1481 panic!(
1482 "unity: virtual slot {}
1483 out of range (vtable len {}
1484) on the runtime class behind {}
1485 (method `{}
1486`)",
1487 26usize,
1488 __vt.len(),
1489 <ArrayList_ReadOnlyArrayList as ::unity::ClassIdentity>::NAME,
1490 "set_Item",
1491 )
1492 });
1493 let __inner: extern "C" fn(ArrayList_ReadOnlyArrayList, i32, crate::system::object::Object, ::unity::OptionalMethod) -> () =
1494 ::core::mem::transmute(__vi.method_ptr);
1495 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1496 __inner(__receiver, ::core::convert::Into::into(index), ::core::convert::Into::into(value), __mi)
1497 }
1498 }
1499 }
1500 #[doc = "`get_SyncRoot()` overload"]
1501 fn get_sync_root(self) -> crate::system::object::Object {
1502 unsafe {
1503 let __receiver =
1504 <ArrayList_ReadOnlyArrayList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1505 {
1506 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1507 let __vi = *__vt.get(24usize).unwrap_or_else(|| {
1508 panic!(
1509 "unity: virtual slot {}
1510 out of range (vtable len {}
1511) on the runtime class behind {}
1512 (method `{}
1513`)",
1514 24usize,
1515 __vt.len(),
1516 <ArrayList_ReadOnlyArrayList as ::unity::ClassIdentity>::NAME,
1517 "get_SyncRoot",
1518 )
1519 });
1520 let __inner: extern "C" fn(ArrayList_ReadOnlyArrayList, ::unity::OptionalMethod) -> crate::system::object::Object =
1521 ::core::mem::transmute(__vi.method_ptr);
1522 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1523 __inner(__receiver, __mi)
1524 }
1525 }
1526 }
1527 #[doc = "`Add(crate::system::object::Object)` overload"]
1528 fn add(self, obj: impl ::core::convert::Into<crate::system::object::Object>) -> i32 {
1529 unsafe {
1530 let __receiver =
1531 <ArrayList_ReadOnlyArrayList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1532 {
1533 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1534 let __vi = *__vt.get(27usize).unwrap_or_else(|| {
1535 panic!(
1536 "unity: virtual slot {}
1537 out of range (vtable len {}
1538) on the runtime class behind {}
1539 (method `{}
1540`)",
1541 27usize,
1542 __vt.len(),
1543 <ArrayList_ReadOnlyArrayList as ::unity::ClassIdentity>::NAME,
1544 "Add",
1545 )
1546 });
1547 let __inner: extern "C" fn(ArrayList_ReadOnlyArrayList, crate::system::object::Object, ::unity::OptionalMethod) -> i32 =
1548 ::core::mem::transmute(__vi.method_ptr);
1549 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1550 __inner(__receiver, ::core::convert::Into::into(obj), __mi)
1551 }
1552 }
1553 }
1554 #[doc = "`AddRange(crate::system::collections::icollection::ICollection)` overload"]
1555 fn add_range(self, c: impl ::core::convert::Into<crate::system::collections::icollection::ICollection>) -> () {
1556 unsafe {
1557 let __receiver =
1558 <ArrayList_ReadOnlyArrayList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1559 {
1560 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1561 let __vi = *__vt.get(28usize).unwrap_or_else(|| {
1562 panic!(
1563 "unity: virtual slot {}
1564 out of range (vtable len {}
1565) on the runtime class behind {}
1566 (method `{}
1567`)",
1568 28usize,
1569 __vt.len(),
1570 <ArrayList_ReadOnlyArrayList as ::unity::ClassIdentity>::NAME,
1571 "AddRange",
1572 )
1573 });
1574 let __inner: extern "C" fn(
1575 ArrayList_ReadOnlyArrayList,
1576 crate::system::collections::icollection::ICollection,
1577 ::unity::OptionalMethod,
1578 ) -> () = ::core::mem::transmute(__vi.method_ptr);
1579 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1580 __inner(__receiver, ::core::convert::Into::into(c), __mi)
1581 }
1582 }
1583 }
1584 #[doc = "`set_Capacity(i32)` overload"]
1585 fn set_capacity(self, value: impl ::core::convert::Into<i32>) -> () {
1586 unsafe {
1587 let __receiver =
1588 <ArrayList_ReadOnlyArrayList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1589 {
1590 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1591 let __vi = *__vt.get(20usize).unwrap_or_else(|| {
1592 panic!(
1593 "unity: virtual slot {}
1594 out of range (vtable len {}
1595) on the runtime class behind {}
1596 (method `{}
1597`)",
1598 20usize,
1599 __vt.len(),
1600 <ArrayList_ReadOnlyArrayList as ::unity::ClassIdentity>::NAME,
1601 "set_Capacity",
1602 )
1603 });
1604 let __inner: extern "C" fn(ArrayList_ReadOnlyArrayList, i32, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
1605 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1606 __inner(__receiver, ::core::convert::Into::into(value), __mi)
1607 }
1608 }
1609 }
1610 #[doc = "`Clear()` overload"]
1611 fn clear(self) -> () {
1612 unsafe {
1613 let __receiver =
1614 <ArrayList_ReadOnlyArrayList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1615 {
1616 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1617 let __vi = *__vt.get(29usize).unwrap_or_else(|| {
1618 panic!(
1619 "unity: virtual slot {}
1620 out of range (vtable len {}
1621) on the runtime class behind {}
1622 (method `{}
1623`)",
1624 29usize,
1625 __vt.len(),
1626 <ArrayList_ReadOnlyArrayList as ::unity::ClassIdentity>::NAME,
1627 "Clear",
1628 )
1629 });
1630 let __inner: extern "C" fn(ArrayList_ReadOnlyArrayList, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
1631 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1632 __inner(__receiver, __mi)
1633 }
1634 }
1635 }
1636 #[doc = "`Clone()` overload"]
1637 fn clone(self) -> crate::system::object::Object {
1638 unsafe {
1639 let __receiver =
1640 <ArrayList_ReadOnlyArrayList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1641 {
1642 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1643 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
1644 panic!(
1645 "unity: virtual slot {}
1646 out of range (vtable len {}
1647) on the runtime class behind {}
1648 (method `{}
1649`)",
1650 30usize,
1651 __vt.len(),
1652 <ArrayList_ReadOnlyArrayList as ::unity::ClassIdentity>::NAME,
1653 "Clone",
1654 )
1655 });
1656 let __inner: extern "C" fn(ArrayList_ReadOnlyArrayList, ::unity::OptionalMethod) -> crate::system::object::Object =
1657 ::core::mem::transmute(__vi.method_ptr);
1658 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1659 __inner(__receiver, __mi)
1660 }
1661 }
1662 }
1663 #[doc = "`Contains(crate::system::object::Object)` overload"]
1664 fn contains(self, obj: impl ::core::convert::Into<crate::system::object::Object>) -> bool {
1665 unsafe {
1666 let __receiver =
1667 <ArrayList_ReadOnlyArrayList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1668 {
1669 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1670 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
1671 panic!(
1672 "unity: virtual slot {}
1673 out of range (vtable len {}
1674) on the runtime class behind {}
1675 (method `{}
1676`)",
1677 31usize,
1678 __vt.len(),
1679 <ArrayList_ReadOnlyArrayList as ::unity::ClassIdentity>::NAME,
1680 "Contains",
1681 )
1682 });
1683 let __inner: extern "C" fn(ArrayList_ReadOnlyArrayList, crate::system::object::Object, ::unity::OptionalMethod) -> bool =
1684 ::core::mem::transmute(__vi.method_ptr);
1685 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1686 __inner(__receiver, ::core::convert::Into::into(obj), __mi)
1687 }
1688 }
1689 }
1690 #[doc = "`CopyTo(::unity::IlInstance, i32)` overload"]
1691 fn copy_to(self, array: impl ::core::convert::Into<::unity::IlInstance>, index: impl ::core::convert::Into<i32>) -> () {
1692 unsafe {
1693 let __receiver =
1694 <ArrayList_ReadOnlyArrayList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1695 {
1696 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1697 let __vi = *__vt.get(33usize).unwrap_or_else(|| {
1698 panic!(
1699 "unity: virtual slot {}
1700 out of range (vtable len {}
1701) on the runtime class behind {}
1702 (method `{}
1703`)",
1704 33usize,
1705 __vt.len(),
1706 <ArrayList_ReadOnlyArrayList as ::unity::ClassIdentity>::NAME,
1707 "CopyTo",
1708 )
1709 });
1710 let __inner: extern "C" fn(ArrayList_ReadOnlyArrayList, ::unity::IlInstance, i32, ::unity::OptionalMethod) -> () =
1711 ::core::mem::transmute(__vi.method_ptr);
1712 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1713 __inner(__receiver, ::core::convert::Into::into(array), ::core::convert::Into::into(index), __mi)
1714 }
1715 }
1716 }
1717 #[doc = "`CopyTo(i32, ::unity::IlInstance, i32, i32)` overload"]
1718 fn copy_to_2(
1719 self,
1720 index: impl ::core::convert::Into<i32>,
1721 array: impl ::core::convert::Into<::unity::IlInstance>,
1722 array_index: impl ::core::convert::Into<i32>,
1723 count: impl ::core::convert::Into<i32>,
1724 ) -> () {
1725 unsafe {
1726 let __receiver =
1727 <ArrayList_ReadOnlyArrayList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1728 {
1729 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1730 let __vi = *__vt.get(34usize).unwrap_or_else(|| {
1731 panic!(
1732 "unity: virtual slot {}
1733 out of range (vtable len {}
1734) on the runtime class behind {}
1735 (method `{}
1736`)",
1737 34usize,
1738 __vt.len(),
1739 <ArrayList_ReadOnlyArrayList as ::unity::ClassIdentity>::NAME,
1740 "CopyTo",
1741 )
1742 });
1743 let __inner: extern "C" fn(ArrayList_ReadOnlyArrayList, i32, ::unity::IlInstance, i32, i32, ::unity::OptionalMethod) -> () =
1744 ::core::mem::transmute(__vi.method_ptr);
1745 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1746 __inner(
1747 __receiver,
1748 ::core::convert::Into::into(index),
1749 ::core::convert::Into::into(array),
1750 ::core::convert::Into::into(array_index),
1751 ::core::convert::Into::into(count),
1752 __mi,
1753 )
1754 }
1755 }
1756 }
1757 #[doc = "`GetEnumerator()` overload"]
1758 fn get_enumerator(self) -> crate::system::collections::ienumerator::IEnumerator {
1759 unsafe {
1760 let __receiver =
1761 <ArrayList_ReadOnlyArrayList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1762 {
1763 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1764 let __vi = *__vt.get(35usize).unwrap_or_else(|| {
1765 panic!(
1766 "unity: virtual slot {}
1767 out of range (vtable len {}
1768) on the runtime class behind {}
1769 (method `{}
1770`)",
1771 35usize,
1772 __vt.len(),
1773 <ArrayList_ReadOnlyArrayList as ::unity::ClassIdentity>::NAME,
1774 "GetEnumerator",
1775 )
1776 });
1777 let __inner: extern "C" fn(
1778 ArrayList_ReadOnlyArrayList,
1779 ::unity::OptionalMethod,
1780 ) -> crate::system::collections::ienumerator::IEnumerator = ::core::mem::transmute(__vi.method_ptr);
1781 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1782 __inner(__receiver, __mi)
1783 }
1784 }
1785 }
1786 #[doc = "`IndexOf(crate::system::object::Object)` overload"]
1787 fn index_of(self, value: impl ::core::convert::Into<crate::system::object::Object>) -> i32 {
1788 unsafe {
1789 let __receiver =
1790 <ArrayList_ReadOnlyArrayList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1791 {
1792 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1793 let __vi = *__vt.get(36usize).unwrap_or_else(|| {
1794 panic!(
1795 "unity: virtual slot {}
1796 out of range (vtable len {}
1797) on the runtime class behind {}
1798 (method `{}
1799`)",
1800 36usize,
1801 __vt.len(),
1802 <ArrayList_ReadOnlyArrayList as ::unity::ClassIdentity>::NAME,
1803 "IndexOf",
1804 )
1805 });
1806 let __inner: extern "C" fn(ArrayList_ReadOnlyArrayList, crate::system::object::Object, ::unity::OptionalMethod) -> i32 =
1807 ::core::mem::transmute(__vi.method_ptr);
1808 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1809 __inner(__receiver, ::core::convert::Into::into(value), __mi)
1810 }
1811 }
1812 }
1813 #[doc = "`Insert(i32, crate::system::object::Object)` overload"]
1814 fn insert(self, index: impl ::core::convert::Into<i32>, obj: impl ::core::convert::Into<crate::system::object::Object>) -> () {
1815 unsafe {
1816 let __receiver =
1817 <ArrayList_ReadOnlyArrayList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1818 {
1819 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1820 let __vi = *__vt.get(37usize).unwrap_or_else(|| {
1821 panic!(
1822 "unity: virtual slot {}
1823 out of range (vtable len {}
1824) on the runtime class behind {}
1825 (method `{}
1826`)",
1827 37usize,
1828 __vt.len(),
1829 <ArrayList_ReadOnlyArrayList as ::unity::ClassIdentity>::NAME,
1830 "Insert",
1831 )
1832 });
1833 let __inner: extern "C" fn(ArrayList_ReadOnlyArrayList, i32, crate::system::object::Object, ::unity::OptionalMethod) -> () =
1834 ::core::mem::transmute(__vi.method_ptr);
1835 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1836 __inner(__receiver, ::core::convert::Into::into(index), ::core::convert::Into::into(obj), __mi)
1837 }
1838 }
1839 }
1840 #[doc = "`InsertRange(i32, crate::system::collections::icollection::ICollection)` overload"]
1841 fn insert_range(
1842 self,
1843 index: impl ::core::convert::Into<i32>,
1844 c: impl ::core::convert::Into<crate::system::collections::icollection::ICollection>,
1845 ) -> () {
1846 unsafe {
1847 let __receiver =
1848 <ArrayList_ReadOnlyArrayList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1849 {
1850 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1851 let __vi = *__vt.get(38usize).unwrap_or_else(|| {
1852 panic!(
1853 "unity: virtual slot {}
1854 out of range (vtable len {}
1855) on the runtime class behind {}
1856 (method `{}
1857`)",
1858 38usize,
1859 __vt.len(),
1860 <ArrayList_ReadOnlyArrayList as ::unity::ClassIdentity>::NAME,
1861 "InsertRange",
1862 )
1863 });
1864 let __inner: extern "C" fn(
1865 ArrayList_ReadOnlyArrayList,
1866 i32,
1867 crate::system::collections::icollection::ICollection,
1868 ::unity::OptionalMethod,
1869 ) -> () = ::core::mem::transmute(__vi.method_ptr);
1870 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1871 __inner(__receiver, ::core::convert::Into::into(index), ::core::convert::Into::into(c), __mi)
1872 }
1873 }
1874 }
1875 #[doc = "`Remove(crate::system::object::Object)` overload"]
1876 fn remove(self, value: impl ::core::convert::Into<crate::system::object::Object>) -> () {
1877 unsafe {
1878 let __receiver =
1879 <ArrayList_ReadOnlyArrayList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1880 {
1881 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1882 let __vi = *__vt.get(39usize).unwrap_or_else(|| {
1883 panic!(
1884 "unity: virtual slot {}
1885 out of range (vtable len {}
1886) on the runtime class behind {}
1887 (method `{}
1888`)",
1889 39usize,
1890 __vt.len(),
1891 <ArrayList_ReadOnlyArrayList as ::unity::ClassIdentity>::NAME,
1892 "Remove",
1893 )
1894 });
1895 let __inner: extern "C" fn(ArrayList_ReadOnlyArrayList, crate::system::object::Object, ::unity::OptionalMethod) -> () =
1896 ::core::mem::transmute(__vi.method_ptr);
1897 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1898 __inner(__receiver, ::core::convert::Into::into(value), __mi)
1899 }
1900 }
1901 }
1902 #[doc = "`RemoveAt(i32)` overload"]
1903 fn remove_at(self, index: impl ::core::convert::Into<i32>) -> () {
1904 unsafe {
1905 let __receiver =
1906 <ArrayList_ReadOnlyArrayList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1907 {
1908 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1909 let __vi = *__vt.get(40usize).unwrap_or_else(|| {
1910 panic!(
1911 "unity: virtual slot {}
1912 out of range (vtable len {}
1913) on the runtime class behind {}
1914 (method `{}
1915`)",
1916 40usize,
1917 __vt.len(),
1918 <ArrayList_ReadOnlyArrayList as ::unity::ClassIdentity>::NAME,
1919 "RemoveAt",
1920 )
1921 });
1922 let __inner: extern "C" fn(ArrayList_ReadOnlyArrayList, i32, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
1923 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1924 __inner(__receiver, ::core::convert::Into::into(index), __mi)
1925 }
1926 }
1927 }
1928 #[doc = "`RemoveRange(i32, i32)` overload"]
1929 fn remove_range(self, index: impl ::core::convert::Into<i32>, count: impl ::core::convert::Into<i32>) -> () {
1930 unsafe {
1931 let __receiver =
1932 <ArrayList_ReadOnlyArrayList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1933 {
1934 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1935 let __vi = *__vt.get(41usize).unwrap_or_else(|| {
1936 panic!(
1937 "unity: virtual slot {}
1938 out of range (vtable len {}
1939) on the runtime class behind {}
1940 (method `{}
1941`)",
1942 41usize,
1943 __vt.len(),
1944 <ArrayList_ReadOnlyArrayList as ::unity::ClassIdentity>::NAME,
1945 "RemoveRange",
1946 )
1947 });
1948 let __inner: extern "C" fn(ArrayList_ReadOnlyArrayList, i32, i32, ::unity::OptionalMethod) -> () =
1949 ::core::mem::transmute(__vi.method_ptr);
1950 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1951 __inner(__receiver, ::core::convert::Into::into(index), ::core::convert::Into::into(count), __mi)
1952 }
1953 }
1954 }
1955 #[doc = "`ToArray()` overload"]
1956 fn to_array(self) -> ::unity::Array<crate::system::object::Object> {
1957 unsafe {
1958 let __receiver =
1959 <ArrayList_ReadOnlyArrayList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1960 {
1961 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1962 let __vi = *__vt.get(42usize).unwrap_or_else(|| {
1963 panic!(
1964 "unity: virtual slot {}
1965 out of range (vtable len {}
1966) on the runtime class behind {}
1967 (method `{}
1968`)",
1969 42usize,
1970 __vt.len(),
1971 <ArrayList_ReadOnlyArrayList as ::unity::ClassIdentity>::NAME,
1972 "ToArray",
1973 )
1974 });
1975 let __inner: extern "C" fn(ArrayList_ReadOnlyArrayList, ::unity::OptionalMethod) -> ::unity::Array<crate::system::object::Object> =
1976 ::core::mem::transmute(__vi.method_ptr);
1977 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1978 __inner(__receiver, __mi)
1979 }
1980 }
1981 }
1982 #[doc = "`ToArray(::unity::SystemType)` overload"]
1983 fn to_array_2(self, r#type: impl ::core::convert::Into<::unity::SystemType>) -> ::unity::IlInstance {
1984 unsafe {
1985 let __receiver =
1986 <ArrayList_ReadOnlyArrayList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1987 {
1988 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1989 let __vi = *__vt.get(43usize).unwrap_or_else(|| {
1990 panic!(
1991 "unity: virtual slot {}
1992 out of range (vtable len {}
1993) on the runtime class behind {}
1994 (method `{}
1995`)",
1996 43usize,
1997 __vt.len(),
1998 <ArrayList_ReadOnlyArrayList as ::unity::ClassIdentity>::NAME,
1999 "ToArray",
2000 )
2001 });
2002 let __inner: extern "C" fn(ArrayList_ReadOnlyArrayList, ::unity::SystemType, ::unity::OptionalMethod) -> ::unity::IlInstance =
2003 ::core::mem::transmute(__vi.method_ptr);
2004 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2005 __inner(__receiver, ::core::convert::Into::into(r#type), __mi)
2006 }
2007 }
2008 }
2009}
2010
2011#[cfg(feature = "system-collections-arraylist")]
2012impl<__T: IArrayList_ReadOnlyArrayList> IArrayList_ReadOnlyArrayListMethods for __T {}
2013
2014#[cfg(feature = "system-collections-arraylist")]
2015impl ArrayList_ReadOnlyArrayList {
2016 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2017 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
2018 }
2019
2020 pub fn get_count_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2021 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
2022 }
2023
2024 pub fn get_is_read_only_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2025 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
2026 }
2027
2028 pub fn get_is_synchronized_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2029 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
2030 }
2031
2032 pub fn get_item_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2033 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
2034 }
2035
2036 pub fn set_item_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2037 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
2038 }
2039
2040 pub fn get_sync_root_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2041 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
2042 }
2043
2044 pub fn add_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2045 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
2046 }
2047
2048 pub fn add_range_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2049 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[8]
2050 }
2051
2052 pub fn set_capacity_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2053 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[9]
2054 }
2055
2056 pub fn clear_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2057 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[10]
2058 }
2059
2060 pub fn clone_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2061 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[11]
2062 }
2063
2064 pub fn contains_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2065 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[12]
2066 }
2067
2068 pub fn copy_to_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2069 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[13]
2070 }
2071
2072 pub fn copy_to_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2073 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[14]
2074 }
2075
2076 pub fn get_enumerator_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2077 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[15]
2078 }
2079
2080 pub fn index_of_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2081 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[16]
2082 }
2083
2084 pub fn insert_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2085 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[17]
2086 }
2087
2088 pub fn insert_range_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2089 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[18]
2090 }
2091
2092 pub fn remove_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2093 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[19]
2094 }
2095
2096 pub fn remove_at_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2097 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[20]
2098 }
2099
2100 pub fn remove_range_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2101 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[21]
2102 }
2103
2104 pub fn to_array_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2105 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[22]
2106 }
2107
2108 pub fn to_array_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2109 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[23]
2110 }
2111}
2112
2113#[cfg(feature = "system-collections-arraylist")]
2114impl ArrayList_ReadOnlyArrayList {
2115 #[doc = "Direct (non-virtual) call to `ArrayList_ReadOnlyArrayList`'s own `get_Count`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2116 pub unsafe fn get_count(this: impl ::core::convert::Into<::unity::IlInstance>) -> i32 {
2117 let __mi = Self::get_count_method_info();
2118 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__mi.method_ptr);
2119 __inner(this.into(), ::core::option::Option::None)
2120 }
2121
2122 #[doc = "Direct (non-virtual) call to `ArrayList_ReadOnlyArrayList`'s own `get_IsReadOnly`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2123 pub unsafe fn get_is_read_only(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
2124 let __mi = Self::get_is_read_only_method_info();
2125 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
2126 __inner(this.into(), ::core::option::Option::None)
2127 }
2128
2129 #[doc = "Direct (non-virtual) call to `ArrayList_ReadOnlyArrayList`'s own `get_IsSynchronized`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2130 pub unsafe fn get_is_synchronized(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
2131 let __mi = Self::get_is_synchronized_method_info();
2132 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
2133 __inner(this.into(), ::core::option::Option::None)
2134 }
2135
2136 #[doc = "Direct (non-virtual) call to `ArrayList_ReadOnlyArrayList`'s own `get_Item`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2137 pub unsafe fn get_item(this: impl ::core::convert::Into<::unity::IlInstance>, index: i32) -> crate::system::object::Object {
2138 let __mi = Self::get_item_method_info();
2139 let __inner: extern "C" fn(::unity::IlInstance, i32, ::unity::OptionalMethod) -> crate::system::object::Object =
2140 ::core::mem::transmute(__mi.method_ptr);
2141 __inner(this.into(), index, ::core::option::Option::None)
2142 }
2143
2144 #[doc = "Direct (non-virtual) call to `ArrayList_ReadOnlyArrayList`'s own `set_Item`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2145 pub unsafe fn set_item(this: impl ::core::convert::Into<::unity::IlInstance>, index: i32, value: crate::system::object::Object) -> () {
2146 let __mi = Self::set_item_method_info();
2147 let __inner: extern "C" fn(::unity::IlInstance, i32, crate::system::object::Object, ::unity::OptionalMethod) -> () =
2148 ::core::mem::transmute(__mi.method_ptr);
2149 __inner(this.into(), index, value, ::core::option::Option::None)
2150 }
2151
2152 #[doc = "Direct (non-virtual) call to `ArrayList_ReadOnlyArrayList`'s own `get_SyncRoot`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2153 pub unsafe fn get_sync_root(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::system::object::Object {
2154 let __mi = Self::get_sync_root_method_info();
2155 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::system::object::Object =
2156 ::core::mem::transmute(__mi.method_ptr);
2157 __inner(this.into(), ::core::option::Option::None)
2158 }
2159
2160 #[doc = "Direct (non-virtual) call to `ArrayList_ReadOnlyArrayList`'s own `Add`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2161 pub unsafe fn add(this: impl ::core::convert::Into<::unity::IlInstance>, obj: crate::system::object::Object) -> i32 {
2162 let __mi = Self::add_method_info();
2163 let __inner: extern "C" fn(::unity::IlInstance, crate::system::object::Object, ::unity::OptionalMethod) -> i32 =
2164 ::core::mem::transmute(__mi.method_ptr);
2165 __inner(this.into(), obj, ::core::option::Option::None)
2166 }
2167
2168 #[doc = "Direct (non-virtual) call to `ArrayList_ReadOnlyArrayList`'s own `AddRange`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2169 pub unsafe fn add_range(this: impl ::core::convert::Into<::unity::IlInstance>, c: crate::system::collections::icollection::ICollection) -> () {
2170 let __mi = Self::add_range_method_info();
2171 let __inner: extern "C" fn(::unity::IlInstance, crate::system::collections::icollection::ICollection, ::unity::OptionalMethod) -> () =
2172 ::core::mem::transmute(__mi.method_ptr);
2173 __inner(this.into(), c, ::core::option::Option::None)
2174 }
2175
2176 #[doc = "Direct (non-virtual) call to `ArrayList_ReadOnlyArrayList`'s own `set_Capacity`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2177 pub unsafe fn set_capacity(this: impl ::core::convert::Into<::unity::IlInstance>, value: i32) -> () {
2178 let __mi = Self::set_capacity_method_info();
2179 let __inner: extern "C" fn(::unity::IlInstance, i32, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
2180 __inner(this.into(), value, ::core::option::Option::None)
2181 }
2182
2183 #[doc = "Direct (non-virtual) call to `ArrayList_ReadOnlyArrayList`'s own `Clear`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2184 pub unsafe fn clear(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
2185 let __mi = Self::clear_method_info();
2186 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
2187 __inner(this.into(), ::core::option::Option::None)
2188 }
2189
2190 #[doc = "Direct (non-virtual) call to `ArrayList_ReadOnlyArrayList`'s own `Clone`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2191 pub unsafe fn clone(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::system::object::Object {
2192 let __mi = Self::clone_method_info();
2193 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::system::object::Object =
2194 ::core::mem::transmute(__mi.method_ptr);
2195 __inner(this.into(), ::core::option::Option::None)
2196 }
2197
2198 #[doc = "Direct (non-virtual) call to `ArrayList_ReadOnlyArrayList`'s own `Contains`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2199 pub unsafe fn contains(this: impl ::core::convert::Into<::unity::IlInstance>, obj: crate::system::object::Object) -> bool {
2200 let __mi = Self::contains_method_info();
2201 let __inner: extern "C" fn(::unity::IlInstance, crate::system::object::Object, ::unity::OptionalMethod) -> bool =
2202 ::core::mem::transmute(__mi.method_ptr);
2203 __inner(this.into(), obj, ::core::option::Option::None)
2204 }
2205
2206 #[doc = "Direct (non-virtual) call to `ArrayList_ReadOnlyArrayList`'s own `CopyTo`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2207 pub unsafe fn copy_to(this: impl ::core::convert::Into<::unity::IlInstance>, array: ::unity::IlInstance, index: i32) -> () {
2208 let __mi = Self::copy_to_method_info();
2209 let __inner: extern "C" fn(::unity::IlInstance, ::unity::IlInstance, i32, ::unity::OptionalMethod) -> () =
2210 ::core::mem::transmute(__mi.method_ptr);
2211 __inner(this.into(), array, index, ::core::option::Option::None)
2212 }
2213
2214 #[doc = "Direct (non-virtual) call to `ArrayList_ReadOnlyArrayList`'s own `CopyTo`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2215 pub unsafe fn copy_to_2(
2216 this: impl ::core::convert::Into<::unity::IlInstance>,
2217 index: i32,
2218 array: ::unity::IlInstance,
2219 array_index: i32,
2220 count: i32,
2221 ) -> () {
2222 let __mi = Self::copy_to_2_method_info();
2223 let __inner: extern "C" fn(::unity::IlInstance, i32, ::unity::IlInstance, i32, i32, ::unity::OptionalMethod) -> () =
2224 ::core::mem::transmute(__mi.method_ptr);
2225 __inner(this.into(), index, array, array_index, count, ::core::option::Option::None)
2226 }
2227
2228 #[doc = "Direct (non-virtual) call to `ArrayList_ReadOnlyArrayList`'s own `GetEnumerator`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2229 pub unsafe fn get_enumerator(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::system::collections::ienumerator::IEnumerator {
2230 let __mi = Self::get_enumerator_method_info();
2231 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::system::collections::ienumerator::IEnumerator =
2232 ::core::mem::transmute(__mi.method_ptr);
2233 __inner(this.into(), ::core::option::Option::None)
2234 }
2235
2236 #[doc = "Direct (non-virtual) call to `ArrayList_ReadOnlyArrayList`'s own `IndexOf`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2237 pub unsafe fn index_of(this: impl ::core::convert::Into<::unity::IlInstance>, value: crate::system::object::Object) -> i32 {
2238 let __mi = Self::index_of_method_info();
2239 let __inner: extern "C" fn(::unity::IlInstance, crate::system::object::Object, ::unity::OptionalMethod) -> i32 =
2240 ::core::mem::transmute(__mi.method_ptr);
2241 __inner(this.into(), value, ::core::option::Option::None)
2242 }
2243
2244 #[doc = "Direct (non-virtual) call to `ArrayList_ReadOnlyArrayList`'s own `Insert`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2245 pub unsafe fn insert(this: impl ::core::convert::Into<::unity::IlInstance>, index: i32, obj: crate::system::object::Object) -> () {
2246 let __mi = Self::insert_method_info();
2247 let __inner: extern "C" fn(::unity::IlInstance, i32, crate::system::object::Object, ::unity::OptionalMethod) -> () =
2248 ::core::mem::transmute(__mi.method_ptr);
2249 __inner(this.into(), index, obj, ::core::option::Option::None)
2250 }
2251
2252 #[doc = "Direct (non-virtual) call to `ArrayList_ReadOnlyArrayList`'s own `InsertRange`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2253 pub unsafe fn insert_range(
2254 this: impl ::core::convert::Into<::unity::IlInstance>,
2255 index: i32,
2256 c: crate::system::collections::icollection::ICollection,
2257 ) -> () {
2258 let __mi = Self::insert_range_method_info();
2259 let __inner: extern "C" fn(::unity::IlInstance, i32, crate::system::collections::icollection::ICollection, ::unity::OptionalMethod) -> () =
2260 ::core::mem::transmute(__mi.method_ptr);
2261 __inner(this.into(), index, c, ::core::option::Option::None)
2262 }
2263
2264 #[doc = "Direct (non-virtual) call to `ArrayList_ReadOnlyArrayList`'s own `Remove`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2265 pub unsafe fn remove(this: impl ::core::convert::Into<::unity::IlInstance>, value: crate::system::object::Object) -> () {
2266 let __mi = Self::remove_method_info();
2267 let __inner: extern "C" fn(::unity::IlInstance, crate::system::object::Object, ::unity::OptionalMethod) -> () =
2268 ::core::mem::transmute(__mi.method_ptr);
2269 __inner(this.into(), value, ::core::option::Option::None)
2270 }
2271
2272 #[doc = "Direct (non-virtual) call to `ArrayList_ReadOnlyArrayList`'s own `RemoveAt`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2273 pub unsafe fn remove_at(this: impl ::core::convert::Into<::unity::IlInstance>, index: i32) -> () {
2274 let __mi = Self::remove_at_method_info();
2275 let __inner: extern "C" fn(::unity::IlInstance, i32, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
2276 __inner(this.into(), index, ::core::option::Option::None)
2277 }
2278
2279 #[doc = "Direct (non-virtual) call to `ArrayList_ReadOnlyArrayList`'s own `RemoveRange`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2280 pub unsafe fn remove_range(this: impl ::core::convert::Into<::unity::IlInstance>, index: i32, count: i32) -> () {
2281 let __mi = Self::remove_range_method_info();
2282 let __inner: extern "C" fn(::unity::IlInstance, i32, i32, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
2283 __inner(this.into(), index, count, ::core::option::Option::None)
2284 }
2285
2286 #[doc = "Direct (non-virtual) call to `ArrayList_ReadOnlyArrayList`'s own `ToArray`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2287 pub unsafe fn to_array(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Array<crate::system::object::Object> {
2288 let __mi = Self::to_array_method_info();
2289 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Array<crate::system::object::Object> =
2290 ::core::mem::transmute(__mi.method_ptr);
2291 __inner(this.into(), ::core::option::Option::None)
2292 }
2293
2294 #[doc = "Direct (non-virtual) call to `ArrayList_ReadOnlyArrayList`'s own `ToArray`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2295 pub unsafe fn to_array_2(this: impl ::core::convert::Into<::unity::IlInstance>, r#type: ::unity::SystemType) -> ::unity::IlInstance {
2296 let __mi = Self::to_array_2_method_info();
2297 let __inner: extern "C" fn(::unity::IlInstance, ::unity::SystemType, ::unity::OptionalMethod) -> ::unity::IlInstance =
2298 ::core::mem::transmute(__mi.method_ptr);
2299 __inner(this.into(), r#type, ::core::option::Option::None)
2300 }
2301}
2302
2303#[cfg(feature = "system-collections-arraylist")]
2304impl ArrayList_ReadOnlyArrayList {
2305 #[doc = "`.ctor(crate::system::collections::arraylist::ArrayList)` — overload selector"]
2306 pub fn new(l: crate::system::collections::arraylist::ArrayList) -> Self {
2307 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
2308 panic!(
2309 "{}
2310::{}
2311 failed to instantiate",
2312 ::core::stringify!(ArrayList_ReadOnlyArrayList),
2313 ::core::stringify!(new),
2314 )
2315 });
2316 <Self as IArrayList_ReadOnlyArrayListMethods>::ctor(this, l);
2317 this
2318 }
2319}
2320
2321#[cfg(feature = "system-collections-arraylist")]
2322#[doc(hidden)]
2323pub mod prelude {
2324 pub use super::{
2325 ArrayList, ArrayList_ArrayListDebugView, ArrayList_ArrayListEnumeratorSimple, ArrayList_ReadOnlyArrayList, IArrayList, IArrayListMethods,
2326 IArrayList_ArrayListDebugView, IArrayList_ArrayListEnumeratorSimple, IArrayList_ArrayListEnumeratorSimpleMethods,
2327 IArrayList_ReadOnlyArrayList, IArrayList_ReadOnlyArrayListMethods,
2328 };
2329 pub use crate::system::object::IObject;
2330 #[cfg(feature = "system-object")]
2331 pub use crate::system::object::IObjectMethods;
2332}