1#[cfg(feature = "system-collections-sortedlist-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/sortedlist/SortedList.md"))]
11 #[::unity::class(namespace = "System.Collections", name = "SortedList")]
12 #[parent(crate::system::object::Object)]
13 pub struct SortedList {
14 #[offset(16)]
15 #[rename(name = "keys")]
16 pub keys: ::unity::Array<crate::system::object::Object>,
17 #[offset(24)]
18 #[rename(name = "values")]
19 pub values: ::unity::Array<crate::system::object::Object>,
20 #[offset(32)]
21 #[rename(name = "_size")]
22 pub size: i32,
23 #[offset(36)]
24 #[rename(name = "version")]
25 pub version: i32,
26 #[offset(40)]
27 #[rename(name = "comparer")]
28 pub comparer: crate::system::collections::icomparer_interface::IComparer_Interface,
29 #[offset(48)]
30 #[rename(name = "keyList")]
31 pub key_list: crate::system::collections::sortedlist::SortedList_KeyList,
32 #[offset(56)]
33 #[rename(name = "valueList")]
34 pub value_list: crate::system::collections::sortedlist::SortedList_ValueList,
35 #[offset(64)]
36 #[rename(name = "_syncRoot")]
37 pub sync_root: ::unity::IlInstance,
38 #[static_field]
39 #[rename(name = "_defaultCapacity")]
40 pub default_capacity: i32,
41 #[static_field]
42 #[rename(name = "emptyArray")]
43 pub empty_array: ::unity::Array<crate::system::object::Object>,
44 }
45
46 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/system/collections/sortedlist/SortedList_SortedListEnumerator.md"))]
47 #[::unity::class(namespace = "System.Collections", name = "SortedList.SortedListEnumerator")]
48 #[parent(crate::system::object::Object)]
49 pub struct SortedList_SortedListEnumerator {
50 #[offset(16)]
51 #[rename(name = "sortedList")]
52 pub sorted_list: crate::system::collections::sortedlist::SortedList,
53 #[offset(24)]
54 #[rename(name = "key")]
55 pub key: ::unity::IlInstance,
56 #[offset(32)]
57 #[rename(name = "value")]
58 pub value: ::unity::IlInstance,
59 #[offset(40)]
60 #[rename(name = "index")]
61 pub index: i32,
62 #[offset(44)]
63 #[rename(name = "startIndex")]
64 pub start_index: i32,
65 #[offset(48)]
66 #[rename(name = "endIndex")]
67 pub end_index: i32,
68 #[offset(52)]
69 #[rename(name = "version")]
70 pub version: i32,
71 #[offset(56)]
72 #[rename(name = "current")]
73 pub current: bool,
74 #[offset(60)]
75 #[rename(name = "getObjectRetType")]
76 pub get_object_ret_type: i32,
77 }
78
79 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/system/collections/sortedlist/SortedList_SortedListDebugView.md"))]
80 #[::unity::class(namespace = "System.Collections", name = "SortedList.SortedListDebugView")]
81 #[parent(crate::system::object::Object)]
82 pub struct SortedList_SortedListDebugView {}
83
84 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/system/collections/sortedlist/SortedList_SyncSortedList.md"))]
85 #[::unity::class(namespace = "System.Collections", name = "SortedList.SyncSortedList")]
86 #[parent(crate::system::collections::sortedlist::SortedList)]
87 pub struct SortedList_SyncSortedList {
88 #[offset(72)]
89 #[rename(name = "_list")]
90 pub list: crate::system::collections::sortedlist::SortedList,
91 #[offset(80)]
92 #[rename(name = "_root")]
93 pub root: ::unity::IlInstance,
94 }
95
96 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/system/collections/sortedlist/SortedList_KeyList.md"))]
97 #[::unity::class(namespace = "System.Collections", name = "SortedList.KeyList")]
98 #[parent(crate::system::object::Object)]
99 pub struct SortedList_KeyList {
100 #[offset(16)]
101 #[rename(name = "sortedList")]
102 pub sorted_list: crate::system::collections::sortedlist::SortedList,
103 }
104
105 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/system/collections/sortedlist/SortedList_ValueList.md"))]
106 #[::unity::class(namespace = "System.Collections", name = "SortedList.ValueList")]
107 #[parent(crate::system::object::Object)]
108 pub struct SortedList_ValueList {
109 #[offset(16)]
110 #[rename(name = "sortedList")]
111 pub sorted_list: crate::system::collections::sortedlist::SortedList,
112 }
113}
114
115#[cfg(feature = "system-collections-sortedlist-types")]
116pub use __types::*;
117
118#[cfg(feature = "system-collections-sortedlist")]
119impl SortedList {
120 #[doc = "`Synchronized(crate::system::collections::sortedlist::SortedList)` overload"]
121 pub fn synchronized(
122 list: impl ::core::convert::Into<crate::system::collections::sortedlist::SortedList>,
123 ) -> crate::system::collections::sortedlist::SortedList {
124 unsafe {
125 ::unity::il2cpp_call!((::unity::module_base()+0x37769a0usize)as*mut u8,crate::system::collections::sortedlist::SortedList;
126(crate::system::collections::sortedlist::SortedList)::core::convert::Into::into(list))
127 }
128 }
129
130 #[doc = "`.cctor()` overload"]
131 pub fn cctor() -> () {
132 unsafe {
133 ::unity::il2cpp_call!((::unity::module_base()+0x3776a50usize)as*mut u8,();
134 )
135 }
136 }
137}
138
139#[cfg(feature = "system-collections-sortedlist")]
140pub trait ISortedListMethods: ISortedList {
141 #[doc = "`.ctor()` overload"]
142 fn ctor(self) -> () {
143 unsafe {
144 let __receiver = <SortedList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
145 ::unity::il2cpp_call!((::unity::module_base()+0x37753d0usize)as*mut u8,();
146(SortedList)__receiver)
147 }
148 }
149 #[doc = "`Init()` overload"]
150 fn init(self) -> () {
151 unsafe {
152 let __receiver = <SortedList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
153 ::unity::il2cpp_call!((::unity::module_base()+0x3775400usize)as*mut u8,();
154(SortedList)__receiver)
155 }
156 }
157 #[doc = "`.ctor(i32)` overload"]
158 fn ctor_2(self, initial_capacity: impl ::core::convert::Into<i32>) -> () {
159 unsafe {
160 let __receiver = <SortedList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
161 ::unity::il2cpp_call!((::unity::module_base()+0x3775510usize)as*mut u8,();
162(SortedList)__receiver,(i32)::core::convert::Into::into(initial_capacity))
163 }
164 }
165 #[doc = "`.ctor(crate::system::collections::icomparer_interface::IComparer_Interface)` overload"]
166 fn ctor_3(self, comparer: impl ::core::convert::Into<crate::system::collections::icomparer_interface::IComparer_Interface>) -> () {
167 unsafe {
168 let __receiver = <SortedList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
169 ::unity::il2cpp_call!((::unity::module_base()+0x3775690usize)as*mut u8,();
170(SortedList)__receiver,(crate::system::collections::icomparer_interface::IComparer_Interface)::core::convert::Into::into(comparer))
171 }
172 }
173 #[doc = "`.ctor(crate::system::collections::icomparer_interface::IComparer_Interface, i32)` overload"]
174 fn ctor_4(
175 self,
176 comparer: impl ::core::convert::Into<crate::system::collections::icomparer_interface::IComparer_Interface>,
177 capacity: impl ::core::convert::Into<i32>,
178 ) -> () {
179 unsafe {
180 let __receiver = <SortedList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
181 ::unity::il2cpp_call!((::unity::module_base()+0x37756e0usize)as*mut u8,();
182(SortedList)__receiver,(crate::system::collections::icomparer_interface::IComparer_Interface)::core::convert::Into::into(comparer),(i32)::core::convert::Into::into(capacity))
183 }
184 }
185 #[doc = "`Add(crate::system::object::Object, crate::system::object::Object)` overload"]
186 fn add(
187 self,
188 key: impl ::core::convert::Into<crate::system::object::Object>,
189 value: impl ::core::convert::Into<crate::system::object::Object>,
190 ) -> () {
191 unsafe {
192 let __receiver = <SortedList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
193 {
194 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
195 let __vi = *__vt.get(20usize).unwrap_or_else(|| {
196 panic!(
197 "unity: virtual slot {}
198 out of range (vtable len {}
199) on the runtime class behind {}
200 (method `{}
201`)",
202 20usize,
203 __vt.len(),
204 <SortedList as ::unity::ClassIdentity>::NAME,
205 "Add",
206 )
207 });
208 let __inner: extern "C" fn(SortedList, crate::system::object::Object, crate::system::object::Object, ::unity::OptionalMethod) -> () =
209 ::core::mem::transmute(__vi.method_ptr);
210 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
211 __inner(__receiver, ::core::convert::Into::into(key), ::core::convert::Into::into(value), __mi)
212 }
213 }
214 }
215 #[doc = "`get_Capacity()` overload"]
216 fn get_capacity(self) -> i32 {
217 unsafe {
218 let __receiver = <SortedList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
219 {
220 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
221 let __vi = *__vt.get(21usize).unwrap_or_else(|| {
222 panic!(
223 "unity: virtual slot {}
224 out of range (vtable len {}
225) on the runtime class behind {}
226 (method `{}
227`)",
228 21usize,
229 __vt.len(),
230 <SortedList as ::unity::ClassIdentity>::NAME,
231 "get_Capacity",
232 )
233 });
234 let __inner: extern "C" fn(SortedList, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__vi.method_ptr);
235 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
236 __inner(__receiver, __mi)
237 }
238 }
239 }
240 #[doc = "`set_Capacity(i32)` overload"]
241 fn set_capacity(self, value: impl ::core::convert::Into<i32>) -> () {
242 unsafe {
243 let __receiver = <SortedList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
244 {
245 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
246 let __vi = *__vt.get(22usize).unwrap_or_else(|| {
247 panic!(
248 "unity: virtual slot {}
249 out of range (vtable len {}
250) on the runtime class behind {}
251 (method `{}
252`)",
253 22usize,
254 __vt.len(),
255 <SortedList as ::unity::ClassIdentity>::NAME,
256 "set_Capacity",
257 )
258 });
259 let __inner: extern "C" fn(SortedList, i32, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
260 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
261 __inner(__receiver, ::core::convert::Into::into(value), __mi)
262 }
263 }
264 }
265 #[doc = "`get_Count()` overload"]
266 fn get_count(self) -> i32 {
267 unsafe {
268 let __receiver = <SortedList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
269 {
270 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
271 let __vi = *__vt.get(23usize).unwrap_or_else(|| {
272 panic!(
273 "unity: virtual slot {}
274 out of range (vtable len {}
275) on the runtime class behind {}
276 (method `{}
277`)",
278 23usize,
279 __vt.len(),
280 <SortedList as ::unity::ClassIdentity>::NAME,
281 "get_Count",
282 )
283 });
284 let __inner: extern "C" fn(SortedList, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__vi.method_ptr);
285 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
286 __inner(__receiver, __mi)
287 }
288 }
289 }
290 #[doc = "`get_Keys()` overload"]
291 fn get_keys(self) -> crate::system::collections::icollection::ICollection {
292 unsafe {
293 let __receiver = <SortedList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
294 {
295 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
296 let __vi = *__vt.get(24usize).unwrap_or_else(|| {
297 panic!(
298 "unity: virtual slot {}
299 out of range (vtable len {}
300) on the runtime class behind {}
301 (method `{}
302`)",
303 24usize,
304 __vt.len(),
305 <SortedList as ::unity::ClassIdentity>::NAME,
306 "get_Keys",
307 )
308 });
309 let __inner: extern "C" fn(SortedList, ::unity::OptionalMethod) -> crate::system::collections::icollection::ICollection =
310 ::core::mem::transmute(__vi.method_ptr);
311 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
312 __inner(__receiver, __mi)
313 }
314 }
315 }
316 #[doc = "`get_Values()` overload"]
317 fn get_values(self) -> crate::system::collections::icollection::ICollection {
318 unsafe {
319 let __receiver = <SortedList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
320 {
321 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
322 let __vi = *__vt.get(25usize).unwrap_or_else(|| {
323 panic!(
324 "unity: virtual slot {}
325 out of range (vtable len {}
326) on the runtime class behind {}
327 (method `{}
328`)",
329 25usize,
330 __vt.len(),
331 <SortedList as ::unity::ClassIdentity>::NAME,
332 "get_Values",
333 )
334 });
335 let __inner: extern "C" fn(SortedList, ::unity::OptionalMethod) -> crate::system::collections::icollection::ICollection =
336 ::core::mem::transmute(__vi.method_ptr);
337 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
338 __inner(__receiver, __mi)
339 }
340 }
341 }
342 #[doc = "`get_IsReadOnly()` overload"]
343 fn get_is_read_only(self) -> bool {
344 unsafe {
345 let __receiver = <SortedList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
346 {
347 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
348 let __vi = *__vt.get(26usize).unwrap_or_else(|| {
349 panic!(
350 "unity: virtual slot {}
351 out of range (vtable len {}
352) on the runtime class behind {}
353 (method `{}
354`)",
355 26usize,
356 __vt.len(),
357 <SortedList as ::unity::ClassIdentity>::NAME,
358 "get_IsReadOnly",
359 )
360 });
361 let __inner: extern "C" fn(SortedList, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
362 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
363 __inner(__receiver, __mi)
364 }
365 }
366 }
367 #[doc = "`get_IsFixedSize()` overload"]
368 fn get_is_fixed_size(self) -> bool {
369 unsafe {
370 let __receiver = <SortedList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
371 {
372 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
373 let __vi = *__vt.get(27usize).unwrap_or_else(|| {
374 panic!(
375 "unity: virtual slot {}
376 out of range (vtable len {}
377) on the runtime class behind {}
378 (method `{}
379`)",
380 27usize,
381 __vt.len(),
382 <SortedList as ::unity::ClassIdentity>::NAME,
383 "get_IsFixedSize",
384 )
385 });
386 let __inner: extern "C" fn(SortedList, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
387 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
388 __inner(__receiver, __mi)
389 }
390 }
391 }
392 #[doc = "`get_IsSynchronized()` overload"]
393 fn get_is_synchronized(self) -> bool {
394 unsafe {
395 let __receiver = <SortedList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
396 {
397 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
398 let __vi = *__vt.get(28usize).unwrap_or_else(|| {
399 panic!(
400 "unity: virtual slot {}
401 out of range (vtable len {}
402) on the runtime class behind {}
403 (method `{}
404`)",
405 28usize,
406 __vt.len(),
407 <SortedList as ::unity::ClassIdentity>::NAME,
408 "get_IsSynchronized",
409 )
410 });
411 let __inner: extern "C" fn(SortedList, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
412 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
413 __inner(__receiver, __mi)
414 }
415 }
416 }
417 #[doc = "`get_SyncRoot()` overload"]
418 fn get_sync_root(self) -> crate::system::object::Object {
419 unsafe {
420 let __receiver = <SortedList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
421 {
422 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
423 let __vi = *__vt.get(29usize).unwrap_or_else(|| {
424 panic!(
425 "unity: virtual slot {}
426 out of range (vtable len {}
427) on the runtime class behind {}
428 (method `{}
429`)",
430 29usize,
431 __vt.len(),
432 <SortedList as ::unity::ClassIdentity>::NAME,
433 "get_SyncRoot",
434 )
435 });
436 let __inner: extern "C" fn(SortedList, ::unity::OptionalMethod) -> crate::system::object::Object =
437 ::core::mem::transmute(__vi.method_ptr);
438 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
439 __inner(__receiver, __mi)
440 }
441 }
442 }
443 #[doc = "`Clone()` overload"]
444 fn clone(self) -> crate::system::object::Object {
445 unsafe {
446 let __receiver = <SortedList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
447 {
448 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
449 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
450 panic!(
451 "unity: virtual slot {}
452 out of range (vtable len {}
453) on the runtime class behind {}
454 (method `{}
455`)",
456 30usize,
457 __vt.len(),
458 <SortedList as ::unity::ClassIdentity>::NAME,
459 "Clone",
460 )
461 });
462 let __inner: extern "C" fn(SortedList, ::unity::OptionalMethod) -> crate::system::object::Object =
463 ::core::mem::transmute(__vi.method_ptr);
464 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
465 __inner(__receiver, __mi)
466 }
467 }
468 }
469 #[doc = "`Contains(crate::system::object::Object)` overload"]
470 fn contains(self, key: impl ::core::convert::Into<crate::system::object::Object>) -> bool {
471 unsafe {
472 let __receiver = <SortedList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
473 {
474 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
475 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
476 panic!(
477 "unity: virtual slot {}
478 out of range (vtable len {}
479) on the runtime class behind {}
480 (method `{}
481`)",
482 31usize,
483 __vt.len(),
484 <SortedList as ::unity::ClassIdentity>::NAME,
485 "Contains",
486 )
487 });
488 let __inner: extern "C" fn(SortedList, crate::system::object::Object, ::unity::OptionalMethod) -> bool =
489 ::core::mem::transmute(__vi.method_ptr);
490 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
491 __inner(__receiver, ::core::convert::Into::into(key), __mi)
492 }
493 }
494 }
495 #[doc = "`ContainsKey(crate::system::object::Object)` overload"]
496 fn contains_key(self, key: impl ::core::convert::Into<crate::system::object::Object>) -> bool {
497 unsafe {
498 let __receiver = <SortedList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
499 {
500 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
501 let __vi = *__vt.get(32usize).unwrap_or_else(|| {
502 panic!(
503 "unity: virtual slot {}
504 out of range (vtable len {}
505) on the runtime class behind {}
506 (method `{}
507`)",
508 32usize,
509 __vt.len(),
510 <SortedList as ::unity::ClassIdentity>::NAME,
511 "ContainsKey",
512 )
513 });
514 let __inner: extern "C" fn(SortedList, crate::system::object::Object, ::unity::OptionalMethod) -> bool =
515 ::core::mem::transmute(__vi.method_ptr);
516 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
517 __inner(__receiver, ::core::convert::Into::into(key), __mi)
518 }
519 }
520 }
521 #[doc = "`ContainsValue(crate::system::object::Object)` overload"]
522 fn contains_value(self, value: impl ::core::convert::Into<crate::system::object::Object>) -> bool {
523 unsafe {
524 let __receiver = <SortedList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
525 {
526 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
527 let __vi = *__vt.get(33usize).unwrap_or_else(|| {
528 panic!(
529 "unity: virtual slot {}
530 out of range (vtable len {}
531) on the runtime class behind {}
532 (method `{}
533`)",
534 33usize,
535 __vt.len(),
536 <SortedList as ::unity::ClassIdentity>::NAME,
537 "ContainsValue",
538 )
539 });
540 let __inner: extern "C" fn(SortedList, crate::system::object::Object, ::unity::OptionalMethod) -> bool =
541 ::core::mem::transmute(__vi.method_ptr);
542 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
543 __inner(__receiver, ::core::convert::Into::into(value), __mi)
544 }
545 }
546 }
547 #[doc = "`CopyTo(::unity::IlInstance, i32)` overload"]
548 fn copy_to(self, array: impl ::core::convert::Into<::unity::IlInstance>, array_index: impl ::core::convert::Into<i32>) -> () {
549 unsafe {
550 let __receiver = <SortedList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
551 {
552 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
553 let __vi = *__vt.get(34usize).unwrap_or_else(|| {
554 panic!(
555 "unity: virtual slot {}
556 out of range (vtable len {}
557) on the runtime class behind {}
558 (method `{}
559`)",
560 34usize,
561 __vt.len(),
562 <SortedList as ::unity::ClassIdentity>::NAME,
563 "CopyTo",
564 )
565 });
566 let __inner: extern "C" fn(SortedList, ::unity::IlInstance, i32, ::unity::OptionalMethod) -> () =
567 ::core::mem::transmute(__vi.method_ptr);
568 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
569 __inner(
570 __receiver,
571 ::core::convert::Into::into(array),
572 ::core::convert::Into::into(array_index),
573 __mi,
574 )
575 }
576 }
577 }
578 #[doc = "`EnsureCapacity(i32)` overload"]
579 fn ensure_capacity(self, min: impl ::core::convert::Into<i32>) -> () {
580 unsafe {
581 let __receiver = <SortedList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
582 ::unity::il2cpp_call!((::unity::module_base()+0x3776100usize)as*mut u8,();
583(SortedList)__receiver,(i32)::core::convert::Into::into(min))
584 }
585 }
586 #[doc = "`GetByIndex(i32)` overload"]
587 fn get_by_index(self, index: impl ::core::convert::Into<i32>) -> crate::system::object::Object {
588 unsafe {
589 let __receiver = <SortedList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
590 {
591 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
592 let __vi = *__vt.get(35usize).unwrap_or_else(|| {
593 panic!(
594 "unity: virtual slot {}
595 out of range (vtable len {}
596) on the runtime class behind {}
597 (method `{}
598`)",
599 35usize,
600 __vt.len(),
601 <SortedList as ::unity::ClassIdentity>::NAME,
602 "GetByIndex",
603 )
604 });
605 let __inner: extern "C" fn(SortedList, i32, ::unity::OptionalMethod) -> crate::system::object::Object =
606 ::core::mem::transmute(__vi.method_ptr);
607 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
608 __inner(__receiver, ::core::convert::Into::into(index), __mi)
609 }
610 }
611 }
612 #[doc = "`System.Collections.IEnumerable.GetEnumerator()` overload"]
613 fn system_collections_i_enumerable_get_enumerator(self) -> crate::system::collections::ienumerator::IEnumerator {
614 unsafe {
615 let __receiver = <SortedList 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(18usize).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 18usize,
626 __vt.len(),
627 <SortedList as ::unity::ClassIdentity>::NAME,
628 "System.Collections.IEnumerable.GetEnumerator",
629 )
630 });
631 let __inner: extern "C" fn(SortedList, ::unity::OptionalMethod) -> crate::system::collections::ienumerator::IEnumerator =
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, __mi)
635 }
636 }
637 }
638 #[doc = "`GetEnumerator()` overload"]
639 fn get_enumerator(self) -> crate::system::collections::idictionaryenumerator::IDictionaryEnumerator {
640 unsafe {
641 let __receiver = <SortedList 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(36usize).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 36usize,
652 __vt.len(),
653 <SortedList as ::unity::ClassIdentity>::NAME,
654 "GetEnumerator",
655 )
656 });
657 let __inner: extern "C" fn(
658 SortedList,
659 ::unity::OptionalMethod,
660 ) -> crate::system::collections::idictionaryenumerator::IDictionaryEnumerator = ::core::mem::transmute(__vi.method_ptr);
661 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
662 __inner(__receiver, __mi)
663 }
664 }
665 }
666 #[doc = "`GetKey(i32)` overload"]
667 fn get_key(self, index: impl ::core::convert::Into<i32>) -> crate::system::object::Object {
668 unsafe {
669 let __receiver = <SortedList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
670 {
671 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
672 let __vi = *__vt.get(37usize).unwrap_or_else(|| {
673 panic!(
674 "unity: virtual slot {}
675 out of range (vtable len {}
676) on the runtime class behind {}
677 (method `{}
678`)",
679 37usize,
680 __vt.len(),
681 <SortedList as ::unity::ClassIdentity>::NAME,
682 "GetKey",
683 )
684 });
685 let __inner: extern "C" fn(SortedList, i32, ::unity::OptionalMethod) -> crate::system::object::Object =
686 ::core::mem::transmute(__vi.method_ptr);
687 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
688 __inner(__receiver, ::core::convert::Into::into(index), __mi)
689 }
690 }
691 }
692 #[doc = "`GetKeyList()` overload"]
693 fn get_key_list(self) -> crate::system::collections::ilist::IList {
694 unsafe {
695 let __receiver = <SortedList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
696 {
697 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
698 let __vi = *__vt.get(38usize).unwrap_or_else(|| {
699 panic!(
700 "unity: virtual slot {}
701 out of range (vtable len {}
702) on the runtime class behind {}
703 (method `{}
704`)",
705 38usize,
706 __vt.len(),
707 <SortedList as ::unity::ClassIdentity>::NAME,
708 "GetKeyList",
709 )
710 });
711 let __inner: extern "C" fn(SortedList, ::unity::OptionalMethod) -> crate::system::collections::ilist::IList =
712 ::core::mem::transmute(__vi.method_ptr);
713 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
714 __inner(__receiver, __mi)
715 }
716 }
717 }
718 #[doc = "`GetValueList()` overload"]
719 fn get_value_list(self) -> crate::system::collections::ilist::IList {
720 unsafe {
721 let __receiver = <SortedList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
722 {
723 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
724 let __vi = *__vt.get(39usize).unwrap_or_else(|| {
725 panic!(
726 "unity: virtual slot {}
727 out of range (vtable len {}
728) on the runtime class behind {}
729 (method `{}
730`)",
731 39usize,
732 __vt.len(),
733 <SortedList as ::unity::ClassIdentity>::NAME,
734 "GetValueList",
735 )
736 });
737 let __inner: extern "C" fn(SortedList, ::unity::OptionalMethod) -> crate::system::collections::ilist::IList =
738 ::core::mem::transmute(__vi.method_ptr);
739 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
740 __inner(__receiver, __mi)
741 }
742 }
743 }
744 #[doc = "`get_Item(crate::system::object::Object)` overload"]
745 fn get_item(self, key: impl ::core::convert::Into<crate::system::object::Object>) -> crate::system::object::Object {
746 unsafe {
747 let __receiver = <SortedList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
748 {
749 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
750 let __vi = *__vt.get(40usize).unwrap_or_else(|| {
751 panic!(
752 "unity: virtual slot {}
753 out of range (vtable len {}
754) on the runtime class behind {}
755 (method `{}
756`)",
757 40usize,
758 __vt.len(),
759 <SortedList as ::unity::ClassIdentity>::NAME,
760 "get_Item",
761 )
762 });
763 let __inner: extern "C" fn(SortedList, crate::system::object::Object, ::unity::OptionalMethod) -> crate::system::object::Object =
764 ::core::mem::transmute(__vi.method_ptr);
765 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
766 __inner(__receiver, ::core::convert::Into::into(key), __mi)
767 }
768 }
769 }
770 #[doc = "`set_Item(crate::system::object::Object, crate::system::object::Object)` overload"]
771 fn set_item(
772 self,
773 key: impl ::core::convert::Into<crate::system::object::Object>,
774 value: impl ::core::convert::Into<crate::system::object::Object>,
775 ) -> () {
776 unsafe {
777 let __receiver = <SortedList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
778 {
779 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
780 let __vi = *__vt.get(41usize).unwrap_or_else(|| {
781 panic!(
782 "unity: virtual slot {}
783 out of range (vtable len {}
784) on the runtime class behind {}
785 (method `{}
786`)",
787 41usize,
788 __vt.len(),
789 <SortedList as ::unity::ClassIdentity>::NAME,
790 "set_Item",
791 )
792 });
793 let __inner: extern "C" fn(SortedList, crate::system::object::Object, crate::system::object::Object, ::unity::OptionalMethod) -> () =
794 ::core::mem::transmute(__vi.method_ptr);
795 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
796 __inner(__receiver, ::core::convert::Into::into(key), ::core::convert::Into::into(value), __mi)
797 }
798 }
799 }
800 #[doc = "`IndexOfKey(crate::system::object::Object)` overload"]
801 fn index_of_key(self, key: impl ::core::convert::Into<crate::system::object::Object>) -> i32 {
802 unsafe {
803 let __receiver = <SortedList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
804 {
805 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
806 let __vi = *__vt.get(42usize).unwrap_or_else(|| {
807 panic!(
808 "unity: virtual slot {}
809 out of range (vtable len {}
810) on the runtime class behind {}
811 (method `{}
812`)",
813 42usize,
814 __vt.len(),
815 <SortedList as ::unity::ClassIdentity>::NAME,
816 "IndexOfKey",
817 )
818 });
819 let __inner: extern "C" fn(SortedList, crate::system::object::Object, ::unity::OptionalMethod) -> i32 =
820 ::core::mem::transmute(__vi.method_ptr);
821 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
822 __inner(__receiver, ::core::convert::Into::into(key), __mi)
823 }
824 }
825 }
826 #[doc = "`IndexOfValue(crate::system::object::Object)` overload"]
827 fn index_of_value(self, value: impl ::core::convert::Into<crate::system::object::Object>) -> i32 {
828 unsafe {
829 let __receiver = <SortedList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
830 {
831 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
832 let __vi = *__vt.get(43usize).unwrap_or_else(|| {
833 panic!(
834 "unity: virtual slot {}
835 out of range (vtable len {}
836) on the runtime class behind {}
837 (method `{}
838`)",
839 43usize,
840 __vt.len(),
841 <SortedList as ::unity::ClassIdentity>::NAME,
842 "IndexOfValue",
843 )
844 });
845 let __inner: extern "C" fn(SortedList, crate::system::object::Object, ::unity::OptionalMethod) -> i32 =
846 ::core::mem::transmute(__vi.method_ptr);
847 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
848 __inner(__receiver, ::core::convert::Into::into(value), __mi)
849 }
850 }
851 }
852 #[doc = "`Insert(i32, crate::system::object::Object, crate::system::object::Object)` overload"]
853 fn insert(
854 self,
855 index: impl ::core::convert::Into<i32>,
856 key: impl ::core::convert::Into<crate::system::object::Object>,
857 value: impl ::core::convert::Into<crate::system::object::Object>,
858 ) -> () {
859 unsafe {
860 let __receiver = <SortedList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
861 ::unity::il2cpp_call!((::unity::module_base()+0x37758d0usize)as*mut u8,();
862(SortedList)__receiver,(i32)::core::convert::Into::into(index),(crate::system::object::Object)::core::convert::Into::into(key),(crate::system::object::Object)::core::convert::Into::into(value))
863 }
864 }
865 #[doc = "`RemoveAt(i32)` overload"]
866 fn remove_at(self, index: impl ::core::convert::Into<i32>) -> () {
867 unsafe {
868 let __receiver = <SortedList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
869 {
870 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
871 let __vi = *__vt.get(44usize).unwrap_or_else(|| {
872 panic!(
873 "unity: virtual slot {}
874 out of range (vtable len {}
875) on the runtime class behind {}
876 (method `{}
877`)",
878 44usize,
879 __vt.len(),
880 <SortedList as ::unity::ClassIdentity>::NAME,
881 "RemoveAt",
882 )
883 });
884 let __inner: extern "C" fn(SortedList, i32, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
885 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
886 __inner(__receiver, ::core::convert::Into::into(index), __mi)
887 }
888 }
889 }
890 #[doc = "`Remove(crate::system::object::Object)` overload"]
891 fn remove(self, key: impl ::core::convert::Into<crate::system::object::Object>) -> () {
892 unsafe {
893 let __receiver = <SortedList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
894 {
895 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
896 let __vi = *__vt.get(45usize).unwrap_or_else(|| {
897 panic!(
898 "unity: virtual slot {}
899 out of range (vtable len {}
900) on the runtime class behind {}
901 (method `{}
902`)",
903 45usize,
904 __vt.len(),
905 <SortedList as ::unity::ClassIdentity>::NAME,
906 "Remove",
907 )
908 });
909 let __inner: extern "C" fn(SortedList, crate::system::object::Object, ::unity::OptionalMethod) -> () =
910 ::core::mem::transmute(__vi.method_ptr);
911 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
912 __inner(__receiver, ::core::convert::Into::into(key), __mi)
913 }
914 }
915 }
916}
917
918#[cfg(feature = "system-collections-sortedlist")]
919impl<__T: ISortedList> ISortedListMethods for __T {}
920
921#[cfg(feature = "system-collections-sortedlist")]
922impl SortedList {
923 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
924 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
925 }
926
927 pub fn init_method_info() -> &'static ::unity::il2cpp::MethodInfo {
928 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
929 }
930
931 pub fn ctor_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
932 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
933 }
934
935 pub fn ctor_3_method_info() -> &'static ::unity::il2cpp::MethodInfo {
936 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
937 }
938
939 pub fn ctor_4_method_info() -> &'static ::unity::il2cpp::MethodInfo {
940 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
941 }
942
943 pub fn add_method_info() -> &'static ::unity::il2cpp::MethodInfo {
944 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
945 }
946
947 pub fn get_capacity_method_info() -> &'static ::unity::il2cpp::MethodInfo {
948 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
949 }
950
951 pub fn set_capacity_method_info() -> &'static ::unity::il2cpp::MethodInfo {
952 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
953 }
954
955 pub fn get_count_method_info() -> &'static ::unity::il2cpp::MethodInfo {
956 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[8]
957 }
958
959 pub fn get_keys_method_info() -> &'static ::unity::il2cpp::MethodInfo {
960 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[9]
961 }
962
963 pub fn get_values_method_info() -> &'static ::unity::il2cpp::MethodInfo {
964 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[10]
965 }
966
967 pub fn get_is_read_only_method_info() -> &'static ::unity::il2cpp::MethodInfo {
968 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[11]
969 }
970
971 pub fn get_is_fixed_size_method_info() -> &'static ::unity::il2cpp::MethodInfo {
972 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[12]
973 }
974
975 pub fn get_is_synchronized_method_info() -> &'static ::unity::il2cpp::MethodInfo {
976 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[13]
977 }
978
979 pub fn get_sync_root_method_info() -> &'static ::unity::il2cpp::MethodInfo {
980 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[14]
981 }
982
983 pub fn clone_method_info() -> &'static ::unity::il2cpp::MethodInfo {
984 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[15]
985 }
986
987 pub fn contains_method_info() -> &'static ::unity::il2cpp::MethodInfo {
988 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[16]
989 }
990
991 pub fn contains_key_method_info() -> &'static ::unity::il2cpp::MethodInfo {
992 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[17]
993 }
994
995 pub fn contains_value_method_info() -> &'static ::unity::il2cpp::MethodInfo {
996 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[18]
997 }
998
999 pub fn copy_to_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1000 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[19]
1001 }
1002
1003 pub fn ensure_capacity_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1004 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[20]
1005 }
1006
1007 pub fn get_by_index_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1008 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[21]
1009 }
1010
1011 pub fn system_collections_i_enumerable_get_enumerator_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1012 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[22]
1013 }
1014
1015 pub fn get_enumerator_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1016 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[23]
1017 }
1018
1019 pub fn get_key_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1020 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[24]
1021 }
1022
1023 pub fn get_key_list_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1024 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[25]
1025 }
1026
1027 pub fn get_value_list_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1028 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[26]
1029 }
1030
1031 pub fn get_item_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1032 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[27]
1033 }
1034
1035 pub fn set_item_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1036 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[28]
1037 }
1038
1039 pub fn index_of_key_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1040 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[29]
1041 }
1042
1043 pub fn index_of_value_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1044 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[30]
1045 }
1046
1047 pub fn insert_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1048 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[31]
1049 }
1050
1051 pub fn remove_at_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1052 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[32]
1053 }
1054
1055 pub fn remove_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1056 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[33]
1057 }
1058
1059 pub fn synchronized_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1060 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[34]
1061 }
1062
1063 pub fn cctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1064 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[35]
1065 }
1066}
1067
1068#[cfg(feature = "system-collections-sortedlist")]
1069impl SortedList {
1070 #[doc = "Direct (non-virtual) call to `SortedList`'s own `Add`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1071 pub unsafe fn add(
1072 this: impl ::core::convert::Into<::unity::IlInstance>,
1073 key: crate::system::object::Object,
1074 value: crate::system::object::Object,
1075 ) -> () {
1076 let __mi = Self::add_method_info();
1077 let __inner: extern "C" fn(::unity::IlInstance, crate::system::object::Object, crate::system::object::Object, ::unity::OptionalMethod) -> () =
1078 ::core::mem::transmute(__mi.method_ptr);
1079 __inner(this.into(), key, value, ::core::option::Option::None)
1080 }
1081
1082 #[doc = "Direct (non-virtual) call to `SortedList`'s own `get_Capacity`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1083 pub unsafe fn get_capacity(this: impl ::core::convert::Into<::unity::IlInstance>) -> i32 {
1084 let __mi = Self::get_capacity_method_info();
1085 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__mi.method_ptr);
1086 __inner(this.into(), ::core::option::Option::None)
1087 }
1088
1089 #[doc = "Direct (non-virtual) call to `SortedList`'s own `set_Capacity`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1090 pub unsafe fn set_capacity(this: impl ::core::convert::Into<::unity::IlInstance>, value: i32) -> () {
1091 let __mi = Self::set_capacity_method_info();
1092 let __inner: extern "C" fn(::unity::IlInstance, i32, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
1093 __inner(this.into(), value, ::core::option::Option::None)
1094 }
1095
1096 #[doc = "Direct (non-virtual) call to `SortedList`'s own `get_Count`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1097 pub unsafe fn get_count(this: impl ::core::convert::Into<::unity::IlInstance>) -> i32 {
1098 let __mi = Self::get_count_method_info();
1099 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__mi.method_ptr);
1100 __inner(this.into(), ::core::option::Option::None)
1101 }
1102
1103 #[doc = "Direct (non-virtual) call to `SortedList`'s own `get_Keys`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1104 pub unsafe fn get_keys(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::system::collections::icollection::ICollection {
1105 let __mi = Self::get_keys_method_info();
1106 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::system::collections::icollection::ICollection =
1107 ::core::mem::transmute(__mi.method_ptr);
1108 __inner(this.into(), ::core::option::Option::None)
1109 }
1110
1111 #[doc = "Direct (non-virtual) call to `SortedList`'s own `get_Values`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1112 pub unsafe fn get_values(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::system::collections::icollection::ICollection {
1113 let __mi = Self::get_values_method_info();
1114 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::system::collections::icollection::ICollection =
1115 ::core::mem::transmute(__mi.method_ptr);
1116 __inner(this.into(), ::core::option::Option::None)
1117 }
1118
1119 #[doc = "Direct (non-virtual) call to `SortedList`'s own `get_IsReadOnly`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1120 pub unsafe fn get_is_read_only(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
1121 let __mi = Self::get_is_read_only_method_info();
1122 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
1123 __inner(this.into(), ::core::option::Option::None)
1124 }
1125
1126 #[doc = "Direct (non-virtual) call to `SortedList`'s own `get_IsFixedSize`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1127 pub unsafe fn get_is_fixed_size(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
1128 let __mi = Self::get_is_fixed_size_method_info();
1129 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
1130 __inner(this.into(), ::core::option::Option::None)
1131 }
1132
1133 #[doc = "Direct (non-virtual) call to `SortedList`'s own `get_IsSynchronized`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1134 pub unsafe fn get_is_synchronized(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
1135 let __mi = Self::get_is_synchronized_method_info();
1136 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
1137 __inner(this.into(), ::core::option::Option::None)
1138 }
1139
1140 #[doc = "Direct (non-virtual) call to `SortedList`'s own `get_SyncRoot`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1141 pub unsafe fn get_sync_root(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::system::object::Object {
1142 let __mi = Self::get_sync_root_method_info();
1143 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::system::object::Object =
1144 ::core::mem::transmute(__mi.method_ptr);
1145 __inner(this.into(), ::core::option::Option::None)
1146 }
1147
1148 #[doc = "Direct (non-virtual) call to `SortedList`'s own `Clone`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1149 pub unsafe fn clone(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::system::object::Object {
1150 let __mi = Self::clone_method_info();
1151 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::system::object::Object =
1152 ::core::mem::transmute(__mi.method_ptr);
1153 __inner(this.into(), ::core::option::Option::None)
1154 }
1155
1156 #[doc = "Direct (non-virtual) call to `SortedList`'s own `Contains`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1157 pub unsafe fn contains(this: impl ::core::convert::Into<::unity::IlInstance>, key: crate::system::object::Object) -> bool {
1158 let __mi = Self::contains_method_info();
1159 let __inner: extern "C" fn(::unity::IlInstance, crate::system::object::Object, ::unity::OptionalMethod) -> bool =
1160 ::core::mem::transmute(__mi.method_ptr);
1161 __inner(this.into(), key, ::core::option::Option::None)
1162 }
1163
1164 #[doc = "Direct (non-virtual) call to `SortedList`'s own `ContainsKey`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1165 pub unsafe fn contains_key(this: impl ::core::convert::Into<::unity::IlInstance>, key: crate::system::object::Object) -> bool {
1166 let __mi = Self::contains_key_method_info();
1167 let __inner: extern "C" fn(::unity::IlInstance, crate::system::object::Object, ::unity::OptionalMethod) -> bool =
1168 ::core::mem::transmute(__mi.method_ptr);
1169 __inner(this.into(), key, ::core::option::Option::None)
1170 }
1171
1172 #[doc = "Direct (non-virtual) call to `SortedList`'s own `ContainsValue`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1173 pub unsafe fn contains_value(this: impl ::core::convert::Into<::unity::IlInstance>, value: crate::system::object::Object) -> bool {
1174 let __mi = Self::contains_value_method_info();
1175 let __inner: extern "C" fn(::unity::IlInstance, crate::system::object::Object, ::unity::OptionalMethod) -> bool =
1176 ::core::mem::transmute(__mi.method_ptr);
1177 __inner(this.into(), value, ::core::option::Option::None)
1178 }
1179
1180 #[doc = "Direct (non-virtual) call to `SortedList`'s own `CopyTo`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1181 pub unsafe fn copy_to(this: impl ::core::convert::Into<::unity::IlInstance>, array: ::unity::IlInstance, array_index: i32) -> () {
1182 let __mi = Self::copy_to_method_info();
1183 let __inner: extern "C" fn(::unity::IlInstance, ::unity::IlInstance, i32, ::unity::OptionalMethod) -> () =
1184 ::core::mem::transmute(__mi.method_ptr);
1185 __inner(this.into(), array, array_index, ::core::option::Option::None)
1186 }
1187
1188 #[doc = "Direct (non-virtual) call to `SortedList`'s own `GetByIndex`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1189 pub unsafe fn get_by_index(this: impl ::core::convert::Into<::unity::IlInstance>, index: i32) -> crate::system::object::Object {
1190 let __mi = Self::get_by_index_method_info();
1191 let __inner: extern "C" fn(::unity::IlInstance, i32, ::unity::OptionalMethod) -> crate::system::object::Object =
1192 ::core::mem::transmute(__mi.method_ptr);
1193 __inner(this.into(), index, ::core::option::Option::None)
1194 }
1195
1196 #[doc = "Direct (non-virtual) call to `SortedList`'s own `System.Collections.IEnumerable.GetEnumerator`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1197 pub unsafe fn system_collections_i_enumerable_get_enumerator(
1198 this: impl ::core::convert::Into<::unity::IlInstance>,
1199 ) -> crate::system::collections::ienumerator::IEnumerator {
1200 let __mi = Self::system_collections_i_enumerable_get_enumerator_method_info();
1201 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::system::collections::ienumerator::IEnumerator =
1202 ::core::mem::transmute(__mi.method_ptr);
1203 __inner(this.into(), ::core::option::Option::None)
1204 }
1205
1206 #[doc = "Direct (non-virtual) call to `SortedList`'s own `GetEnumerator`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1207 pub unsafe fn get_enumerator(
1208 this: impl ::core::convert::Into<::unity::IlInstance>,
1209 ) -> crate::system::collections::idictionaryenumerator::IDictionaryEnumerator {
1210 let __mi = Self::get_enumerator_method_info();
1211 let __inner: extern "C" fn(
1212 ::unity::IlInstance,
1213 ::unity::OptionalMethod,
1214 ) -> crate::system::collections::idictionaryenumerator::IDictionaryEnumerator = ::core::mem::transmute(__mi.method_ptr);
1215 __inner(this.into(), ::core::option::Option::None)
1216 }
1217
1218 #[doc = "Direct (non-virtual) call to `SortedList`'s own `GetKey`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1219 pub unsafe fn get_key(this: impl ::core::convert::Into<::unity::IlInstance>, index: i32) -> crate::system::object::Object {
1220 let __mi = Self::get_key_method_info();
1221 let __inner: extern "C" fn(::unity::IlInstance, i32, ::unity::OptionalMethod) -> crate::system::object::Object =
1222 ::core::mem::transmute(__mi.method_ptr);
1223 __inner(this.into(), index, ::core::option::Option::None)
1224 }
1225
1226 #[doc = "Direct (non-virtual) call to `SortedList`'s own `GetKeyList`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1227 pub unsafe fn get_key_list(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::system::collections::ilist::IList {
1228 let __mi = Self::get_key_list_method_info();
1229 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::system::collections::ilist::IList =
1230 ::core::mem::transmute(__mi.method_ptr);
1231 __inner(this.into(), ::core::option::Option::None)
1232 }
1233
1234 #[doc = "Direct (non-virtual) call to `SortedList`'s own `GetValueList`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1235 pub unsafe fn get_value_list(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::system::collections::ilist::IList {
1236 let __mi = Self::get_value_list_method_info();
1237 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::system::collections::ilist::IList =
1238 ::core::mem::transmute(__mi.method_ptr);
1239 __inner(this.into(), ::core::option::Option::None)
1240 }
1241
1242 #[doc = "Direct (non-virtual) call to `SortedList`'s own `get_Item`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1243 pub unsafe fn get_item(
1244 this: impl ::core::convert::Into<::unity::IlInstance>,
1245 key: crate::system::object::Object,
1246 ) -> crate::system::object::Object {
1247 let __mi = Self::get_item_method_info();
1248 let __inner: extern "C" fn(::unity::IlInstance, crate::system::object::Object, ::unity::OptionalMethod) -> crate::system::object::Object =
1249 ::core::mem::transmute(__mi.method_ptr);
1250 __inner(this.into(), key, ::core::option::Option::None)
1251 }
1252
1253 #[doc = "Direct (non-virtual) call to `SortedList`'s own `set_Item`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1254 pub unsafe fn set_item(
1255 this: impl ::core::convert::Into<::unity::IlInstance>,
1256 key: crate::system::object::Object,
1257 value: crate::system::object::Object,
1258 ) -> () {
1259 let __mi = Self::set_item_method_info();
1260 let __inner: extern "C" fn(::unity::IlInstance, crate::system::object::Object, crate::system::object::Object, ::unity::OptionalMethod) -> () =
1261 ::core::mem::transmute(__mi.method_ptr);
1262 __inner(this.into(), key, value, ::core::option::Option::None)
1263 }
1264
1265 #[doc = "Direct (non-virtual) call to `SortedList`'s own `IndexOfKey`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1266 pub unsafe fn index_of_key(this: impl ::core::convert::Into<::unity::IlInstance>, key: crate::system::object::Object) -> i32 {
1267 let __mi = Self::index_of_key_method_info();
1268 let __inner: extern "C" fn(::unity::IlInstance, crate::system::object::Object, ::unity::OptionalMethod) -> i32 =
1269 ::core::mem::transmute(__mi.method_ptr);
1270 __inner(this.into(), key, ::core::option::Option::None)
1271 }
1272
1273 #[doc = "Direct (non-virtual) call to `SortedList`'s own `IndexOfValue`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1274 pub unsafe fn index_of_value(this: impl ::core::convert::Into<::unity::IlInstance>, value: crate::system::object::Object) -> i32 {
1275 let __mi = Self::index_of_value_method_info();
1276 let __inner: extern "C" fn(::unity::IlInstance, crate::system::object::Object, ::unity::OptionalMethod) -> i32 =
1277 ::core::mem::transmute(__mi.method_ptr);
1278 __inner(this.into(), value, ::core::option::Option::None)
1279 }
1280
1281 #[doc = "Direct (non-virtual) call to `SortedList`'s own `RemoveAt`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1282 pub unsafe fn remove_at(this: impl ::core::convert::Into<::unity::IlInstance>, index: i32) -> () {
1283 let __mi = Self::remove_at_method_info();
1284 let __inner: extern "C" fn(::unity::IlInstance, i32, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
1285 __inner(this.into(), index, ::core::option::Option::None)
1286 }
1287
1288 #[doc = "Direct (non-virtual) call to `SortedList`'s own `Remove`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1289 pub unsafe fn remove(this: impl ::core::convert::Into<::unity::IlInstance>, key: crate::system::object::Object) -> () {
1290 let __mi = Self::remove_method_info();
1291 let __inner: extern "C" fn(::unity::IlInstance, crate::system::object::Object, ::unity::OptionalMethod) -> () =
1292 ::core::mem::transmute(__mi.method_ptr);
1293 __inner(this.into(), key, ::core::option::Option::None)
1294 }
1295}
1296
1297#[cfg(feature = "system-collections-sortedlist")]
1298impl SortedList {
1299 #[doc = "`.ctor()` — no args"]
1300 pub fn new() -> Self {
1301 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1302 panic!(
1303 "{}
1304::{}
1305 failed to instantiate",
1306 ::core::stringify!(SortedList),
1307 ::core::stringify!(new),
1308 )
1309 });
1310 <Self as ISortedListMethods>::ctor(this);
1311 this
1312 }
1313
1314 #[doc = "`.ctor(i32)` — overload selector"]
1315 pub fn new_2(initial_capacity: i32) -> Self {
1316 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1317 panic!(
1318 "{}
1319::{}
1320 failed to instantiate",
1321 ::core::stringify!(SortedList),
1322 ::core::stringify!(new_2),
1323 )
1324 });
1325 <Self as ISortedListMethods>::ctor_2(this, initial_capacity);
1326 this
1327 }
1328
1329 #[doc = "`.ctor(crate::system::collections::icomparer_interface::IComparer_Interface)` — overload selector"]
1330 pub fn new_3(comparer: crate::system::collections::icomparer_interface::IComparer_Interface) -> Self {
1331 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1332 panic!(
1333 "{}
1334::{}
1335 failed to instantiate",
1336 ::core::stringify!(SortedList),
1337 ::core::stringify!(new_3),
1338 )
1339 });
1340 <Self as ISortedListMethods>::ctor_3(this, comparer);
1341 this
1342 }
1343
1344 #[doc = "`.ctor(crate::system::collections::icomparer_interface::IComparer_Interface, i32)` — overload selector"]
1345 pub fn new_4(comparer: crate::system::collections::icomparer_interface::IComparer_Interface, capacity: i32) -> Self {
1346 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1347 panic!(
1348 "{}
1349::{}
1350 failed to instantiate",
1351 ::core::stringify!(SortedList),
1352 ::core::stringify!(new_4),
1353 )
1354 });
1355 <Self as ISortedListMethods>::ctor_4(this, comparer, capacity);
1356 this
1357 }
1358}
1359
1360#[cfg(feature = "system-collections-sortedlist")]
1361pub trait ISortedList_SortedListEnumeratorMethods: ISortedList_SortedListEnumerator {
1362 #[doc = "`.ctor(crate::system::collections::sortedlist::SortedList, i32, i32, i32)` overload"]
1363 fn ctor(
1364 self,
1365 sorted_list: impl ::core::convert::Into<crate::system::collections::sortedlist::SortedList>,
1366 index: impl ::core::convert::Into<i32>,
1367 count: impl ::core::convert::Into<i32>,
1368 get_obj_ret_type: impl ::core::convert::Into<i32>,
1369 ) -> () {
1370 unsafe {
1371 let __receiver =
1372 <SortedList_SortedListEnumerator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1373 ::unity::il2cpp_call!((::unity::module_base()+0x3c55cd0usize)as*mut u8,();
1374(SortedList_SortedListEnumerator)__receiver,(crate::system::collections::sortedlist::SortedList)::core::convert::Into::into(sorted_list),(i32)::core::convert::Into::into(index),(i32)::core::convert::Into::into(count),(i32)::core::convert::Into::into(get_obj_ret_type))
1375 }
1376 }
1377 #[doc = "`Clone()` overload"]
1378 fn clone(self) -> crate::system::object::Object {
1379 unsafe {
1380 let __receiver =
1381 <SortedList_SortedListEnumerator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1382 {
1383 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1384 let __vi = *__vt.get(10usize).unwrap_or_else(|| {
1385 panic!(
1386 "unity: virtual slot {}
1387 out of range (vtable len {}
1388) on the runtime class behind {}
1389 (method `{}
1390`)",
1391 10usize,
1392 __vt.len(),
1393 <SortedList_SortedListEnumerator as ::unity::ClassIdentity>::NAME,
1394 "Clone",
1395 )
1396 });
1397 let __inner: extern "C" fn(SortedList_SortedListEnumerator, ::unity::OptionalMethod) -> crate::system::object::Object =
1398 ::core::mem::transmute(__vi.method_ptr);
1399 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1400 __inner(__receiver, __mi)
1401 }
1402 }
1403 }
1404 #[doc = "`get_Key()` overload"]
1405 fn get_key(self) -> crate::system::object::Object {
1406 unsafe {
1407 let __receiver =
1408 <SortedList_SortedListEnumerator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1409 {
1410 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1411 let __vi = *__vt.get(11usize).unwrap_or_else(|| {
1412 panic!(
1413 "unity: virtual slot {}
1414 out of range (vtable len {}
1415) on the runtime class behind {}
1416 (method `{}
1417`)",
1418 11usize,
1419 __vt.len(),
1420 <SortedList_SortedListEnumerator as ::unity::ClassIdentity>::NAME,
1421 "get_Key",
1422 )
1423 });
1424 let __inner: extern "C" fn(SortedList_SortedListEnumerator, ::unity::OptionalMethod) -> crate::system::object::Object =
1425 ::core::mem::transmute(__vi.method_ptr);
1426 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1427 __inner(__receiver, __mi)
1428 }
1429 }
1430 }
1431 #[doc = "`MoveNext()` overload"]
1432 fn move_next(self) -> bool {
1433 unsafe {
1434 let __receiver =
1435 <SortedList_SortedListEnumerator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1436 {
1437 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1438 let __vi = *__vt.get(12usize).unwrap_or_else(|| {
1439 panic!(
1440 "unity: virtual slot {}
1441 out of range (vtable len {}
1442) on the runtime class behind {}
1443 (method `{}
1444`)",
1445 12usize,
1446 __vt.len(),
1447 <SortedList_SortedListEnumerator as ::unity::ClassIdentity>::NAME,
1448 "MoveNext",
1449 )
1450 });
1451 let __inner: extern "C" fn(SortedList_SortedListEnumerator, ::unity::OptionalMethod) -> bool =
1452 ::core::mem::transmute(__vi.method_ptr);
1453 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1454 __inner(__receiver, __mi)
1455 }
1456 }
1457 }
1458 #[doc = "`get_Entry()` overload"]
1459 fn get_entry(self) -> crate::system::collections::dictionaryentry::DictionaryEntry {
1460 unsafe {
1461 let __receiver =
1462 <SortedList_SortedListEnumerator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1463 {
1464 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1465 let __vi = *__vt.get(13usize).unwrap_or_else(|| {
1466 panic!(
1467 "unity: virtual slot {}
1468 out of range (vtable len {}
1469) on the runtime class behind {}
1470 (method `{}
1471`)",
1472 13usize,
1473 __vt.len(),
1474 <SortedList_SortedListEnumerator as ::unity::ClassIdentity>::NAME,
1475 "get_Entry",
1476 )
1477 });
1478 let __inner: extern "C" fn(
1479 SortedList_SortedListEnumerator,
1480 ::unity::OptionalMethod,
1481 ) -> crate::system::collections::dictionaryentry::DictionaryEntry = ::core::mem::transmute(__vi.method_ptr);
1482 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1483 __inner(__receiver, __mi)
1484 }
1485 }
1486 }
1487 #[doc = "`get_Current()` overload"]
1488 fn get_current(self) -> crate::system::object::Object {
1489 unsafe {
1490 let __receiver =
1491 <SortedList_SortedListEnumerator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1492 {
1493 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1494 let __vi = *__vt.get(14usize).unwrap_or_else(|| {
1495 panic!(
1496 "unity: virtual slot {}
1497 out of range (vtable len {}
1498) on the runtime class behind {}
1499 (method `{}
1500`)",
1501 14usize,
1502 __vt.len(),
1503 <SortedList_SortedListEnumerator as ::unity::ClassIdentity>::NAME,
1504 "get_Current",
1505 )
1506 });
1507 let __inner: extern "C" fn(SortedList_SortedListEnumerator, ::unity::OptionalMethod) -> crate::system::object::Object =
1508 ::core::mem::transmute(__vi.method_ptr);
1509 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1510 __inner(__receiver, __mi)
1511 }
1512 }
1513 }
1514 #[doc = "`get_Value()` overload"]
1515 fn get_value(self) -> crate::system::object::Object {
1516 unsafe {
1517 let __receiver =
1518 <SortedList_SortedListEnumerator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1519 {
1520 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1521 let __vi = *__vt.get(15usize).unwrap_or_else(|| {
1522 panic!(
1523 "unity: virtual slot {}
1524 out of range (vtable len {}
1525) on the runtime class behind {}
1526 (method `{}
1527`)",
1528 15usize,
1529 __vt.len(),
1530 <SortedList_SortedListEnumerator as ::unity::ClassIdentity>::NAME,
1531 "get_Value",
1532 )
1533 });
1534 let __inner: extern "C" fn(SortedList_SortedListEnumerator, ::unity::OptionalMethod) -> crate::system::object::Object =
1535 ::core::mem::transmute(__vi.method_ptr);
1536 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1537 __inner(__receiver, __mi)
1538 }
1539 }
1540 }
1541 #[doc = "`Reset()` overload"]
1542 fn reset(self) -> () {
1543 unsafe {
1544 let __receiver =
1545 <SortedList_SortedListEnumerator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1546 {
1547 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1548 let __vi = *__vt.get(16usize).unwrap_or_else(|| {
1549 panic!(
1550 "unity: virtual slot {}
1551 out of range (vtable len {}
1552) on the runtime class behind {}
1553 (method `{}
1554`)",
1555 16usize,
1556 __vt.len(),
1557 <SortedList_SortedListEnumerator as ::unity::ClassIdentity>::NAME,
1558 "Reset",
1559 )
1560 });
1561 let __inner: extern "C" fn(SortedList_SortedListEnumerator, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
1562 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1563 __inner(__receiver, __mi)
1564 }
1565 }
1566 }
1567}
1568
1569#[cfg(feature = "system-collections-sortedlist")]
1570impl<__T: ISortedList_SortedListEnumerator> ISortedList_SortedListEnumeratorMethods for __T {}
1571
1572#[cfg(feature = "system-collections-sortedlist")]
1573impl SortedList_SortedListEnumerator {
1574 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1575 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
1576 }
1577
1578 pub fn clone_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1579 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
1580 }
1581
1582 pub fn get_key_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1583 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
1584 }
1585
1586 pub fn move_next_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1587 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
1588 }
1589
1590 pub fn get_entry_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1591 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
1592 }
1593
1594 pub fn get_current_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1595 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
1596 }
1597
1598 pub fn get_value_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1599 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
1600 }
1601
1602 pub fn reset_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1603 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
1604 }
1605}
1606
1607#[cfg(feature = "system-collections-sortedlist")]
1608impl SortedList_SortedListEnumerator {
1609 #[doc = "Direct (non-virtual) call to `SortedList_SortedListEnumerator`'s own `Clone`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1610 pub unsafe fn clone(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::system::object::Object {
1611 let __mi = Self::clone_method_info();
1612 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::system::object::Object =
1613 ::core::mem::transmute(__mi.method_ptr);
1614 __inner(this.into(), ::core::option::Option::None)
1615 }
1616
1617 #[doc = "Direct (non-virtual) call to `SortedList_SortedListEnumerator`'s own `get_Key`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1618 pub unsafe fn get_key(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::system::object::Object {
1619 let __mi = Self::get_key_method_info();
1620 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::system::object::Object =
1621 ::core::mem::transmute(__mi.method_ptr);
1622 __inner(this.into(), ::core::option::Option::None)
1623 }
1624
1625 #[doc = "Direct (non-virtual) call to `SortedList_SortedListEnumerator`'s own `MoveNext`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1626 pub unsafe fn move_next(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
1627 let __mi = Self::move_next_method_info();
1628 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
1629 __inner(this.into(), ::core::option::Option::None)
1630 }
1631
1632 #[doc = "Direct (non-virtual) call to `SortedList_SortedListEnumerator`'s own `get_Entry`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1633 pub unsafe fn get_entry(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::system::collections::dictionaryentry::DictionaryEntry {
1634 let __mi = Self::get_entry_method_info();
1635 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::system::collections::dictionaryentry::DictionaryEntry =
1636 ::core::mem::transmute(__mi.method_ptr);
1637 __inner(this.into(), ::core::option::Option::None)
1638 }
1639
1640 #[doc = "Direct (non-virtual) call to `SortedList_SortedListEnumerator`'s own `get_Current`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1641 pub unsafe fn get_current(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::system::object::Object {
1642 let __mi = Self::get_current_method_info();
1643 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::system::object::Object =
1644 ::core::mem::transmute(__mi.method_ptr);
1645 __inner(this.into(), ::core::option::Option::None)
1646 }
1647
1648 #[doc = "Direct (non-virtual) call to `SortedList_SortedListEnumerator`'s own `get_Value`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1649 pub unsafe fn get_value(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::system::object::Object {
1650 let __mi = Self::get_value_method_info();
1651 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::system::object::Object =
1652 ::core::mem::transmute(__mi.method_ptr);
1653 __inner(this.into(), ::core::option::Option::None)
1654 }
1655
1656 #[doc = "Direct (non-virtual) call to `SortedList_SortedListEnumerator`'s own `Reset`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1657 pub unsafe fn reset(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
1658 let __mi = Self::reset_method_info();
1659 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
1660 __inner(this.into(), ::core::option::Option::None)
1661 }
1662}
1663
1664#[cfg(feature = "system-collections-sortedlist")]
1665impl SortedList_SortedListEnumerator {
1666 #[doc = "`.ctor(crate::system::collections::sortedlist::SortedList, i32, i32, i32)` — overload selector"]
1667 pub fn new(sorted_list: crate::system::collections::sortedlist::SortedList, index: i32, count: i32, get_obj_ret_type: i32) -> Self {
1668 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1669 panic!(
1670 "{}
1671::{}
1672 failed to instantiate",
1673 ::core::stringify!(SortedList_SortedListEnumerator),
1674 ::core::stringify!(new),
1675 )
1676 });
1677 <Self as ISortedList_SortedListEnumeratorMethods>::ctor(this, sorted_list, index, count, get_obj_ret_type);
1678 this
1679 }
1680}
1681
1682#[cfg(feature = "system-collections-sortedlist")]
1683pub trait ISortedList_SyncSortedListMethods: ISortedList_SyncSortedList {
1684 #[doc = "`.ctor(crate::system::collections::sortedlist::SortedList)` overload"]
1685 fn ctor(self, list: impl ::core::convert::Into<crate::system::collections::sortedlist::SortedList>) -> () {
1686 unsafe {
1687 let __receiver =
1688 <SortedList_SyncSortedList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1689 ::unity::il2cpp_call!((::unity::module_base()+0x3c563d0usize)as*mut u8,();
1690(SortedList_SyncSortedList)__receiver,(crate::system::collections::sortedlist::SortedList)::core::convert::Into::into(list))
1691 }
1692 }
1693 #[doc = "`get_Count()` overload"]
1694 fn get_count(self) -> i32 {
1695 unsafe {
1696 let __receiver =
1697 <SortedList_SyncSortedList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1698 {
1699 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1700 let __vi = *__vt.get(23usize).unwrap_or_else(|| {
1701 panic!(
1702 "unity: virtual slot {}
1703 out of range (vtable len {}
1704) on the runtime class behind {}
1705 (method `{}
1706`)",
1707 23usize,
1708 __vt.len(),
1709 <SortedList_SyncSortedList as ::unity::ClassIdentity>::NAME,
1710 "get_Count",
1711 )
1712 });
1713 let __inner: extern "C" fn(SortedList_SyncSortedList, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__vi.method_ptr);
1714 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1715 __inner(__receiver, __mi)
1716 }
1717 }
1718 }
1719 #[doc = "`get_SyncRoot()` overload"]
1720 fn get_sync_root(self) -> crate::system::object::Object {
1721 unsafe {
1722 let __receiver =
1723 <SortedList_SyncSortedList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1724 {
1725 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1726 let __vi = *__vt.get(29usize).unwrap_or_else(|| {
1727 panic!(
1728 "unity: virtual slot {}
1729 out of range (vtable len {}
1730) on the runtime class behind {}
1731 (method `{}
1732`)",
1733 29usize,
1734 __vt.len(),
1735 <SortedList_SyncSortedList as ::unity::ClassIdentity>::NAME,
1736 "get_SyncRoot",
1737 )
1738 });
1739 let __inner: extern "C" fn(SortedList_SyncSortedList, ::unity::OptionalMethod) -> crate::system::object::Object =
1740 ::core::mem::transmute(__vi.method_ptr);
1741 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1742 __inner(__receiver, __mi)
1743 }
1744 }
1745 }
1746 #[doc = "`get_IsReadOnly()` overload"]
1747 fn get_is_read_only(self) -> bool {
1748 unsafe {
1749 let __receiver =
1750 <SortedList_SyncSortedList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1751 {
1752 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1753 let __vi = *__vt.get(26usize).unwrap_or_else(|| {
1754 panic!(
1755 "unity: virtual slot {}
1756 out of range (vtable len {}
1757) on the runtime class behind {}
1758 (method `{}
1759`)",
1760 26usize,
1761 __vt.len(),
1762 <SortedList_SyncSortedList as ::unity::ClassIdentity>::NAME,
1763 "get_IsReadOnly",
1764 )
1765 });
1766 let __inner: extern "C" fn(SortedList_SyncSortedList, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
1767 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1768 __inner(__receiver, __mi)
1769 }
1770 }
1771 }
1772 #[doc = "`get_IsFixedSize()` overload"]
1773 fn get_is_fixed_size(self) -> bool {
1774 unsafe {
1775 let __receiver =
1776 <SortedList_SyncSortedList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1777 {
1778 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1779 let __vi = *__vt.get(27usize).unwrap_or_else(|| {
1780 panic!(
1781 "unity: virtual slot {}
1782 out of range (vtable len {}
1783) on the runtime class behind {}
1784 (method `{}
1785`)",
1786 27usize,
1787 __vt.len(),
1788 <SortedList_SyncSortedList as ::unity::ClassIdentity>::NAME,
1789 "get_IsFixedSize",
1790 )
1791 });
1792 let __inner: extern "C" fn(SortedList_SyncSortedList, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
1793 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1794 __inner(__receiver, __mi)
1795 }
1796 }
1797 }
1798 #[doc = "`get_IsSynchronized()` overload"]
1799 fn get_is_synchronized(self) -> bool {
1800 unsafe {
1801 let __receiver =
1802 <SortedList_SyncSortedList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1803 {
1804 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1805 let __vi = *__vt.get(28usize).unwrap_or_else(|| {
1806 panic!(
1807 "unity: virtual slot {}
1808 out of range (vtable len {}
1809) on the runtime class behind {}
1810 (method `{}
1811`)",
1812 28usize,
1813 __vt.len(),
1814 <SortedList_SyncSortedList as ::unity::ClassIdentity>::NAME,
1815 "get_IsSynchronized",
1816 )
1817 });
1818 let __inner: extern "C" fn(SortedList_SyncSortedList, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
1819 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1820 __inner(__receiver, __mi)
1821 }
1822 }
1823 }
1824 #[doc = "`get_Item(crate::system::object::Object)` overload"]
1825 fn get_item(self, key: impl ::core::convert::Into<crate::system::object::Object>) -> crate::system::object::Object {
1826 unsafe {
1827 let __receiver =
1828 <SortedList_SyncSortedList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1829 {
1830 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1831 let __vi = *__vt.get(40usize).unwrap_or_else(|| {
1832 panic!(
1833 "unity: virtual slot {}
1834 out of range (vtable len {}
1835) on the runtime class behind {}
1836 (method `{}
1837`)",
1838 40usize,
1839 __vt.len(),
1840 <SortedList_SyncSortedList as ::unity::ClassIdentity>::NAME,
1841 "get_Item",
1842 )
1843 });
1844 let __inner: extern "C" fn(
1845 SortedList_SyncSortedList,
1846 crate::system::object::Object,
1847 ::unity::OptionalMethod,
1848 ) -> crate::system::object::Object = ::core::mem::transmute(__vi.method_ptr);
1849 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1850 __inner(__receiver, ::core::convert::Into::into(key), __mi)
1851 }
1852 }
1853 }
1854 #[doc = "`set_Item(crate::system::object::Object, crate::system::object::Object)` overload"]
1855 fn set_item(
1856 self,
1857 key: impl ::core::convert::Into<crate::system::object::Object>,
1858 value: impl ::core::convert::Into<crate::system::object::Object>,
1859 ) -> () {
1860 unsafe {
1861 let __receiver =
1862 <SortedList_SyncSortedList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1863 {
1864 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1865 let __vi = *__vt.get(41usize).unwrap_or_else(|| {
1866 panic!(
1867 "unity: virtual slot {}
1868 out of range (vtable len {}
1869) on the runtime class behind {}
1870 (method `{}
1871`)",
1872 41usize,
1873 __vt.len(),
1874 <SortedList_SyncSortedList as ::unity::ClassIdentity>::NAME,
1875 "set_Item",
1876 )
1877 });
1878 let __inner: extern "C" fn(
1879 SortedList_SyncSortedList,
1880 crate::system::object::Object,
1881 crate::system::object::Object,
1882 ::unity::OptionalMethod,
1883 ) -> () = ::core::mem::transmute(__vi.method_ptr);
1884 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1885 __inner(__receiver, ::core::convert::Into::into(key), ::core::convert::Into::into(value), __mi)
1886 }
1887 }
1888 }
1889 #[doc = "`Add(crate::system::object::Object, crate::system::object::Object)` overload"]
1890 fn add(
1891 self,
1892 key: impl ::core::convert::Into<crate::system::object::Object>,
1893 value: impl ::core::convert::Into<crate::system::object::Object>,
1894 ) -> () {
1895 unsafe {
1896 let __receiver =
1897 <SortedList_SyncSortedList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1898 {
1899 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1900 let __vi = *__vt.get(20usize).unwrap_or_else(|| {
1901 panic!(
1902 "unity: virtual slot {}
1903 out of range (vtable len {}
1904) on the runtime class behind {}
1905 (method `{}
1906`)",
1907 20usize,
1908 __vt.len(),
1909 <SortedList_SyncSortedList as ::unity::ClassIdentity>::NAME,
1910 "Add",
1911 )
1912 });
1913 let __inner: extern "C" fn(
1914 SortedList_SyncSortedList,
1915 crate::system::object::Object,
1916 crate::system::object::Object,
1917 ::unity::OptionalMethod,
1918 ) -> () = ::core::mem::transmute(__vi.method_ptr);
1919 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1920 __inner(__receiver, ::core::convert::Into::into(key), ::core::convert::Into::into(value), __mi)
1921 }
1922 }
1923 }
1924 #[doc = "`get_Capacity()` overload"]
1925 fn get_capacity(self) -> i32 {
1926 unsafe {
1927 let __receiver =
1928 <SortedList_SyncSortedList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1929 {
1930 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1931 let __vi = *__vt.get(21usize).unwrap_or_else(|| {
1932 panic!(
1933 "unity: virtual slot {}
1934 out of range (vtable len {}
1935) on the runtime class behind {}
1936 (method `{}
1937`)",
1938 21usize,
1939 __vt.len(),
1940 <SortedList_SyncSortedList as ::unity::ClassIdentity>::NAME,
1941 "get_Capacity",
1942 )
1943 });
1944 let __inner: extern "C" fn(SortedList_SyncSortedList, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__vi.method_ptr);
1945 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1946 __inner(__receiver, __mi)
1947 }
1948 }
1949 }
1950 #[doc = "`Clone()` overload"]
1951 fn clone(self) -> crate::system::object::Object {
1952 unsafe {
1953 let __receiver =
1954 <SortedList_SyncSortedList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1955 {
1956 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1957 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
1958 panic!(
1959 "unity: virtual slot {}
1960 out of range (vtable len {}
1961) on the runtime class behind {}
1962 (method `{}
1963`)",
1964 30usize,
1965 __vt.len(),
1966 <SortedList_SyncSortedList as ::unity::ClassIdentity>::NAME,
1967 "Clone",
1968 )
1969 });
1970 let __inner: extern "C" fn(SortedList_SyncSortedList, ::unity::OptionalMethod) -> crate::system::object::Object =
1971 ::core::mem::transmute(__vi.method_ptr);
1972 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1973 __inner(__receiver, __mi)
1974 }
1975 }
1976 }
1977 #[doc = "`Contains(crate::system::object::Object)` overload"]
1978 fn contains(self, key: impl ::core::convert::Into<crate::system::object::Object>) -> bool {
1979 unsafe {
1980 let __receiver =
1981 <SortedList_SyncSortedList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1982 {
1983 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1984 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
1985 panic!(
1986 "unity: virtual slot {}
1987 out of range (vtable len {}
1988) on the runtime class behind {}
1989 (method `{}
1990`)",
1991 31usize,
1992 __vt.len(),
1993 <SortedList_SyncSortedList as ::unity::ClassIdentity>::NAME,
1994 "Contains",
1995 )
1996 });
1997 let __inner: extern "C" fn(SortedList_SyncSortedList, crate::system::object::Object, ::unity::OptionalMethod) -> bool =
1998 ::core::mem::transmute(__vi.method_ptr);
1999 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2000 __inner(__receiver, ::core::convert::Into::into(key), __mi)
2001 }
2002 }
2003 }
2004 #[doc = "`ContainsKey(crate::system::object::Object)` overload"]
2005 fn contains_key(self, key: impl ::core::convert::Into<crate::system::object::Object>) -> bool {
2006 unsafe {
2007 let __receiver =
2008 <SortedList_SyncSortedList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2009 {
2010 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2011 let __vi = *__vt.get(32usize).unwrap_or_else(|| {
2012 panic!(
2013 "unity: virtual slot {}
2014 out of range (vtable len {}
2015) on the runtime class behind {}
2016 (method `{}
2017`)",
2018 32usize,
2019 __vt.len(),
2020 <SortedList_SyncSortedList as ::unity::ClassIdentity>::NAME,
2021 "ContainsKey",
2022 )
2023 });
2024 let __inner: extern "C" fn(SortedList_SyncSortedList, crate::system::object::Object, ::unity::OptionalMethod) -> bool =
2025 ::core::mem::transmute(__vi.method_ptr);
2026 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2027 __inner(__receiver, ::core::convert::Into::into(key), __mi)
2028 }
2029 }
2030 }
2031 #[doc = "`ContainsValue(crate::system::object::Object)` overload"]
2032 fn contains_value(self, key: impl ::core::convert::Into<crate::system::object::Object>) -> bool {
2033 unsafe {
2034 let __receiver =
2035 <SortedList_SyncSortedList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2036 {
2037 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2038 let __vi = *__vt.get(33usize).unwrap_or_else(|| {
2039 panic!(
2040 "unity: virtual slot {}
2041 out of range (vtable len {}
2042) on the runtime class behind {}
2043 (method `{}
2044`)",
2045 33usize,
2046 __vt.len(),
2047 <SortedList_SyncSortedList as ::unity::ClassIdentity>::NAME,
2048 "ContainsValue",
2049 )
2050 });
2051 let __inner: extern "C" fn(SortedList_SyncSortedList, crate::system::object::Object, ::unity::OptionalMethod) -> bool =
2052 ::core::mem::transmute(__vi.method_ptr);
2053 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2054 __inner(__receiver, ::core::convert::Into::into(key), __mi)
2055 }
2056 }
2057 }
2058 #[doc = "`CopyTo(::unity::IlInstance, i32)` overload"]
2059 fn copy_to(self, array: impl ::core::convert::Into<::unity::IlInstance>, index: impl ::core::convert::Into<i32>) -> () {
2060 unsafe {
2061 let __receiver =
2062 <SortedList_SyncSortedList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2063 {
2064 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2065 let __vi = *__vt.get(34usize).unwrap_or_else(|| {
2066 panic!(
2067 "unity: virtual slot {}
2068 out of range (vtable len {}
2069) on the runtime class behind {}
2070 (method `{}
2071`)",
2072 34usize,
2073 __vt.len(),
2074 <SortedList_SyncSortedList as ::unity::ClassIdentity>::NAME,
2075 "CopyTo",
2076 )
2077 });
2078 let __inner: extern "C" fn(SortedList_SyncSortedList, ::unity::IlInstance, i32, ::unity::OptionalMethod) -> () =
2079 ::core::mem::transmute(__vi.method_ptr);
2080 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2081 __inner(__receiver, ::core::convert::Into::into(array), ::core::convert::Into::into(index), __mi)
2082 }
2083 }
2084 }
2085 #[doc = "`GetByIndex(i32)` overload"]
2086 fn get_by_index(self, index: impl ::core::convert::Into<i32>) -> crate::system::object::Object {
2087 unsafe {
2088 let __receiver =
2089 <SortedList_SyncSortedList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2090 {
2091 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2092 let __vi = *__vt.get(35usize).unwrap_or_else(|| {
2093 panic!(
2094 "unity: virtual slot {}
2095 out of range (vtable len {}
2096) on the runtime class behind {}
2097 (method `{}
2098`)",
2099 35usize,
2100 __vt.len(),
2101 <SortedList_SyncSortedList as ::unity::ClassIdentity>::NAME,
2102 "GetByIndex",
2103 )
2104 });
2105 let __inner: extern "C" fn(SortedList_SyncSortedList, i32, ::unity::OptionalMethod) -> crate::system::object::Object =
2106 ::core::mem::transmute(__vi.method_ptr);
2107 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2108 __inner(__receiver, ::core::convert::Into::into(index), __mi)
2109 }
2110 }
2111 }
2112 #[doc = "`GetEnumerator()` overload"]
2113 fn get_enumerator(self) -> crate::system::collections::idictionaryenumerator::IDictionaryEnumerator {
2114 unsafe {
2115 let __receiver =
2116 <SortedList_SyncSortedList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2117 {
2118 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2119 let __vi = *__vt.get(36usize).unwrap_or_else(|| {
2120 panic!(
2121 "unity: virtual slot {}
2122 out of range (vtable len {}
2123) on the runtime class behind {}
2124 (method `{}
2125`)",
2126 36usize,
2127 __vt.len(),
2128 <SortedList_SyncSortedList as ::unity::ClassIdentity>::NAME,
2129 "GetEnumerator",
2130 )
2131 });
2132 let __inner: extern "C" fn(
2133 SortedList_SyncSortedList,
2134 ::unity::OptionalMethod,
2135 ) -> crate::system::collections::idictionaryenumerator::IDictionaryEnumerator = ::core::mem::transmute(__vi.method_ptr);
2136 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2137 __inner(__receiver, __mi)
2138 }
2139 }
2140 }
2141 #[doc = "`GetKey(i32)` overload"]
2142 fn get_key(self, index: impl ::core::convert::Into<i32>) -> crate::system::object::Object {
2143 unsafe {
2144 let __receiver =
2145 <SortedList_SyncSortedList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2146 {
2147 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2148 let __vi = *__vt.get(37usize).unwrap_or_else(|| {
2149 panic!(
2150 "unity: virtual slot {}
2151 out of range (vtable len {}
2152) on the runtime class behind {}
2153 (method `{}
2154`)",
2155 37usize,
2156 __vt.len(),
2157 <SortedList_SyncSortedList as ::unity::ClassIdentity>::NAME,
2158 "GetKey",
2159 )
2160 });
2161 let __inner: extern "C" fn(SortedList_SyncSortedList, i32, ::unity::OptionalMethod) -> crate::system::object::Object =
2162 ::core::mem::transmute(__vi.method_ptr);
2163 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2164 __inner(__receiver, ::core::convert::Into::into(index), __mi)
2165 }
2166 }
2167 }
2168 #[doc = "`GetKeyList()` overload"]
2169 fn get_key_list(self) -> crate::system::collections::ilist::IList {
2170 unsafe {
2171 let __receiver =
2172 <SortedList_SyncSortedList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2173 {
2174 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2175 let __vi = *__vt.get(38usize).unwrap_or_else(|| {
2176 panic!(
2177 "unity: virtual slot {}
2178 out of range (vtable len {}
2179) on the runtime class behind {}
2180 (method `{}
2181`)",
2182 38usize,
2183 __vt.len(),
2184 <SortedList_SyncSortedList as ::unity::ClassIdentity>::NAME,
2185 "GetKeyList",
2186 )
2187 });
2188 let __inner: extern "C" fn(SortedList_SyncSortedList, ::unity::OptionalMethod) -> crate::system::collections::ilist::IList =
2189 ::core::mem::transmute(__vi.method_ptr);
2190 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2191 __inner(__receiver, __mi)
2192 }
2193 }
2194 }
2195 #[doc = "`GetValueList()` overload"]
2196 fn get_value_list(self) -> crate::system::collections::ilist::IList {
2197 unsafe {
2198 let __receiver =
2199 <SortedList_SyncSortedList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2200 {
2201 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2202 let __vi = *__vt.get(39usize).unwrap_or_else(|| {
2203 panic!(
2204 "unity: virtual slot {}
2205 out of range (vtable len {}
2206) on the runtime class behind {}
2207 (method `{}
2208`)",
2209 39usize,
2210 __vt.len(),
2211 <SortedList_SyncSortedList as ::unity::ClassIdentity>::NAME,
2212 "GetValueList",
2213 )
2214 });
2215 let __inner: extern "C" fn(SortedList_SyncSortedList, ::unity::OptionalMethod) -> crate::system::collections::ilist::IList =
2216 ::core::mem::transmute(__vi.method_ptr);
2217 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2218 __inner(__receiver, __mi)
2219 }
2220 }
2221 }
2222 #[doc = "`IndexOfKey(crate::system::object::Object)` overload"]
2223 fn index_of_key(self, key: impl ::core::convert::Into<crate::system::object::Object>) -> i32 {
2224 unsafe {
2225 let __receiver =
2226 <SortedList_SyncSortedList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2227 {
2228 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2229 let __vi = *__vt.get(42usize).unwrap_or_else(|| {
2230 panic!(
2231 "unity: virtual slot {}
2232 out of range (vtable len {}
2233) on the runtime class behind {}
2234 (method `{}
2235`)",
2236 42usize,
2237 __vt.len(),
2238 <SortedList_SyncSortedList as ::unity::ClassIdentity>::NAME,
2239 "IndexOfKey",
2240 )
2241 });
2242 let __inner: extern "C" fn(SortedList_SyncSortedList, crate::system::object::Object, ::unity::OptionalMethod) -> i32 =
2243 ::core::mem::transmute(__vi.method_ptr);
2244 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2245 __inner(__receiver, ::core::convert::Into::into(key), __mi)
2246 }
2247 }
2248 }
2249 #[doc = "`IndexOfValue(crate::system::object::Object)` overload"]
2250 fn index_of_value(self, value: impl ::core::convert::Into<crate::system::object::Object>) -> i32 {
2251 unsafe {
2252 let __receiver =
2253 <SortedList_SyncSortedList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2254 {
2255 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2256 let __vi = *__vt.get(43usize).unwrap_or_else(|| {
2257 panic!(
2258 "unity: virtual slot {}
2259 out of range (vtable len {}
2260) on the runtime class behind {}
2261 (method `{}
2262`)",
2263 43usize,
2264 __vt.len(),
2265 <SortedList_SyncSortedList as ::unity::ClassIdentity>::NAME,
2266 "IndexOfValue",
2267 )
2268 });
2269 let __inner: extern "C" fn(SortedList_SyncSortedList, crate::system::object::Object, ::unity::OptionalMethod) -> i32 =
2270 ::core::mem::transmute(__vi.method_ptr);
2271 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2272 __inner(__receiver, ::core::convert::Into::into(value), __mi)
2273 }
2274 }
2275 }
2276 #[doc = "`RemoveAt(i32)` overload"]
2277 fn remove_at(self, index: impl ::core::convert::Into<i32>) -> () {
2278 unsafe {
2279 let __receiver =
2280 <SortedList_SyncSortedList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2281 {
2282 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2283 let __vi = *__vt.get(44usize).unwrap_or_else(|| {
2284 panic!(
2285 "unity: virtual slot {}
2286 out of range (vtable len {}
2287) on the runtime class behind {}
2288 (method `{}
2289`)",
2290 44usize,
2291 __vt.len(),
2292 <SortedList_SyncSortedList as ::unity::ClassIdentity>::NAME,
2293 "RemoveAt",
2294 )
2295 });
2296 let __inner: extern "C" fn(SortedList_SyncSortedList, i32, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
2297 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2298 __inner(__receiver, ::core::convert::Into::into(index), __mi)
2299 }
2300 }
2301 }
2302 #[doc = "`Remove(crate::system::object::Object)` overload"]
2303 fn remove(self, key: impl ::core::convert::Into<crate::system::object::Object>) -> () {
2304 unsafe {
2305 let __receiver =
2306 <SortedList_SyncSortedList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2307 {
2308 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2309 let __vi = *__vt.get(45usize).unwrap_or_else(|| {
2310 panic!(
2311 "unity: virtual slot {}
2312 out of range (vtable len {}
2313) on the runtime class behind {}
2314 (method `{}
2315`)",
2316 45usize,
2317 __vt.len(),
2318 <SortedList_SyncSortedList as ::unity::ClassIdentity>::NAME,
2319 "Remove",
2320 )
2321 });
2322 let __inner: extern "C" fn(SortedList_SyncSortedList, crate::system::object::Object, ::unity::OptionalMethod) -> () =
2323 ::core::mem::transmute(__vi.method_ptr);
2324 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2325 __inner(__receiver, ::core::convert::Into::into(key), __mi)
2326 }
2327 }
2328 }
2329}
2330
2331#[cfg(feature = "system-collections-sortedlist")]
2332impl<__T: ISortedList_SyncSortedList> ISortedList_SyncSortedListMethods for __T {}
2333
2334#[cfg(feature = "system-collections-sortedlist")]
2335impl SortedList_SyncSortedList {
2336 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2337 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
2338 }
2339
2340 pub fn get_count_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2341 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
2342 }
2343
2344 pub fn get_sync_root_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2345 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
2346 }
2347
2348 pub fn get_is_read_only_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2349 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
2350 }
2351
2352 pub fn get_is_fixed_size_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2353 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
2354 }
2355
2356 pub fn get_is_synchronized_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2357 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
2358 }
2359
2360 pub fn get_item_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2361 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
2362 }
2363
2364 pub fn set_item_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2365 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
2366 }
2367
2368 pub fn add_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2369 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[8]
2370 }
2371
2372 pub fn get_capacity_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2373 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[9]
2374 }
2375
2376 pub fn clone_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2377 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[10]
2378 }
2379
2380 pub fn contains_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2381 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[11]
2382 }
2383
2384 pub fn contains_key_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2385 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[12]
2386 }
2387
2388 pub fn contains_value_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2389 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[13]
2390 }
2391
2392 pub fn copy_to_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2393 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[14]
2394 }
2395
2396 pub fn get_by_index_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2397 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[15]
2398 }
2399
2400 pub fn get_enumerator_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2401 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[16]
2402 }
2403
2404 pub fn get_key_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2405 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[17]
2406 }
2407
2408 pub fn get_key_list_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2409 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[18]
2410 }
2411
2412 pub fn get_value_list_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2413 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[19]
2414 }
2415
2416 pub fn index_of_key_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2417 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[20]
2418 }
2419
2420 pub fn index_of_value_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2421 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[21]
2422 }
2423
2424 pub fn remove_at_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2425 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[22]
2426 }
2427
2428 pub fn remove_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2429 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[23]
2430 }
2431}
2432
2433#[cfg(feature = "system-collections-sortedlist")]
2434impl SortedList_SyncSortedList {
2435 #[doc = "Direct (non-virtual) call to `SortedList_SyncSortedList`'s own `get_Count`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2436 pub unsafe fn get_count(this: impl ::core::convert::Into<::unity::IlInstance>) -> i32 {
2437 let __mi = Self::get_count_method_info();
2438 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__mi.method_ptr);
2439 __inner(this.into(), ::core::option::Option::None)
2440 }
2441
2442 #[doc = "Direct (non-virtual) call to `SortedList_SyncSortedList`'s own `get_SyncRoot`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2443 pub unsafe fn get_sync_root(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::system::object::Object {
2444 let __mi = Self::get_sync_root_method_info();
2445 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::system::object::Object =
2446 ::core::mem::transmute(__mi.method_ptr);
2447 __inner(this.into(), ::core::option::Option::None)
2448 }
2449
2450 #[doc = "Direct (non-virtual) call to `SortedList_SyncSortedList`'s own `get_IsReadOnly`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2451 pub unsafe fn get_is_read_only(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
2452 let __mi = Self::get_is_read_only_method_info();
2453 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
2454 __inner(this.into(), ::core::option::Option::None)
2455 }
2456
2457 #[doc = "Direct (non-virtual) call to `SortedList_SyncSortedList`'s own `get_IsFixedSize`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2458 pub unsafe fn get_is_fixed_size(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
2459 let __mi = Self::get_is_fixed_size_method_info();
2460 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
2461 __inner(this.into(), ::core::option::Option::None)
2462 }
2463
2464 #[doc = "Direct (non-virtual) call to `SortedList_SyncSortedList`'s own `get_IsSynchronized`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2465 pub unsafe fn get_is_synchronized(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
2466 let __mi = Self::get_is_synchronized_method_info();
2467 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
2468 __inner(this.into(), ::core::option::Option::None)
2469 }
2470
2471 #[doc = "Direct (non-virtual) call to `SortedList_SyncSortedList`'s own `get_Item`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2472 pub unsafe fn get_item(
2473 this: impl ::core::convert::Into<::unity::IlInstance>,
2474 key: crate::system::object::Object,
2475 ) -> crate::system::object::Object {
2476 let __mi = Self::get_item_method_info();
2477 let __inner: extern "C" fn(::unity::IlInstance, crate::system::object::Object, ::unity::OptionalMethod) -> crate::system::object::Object =
2478 ::core::mem::transmute(__mi.method_ptr);
2479 __inner(this.into(), key, ::core::option::Option::None)
2480 }
2481
2482 #[doc = "Direct (non-virtual) call to `SortedList_SyncSortedList`'s own `set_Item`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2483 pub unsafe fn set_item(
2484 this: impl ::core::convert::Into<::unity::IlInstance>,
2485 key: crate::system::object::Object,
2486 value: crate::system::object::Object,
2487 ) -> () {
2488 let __mi = Self::set_item_method_info();
2489 let __inner: extern "C" fn(::unity::IlInstance, crate::system::object::Object, crate::system::object::Object, ::unity::OptionalMethod) -> () =
2490 ::core::mem::transmute(__mi.method_ptr);
2491 __inner(this.into(), key, value, ::core::option::Option::None)
2492 }
2493
2494 #[doc = "Direct (non-virtual) call to `SortedList_SyncSortedList`'s own `Add`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2495 pub unsafe fn add(
2496 this: impl ::core::convert::Into<::unity::IlInstance>,
2497 key: crate::system::object::Object,
2498 value: crate::system::object::Object,
2499 ) -> () {
2500 let __mi = Self::add_method_info();
2501 let __inner: extern "C" fn(::unity::IlInstance, crate::system::object::Object, crate::system::object::Object, ::unity::OptionalMethod) -> () =
2502 ::core::mem::transmute(__mi.method_ptr);
2503 __inner(this.into(), key, value, ::core::option::Option::None)
2504 }
2505
2506 #[doc = "Direct (non-virtual) call to `SortedList_SyncSortedList`'s own `get_Capacity`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2507 pub unsafe fn get_capacity(this: impl ::core::convert::Into<::unity::IlInstance>) -> i32 {
2508 let __mi = Self::get_capacity_method_info();
2509 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__mi.method_ptr);
2510 __inner(this.into(), ::core::option::Option::None)
2511 }
2512
2513 #[doc = "Direct (non-virtual) call to `SortedList_SyncSortedList`'s own `Clone`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2514 pub unsafe fn clone(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::system::object::Object {
2515 let __mi = Self::clone_method_info();
2516 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::system::object::Object =
2517 ::core::mem::transmute(__mi.method_ptr);
2518 __inner(this.into(), ::core::option::Option::None)
2519 }
2520
2521 #[doc = "Direct (non-virtual) call to `SortedList_SyncSortedList`'s own `Contains`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2522 pub unsafe fn contains(this: impl ::core::convert::Into<::unity::IlInstance>, key: crate::system::object::Object) -> bool {
2523 let __mi = Self::contains_method_info();
2524 let __inner: extern "C" fn(::unity::IlInstance, crate::system::object::Object, ::unity::OptionalMethod) -> bool =
2525 ::core::mem::transmute(__mi.method_ptr);
2526 __inner(this.into(), key, ::core::option::Option::None)
2527 }
2528
2529 #[doc = "Direct (non-virtual) call to `SortedList_SyncSortedList`'s own `ContainsKey`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2530 pub unsafe fn contains_key(this: impl ::core::convert::Into<::unity::IlInstance>, key: crate::system::object::Object) -> bool {
2531 let __mi = Self::contains_key_method_info();
2532 let __inner: extern "C" fn(::unity::IlInstance, crate::system::object::Object, ::unity::OptionalMethod) -> bool =
2533 ::core::mem::transmute(__mi.method_ptr);
2534 __inner(this.into(), key, ::core::option::Option::None)
2535 }
2536
2537 #[doc = "Direct (non-virtual) call to `SortedList_SyncSortedList`'s own `ContainsValue`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2538 pub unsafe fn contains_value(this: impl ::core::convert::Into<::unity::IlInstance>, key: crate::system::object::Object) -> bool {
2539 let __mi = Self::contains_value_method_info();
2540 let __inner: extern "C" fn(::unity::IlInstance, crate::system::object::Object, ::unity::OptionalMethod) -> bool =
2541 ::core::mem::transmute(__mi.method_ptr);
2542 __inner(this.into(), key, ::core::option::Option::None)
2543 }
2544
2545 #[doc = "Direct (non-virtual) call to `SortedList_SyncSortedList`'s own `CopyTo`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2546 pub unsafe fn copy_to(this: impl ::core::convert::Into<::unity::IlInstance>, array: ::unity::IlInstance, index: i32) -> () {
2547 let __mi = Self::copy_to_method_info();
2548 let __inner: extern "C" fn(::unity::IlInstance, ::unity::IlInstance, i32, ::unity::OptionalMethod) -> () =
2549 ::core::mem::transmute(__mi.method_ptr);
2550 __inner(this.into(), array, index, ::core::option::Option::None)
2551 }
2552
2553 #[doc = "Direct (non-virtual) call to `SortedList_SyncSortedList`'s own `GetByIndex`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2554 pub unsafe fn get_by_index(this: impl ::core::convert::Into<::unity::IlInstance>, index: i32) -> crate::system::object::Object {
2555 let __mi = Self::get_by_index_method_info();
2556 let __inner: extern "C" fn(::unity::IlInstance, i32, ::unity::OptionalMethod) -> crate::system::object::Object =
2557 ::core::mem::transmute(__mi.method_ptr);
2558 __inner(this.into(), index, ::core::option::Option::None)
2559 }
2560
2561 #[doc = "Direct (non-virtual) call to `SortedList_SyncSortedList`'s own `GetEnumerator`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2562 pub unsafe fn get_enumerator(
2563 this: impl ::core::convert::Into<::unity::IlInstance>,
2564 ) -> crate::system::collections::idictionaryenumerator::IDictionaryEnumerator {
2565 let __mi = Self::get_enumerator_method_info();
2566 let __inner: extern "C" fn(
2567 ::unity::IlInstance,
2568 ::unity::OptionalMethod,
2569 ) -> crate::system::collections::idictionaryenumerator::IDictionaryEnumerator = ::core::mem::transmute(__mi.method_ptr);
2570 __inner(this.into(), ::core::option::Option::None)
2571 }
2572
2573 #[doc = "Direct (non-virtual) call to `SortedList_SyncSortedList`'s own `GetKey`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2574 pub unsafe fn get_key(this: impl ::core::convert::Into<::unity::IlInstance>, index: i32) -> crate::system::object::Object {
2575 let __mi = Self::get_key_method_info();
2576 let __inner: extern "C" fn(::unity::IlInstance, i32, ::unity::OptionalMethod) -> crate::system::object::Object =
2577 ::core::mem::transmute(__mi.method_ptr);
2578 __inner(this.into(), index, ::core::option::Option::None)
2579 }
2580
2581 #[doc = "Direct (non-virtual) call to `SortedList_SyncSortedList`'s own `GetKeyList`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2582 pub unsafe fn get_key_list(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::system::collections::ilist::IList {
2583 let __mi = Self::get_key_list_method_info();
2584 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::system::collections::ilist::IList =
2585 ::core::mem::transmute(__mi.method_ptr);
2586 __inner(this.into(), ::core::option::Option::None)
2587 }
2588
2589 #[doc = "Direct (non-virtual) call to `SortedList_SyncSortedList`'s own `GetValueList`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2590 pub unsafe fn get_value_list(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::system::collections::ilist::IList {
2591 let __mi = Self::get_value_list_method_info();
2592 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::system::collections::ilist::IList =
2593 ::core::mem::transmute(__mi.method_ptr);
2594 __inner(this.into(), ::core::option::Option::None)
2595 }
2596
2597 #[doc = "Direct (non-virtual) call to `SortedList_SyncSortedList`'s own `IndexOfKey`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2598 pub unsafe fn index_of_key(this: impl ::core::convert::Into<::unity::IlInstance>, key: crate::system::object::Object) -> i32 {
2599 let __mi = Self::index_of_key_method_info();
2600 let __inner: extern "C" fn(::unity::IlInstance, crate::system::object::Object, ::unity::OptionalMethod) -> i32 =
2601 ::core::mem::transmute(__mi.method_ptr);
2602 __inner(this.into(), key, ::core::option::Option::None)
2603 }
2604
2605 #[doc = "Direct (non-virtual) call to `SortedList_SyncSortedList`'s own `IndexOfValue`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2606 pub unsafe fn index_of_value(this: impl ::core::convert::Into<::unity::IlInstance>, value: crate::system::object::Object) -> i32 {
2607 let __mi = Self::index_of_value_method_info();
2608 let __inner: extern "C" fn(::unity::IlInstance, crate::system::object::Object, ::unity::OptionalMethod) -> i32 =
2609 ::core::mem::transmute(__mi.method_ptr);
2610 __inner(this.into(), value, ::core::option::Option::None)
2611 }
2612
2613 #[doc = "Direct (non-virtual) call to `SortedList_SyncSortedList`'s own `RemoveAt`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2614 pub unsafe fn remove_at(this: impl ::core::convert::Into<::unity::IlInstance>, index: i32) -> () {
2615 let __mi = Self::remove_at_method_info();
2616 let __inner: extern "C" fn(::unity::IlInstance, i32, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
2617 __inner(this.into(), index, ::core::option::Option::None)
2618 }
2619
2620 #[doc = "Direct (non-virtual) call to `SortedList_SyncSortedList`'s own `Remove`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2621 pub unsafe fn remove(this: impl ::core::convert::Into<::unity::IlInstance>, key: crate::system::object::Object) -> () {
2622 let __mi = Self::remove_method_info();
2623 let __inner: extern "C" fn(::unity::IlInstance, crate::system::object::Object, ::unity::OptionalMethod) -> () =
2624 ::core::mem::transmute(__mi.method_ptr);
2625 __inner(this.into(), key, ::core::option::Option::None)
2626 }
2627}
2628
2629#[cfg(feature = "system-collections-sortedlist")]
2630impl SortedList_SyncSortedList {
2631 #[doc = "`.ctor(crate::system::collections::sortedlist::SortedList)` — overload selector"]
2632 pub fn new(list: crate::system::collections::sortedlist::SortedList) -> Self {
2633 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
2634 panic!(
2635 "{}
2636::{}
2637 failed to instantiate",
2638 ::core::stringify!(SortedList_SyncSortedList),
2639 ::core::stringify!(new),
2640 )
2641 });
2642 <Self as ISortedList_SyncSortedListMethods>::ctor(this, list);
2643 this
2644 }
2645}
2646
2647#[cfg(feature = "system-collections-sortedlist")]
2648pub trait ISortedList_KeyListMethods: ISortedList_KeyList {
2649 #[doc = "`.ctor(crate::system::collections::sortedlist::SortedList)` overload"]
2650 fn ctor(self, sorted_list: impl ::core::convert::Into<crate::system::collections::sortedlist::SortedList>) -> () {
2651 unsafe {
2652 let __receiver = <SortedList_KeyList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2653 ::unity::il2cpp_call!((::unity::module_base()+0x3c558f0usize)as*mut u8,();
2654(SortedList_KeyList)__receiver,(crate::system::collections::sortedlist::SortedList)::core::convert::Into::into(sorted_list))
2655 }
2656 }
2657 #[doc = "`get_Count()` overload"]
2658 fn get_count(self) -> i32 {
2659 unsafe {
2660 let __receiver = <SortedList_KeyList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2661 {
2662 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2663 let __vi = *__vt.get(19usize).unwrap_or_else(|| {
2664 panic!(
2665 "unity: virtual slot {}
2666 out of range (vtable len {}
2667) on the runtime class behind {}
2668 (method `{}
2669`)",
2670 19usize,
2671 __vt.len(),
2672 <SortedList_KeyList as ::unity::ClassIdentity>::NAME,
2673 "get_Count",
2674 )
2675 });
2676 let __inner: extern "C" fn(SortedList_KeyList, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__vi.method_ptr);
2677 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2678 __inner(__receiver, __mi)
2679 }
2680 }
2681 }
2682 #[doc = "`get_IsReadOnly()` overload"]
2683 fn get_is_read_only(self) -> bool {
2684 unsafe {
2685 let __receiver = <SortedList_KeyList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2686 {
2687 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2688 let __vi = *__vt.get(20usize).unwrap_or_else(|| {
2689 panic!(
2690 "unity: virtual slot {}
2691 out of range (vtable len {}
2692) on the runtime class behind {}
2693 (method `{}
2694`)",
2695 20usize,
2696 __vt.len(),
2697 <SortedList_KeyList as ::unity::ClassIdentity>::NAME,
2698 "get_IsReadOnly",
2699 )
2700 });
2701 let __inner: extern "C" fn(SortedList_KeyList, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
2702 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2703 __inner(__receiver, __mi)
2704 }
2705 }
2706 }
2707 #[doc = "`get_IsSynchronized()` overload"]
2708 fn get_is_synchronized(self) -> bool {
2709 unsafe {
2710 let __receiver = <SortedList_KeyList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2711 {
2712 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2713 let __vi = *__vt.get(21usize).unwrap_or_else(|| {
2714 panic!(
2715 "unity: virtual slot {}
2716 out of range (vtable len {}
2717) on the runtime class behind {}
2718 (method `{}
2719`)",
2720 21usize,
2721 __vt.len(),
2722 <SortedList_KeyList as ::unity::ClassIdentity>::NAME,
2723 "get_IsSynchronized",
2724 )
2725 });
2726 let __inner: extern "C" fn(SortedList_KeyList, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
2727 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2728 __inner(__receiver, __mi)
2729 }
2730 }
2731 }
2732 #[doc = "`get_SyncRoot()` overload"]
2733 fn get_sync_root(self) -> crate::system::object::Object {
2734 unsafe {
2735 let __receiver = <SortedList_KeyList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2736 {
2737 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2738 let __vi = *__vt.get(22usize).unwrap_or_else(|| {
2739 panic!(
2740 "unity: virtual slot {}
2741 out of range (vtable len {}
2742) on the runtime class behind {}
2743 (method `{}
2744`)",
2745 22usize,
2746 __vt.len(),
2747 <SortedList_KeyList as ::unity::ClassIdentity>::NAME,
2748 "get_SyncRoot",
2749 )
2750 });
2751 let __inner: extern "C" fn(SortedList_KeyList, ::unity::OptionalMethod) -> crate::system::object::Object =
2752 ::core::mem::transmute(__vi.method_ptr);
2753 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2754 __inner(__receiver, __mi)
2755 }
2756 }
2757 }
2758 #[doc = "`Add(crate::system::object::Object)` overload"]
2759 fn add(self, key: impl ::core::convert::Into<crate::system::object::Object>) -> i32 {
2760 unsafe {
2761 let __receiver = <SortedList_KeyList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2762 {
2763 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2764 let __vi = *__vt.get(23usize).unwrap_or_else(|| {
2765 panic!(
2766 "unity: virtual slot {}
2767 out of range (vtable len {}
2768) on the runtime class behind {}
2769 (method `{}
2770`)",
2771 23usize,
2772 __vt.len(),
2773 <SortedList_KeyList as ::unity::ClassIdentity>::NAME,
2774 "Add",
2775 )
2776 });
2777 let __inner: extern "C" fn(SortedList_KeyList, crate::system::object::Object, ::unity::OptionalMethod) -> i32 =
2778 ::core::mem::transmute(__vi.method_ptr);
2779 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2780 __inner(__receiver, ::core::convert::Into::into(key), __mi)
2781 }
2782 }
2783 }
2784 #[doc = "`Clear()` overload"]
2785 fn clear(self) -> () {
2786 unsafe {
2787 let __receiver = <SortedList_KeyList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2788 {
2789 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2790 let __vi = *__vt.get(24usize).unwrap_or_else(|| {
2791 panic!(
2792 "unity: virtual slot {}
2793 out of range (vtable len {}
2794) on the runtime class behind {}
2795 (method `{}
2796`)",
2797 24usize,
2798 __vt.len(),
2799 <SortedList_KeyList as ::unity::ClassIdentity>::NAME,
2800 "Clear",
2801 )
2802 });
2803 let __inner: extern "C" fn(SortedList_KeyList, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
2804 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2805 __inner(__receiver, __mi)
2806 }
2807 }
2808 }
2809 #[doc = "`Contains(crate::system::object::Object)` overload"]
2810 fn contains(self, key: impl ::core::convert::Into<crate::system::object::Object>) -> bool {
2811 unsafe {
2812 let __receiver = <SortedList_KeyList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2813 {
2814 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2815 let __vi = *__vt.get(25usize).unwrap_or_else(|| {
2816 panic!(
2817 "unity: virtual slot {}
2818 out of range (vtable len {}
2819) on the runtime class behind {}
2820 (method `{}
2821`)",
2822 25usize,
2823 __vt.len(),
2824 <SortedList_KeyList as ::unity::ClassIdentity>::NAME,
2825 "Contains",
2826 )
2827 });
2828 let __inner: extern "C" fn(SortedList_KeyList, crate::system::object::Object, ::unity::OptionalMethod) -> bool =
2829 ::core::mem::transmute(__vi.method_ptr);
2830 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2831 __inner(__receiver, ::core::convert::Into::into(key), __mi)
2832 }
2833 }
2834 }
2835 #[doc = "`CopyTo(::unity::IlInstance, i32)` overload"]
2836 fn copy_to(self, array: impl ::core::convert::Into<::unity::IlInstance>, array_index: impl ::core::convert::Into<i32>) -> () {
2837 unsafe {
2838 let __receiver = <SortedList_KeyList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2839 {
2840 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2841 let __vi = *__vt.get(26usize).unwrap_or_else(|| {
2842 panic!(
2843 "unity: virtual slot {}
2844 out of range (vtable len {}
2845) on the runtime class behind {}
2846 (method `{}
2847`)",
2848 26usize,
2849 __vt.len(),
2850 <SortedList_KeyList as ::unity::ClassIdentity>::NAME,
2851 "CopyTo",
2852 )
2853 });
2854 let __inner: extern "C" fn(SortedList_KeyList, ::unity::IlInstance, i32, ::unity::OptionalMethod) -> () =
2855 ::core::mem::transmute(__vi.method_ptr);
2856 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2857 __inner(
2858 __receiver,
2859 ::core::convert::Into::into(array),
2860 ::core::convert::Into::into(array_index),
2861 __mi,
2862 )
2863 }
2864 }
2865 }
2866 #[doc = "`Insert(i32, crate::system::object::Object)` overload"]
2867 fn insert(self, index: impl ::core::convert::Into<i32>, value: impl ::core::convert::Into<crate::system::object::Object>) -> () {
2868 unsafe {
2869 let __receiver = <SortedList_KeyList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2870 {
2871 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2872 let __vi = *__vt.get(27usize).unwrap_or_else(|| {
2873 panic!(
2874 "unity: virtual slot {}
2875 out of range (vtable len {}
2876) on the runtime class behind {}
2877 (method `{}
2878`)",
2879 27usize,
2880 __vt.len(),
2881 <SortedList_KeyList as ::unity::ClassIdentity>::NAME,
2882 "Insert",
2883 )
2884 });
2885 let __inner: extern "C" fn(SortedList_KeyList, i32, crate::system::object::Object, ::unity::OptionalMethod) -> () =
2886 ::core::mem::transmute(__vi.method_ptr);
2887 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2888 __inner(__receiver, ::core::convert::Into::into(index), ::core::convert::Into::into(value), __mi)
2889 }
2890 }
2891 }
2892 #[doc = "`get_Item(i32)` overload"]
2893 fn get_item(self, index: impl ::core::convert::Into<i32>) -> crate::system::object::Object {
2894 unsafe {
2895 let __receiver = <SortedList_KeyList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2896 {
2897 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2898 let __vi = *__vt.get(28usize).unwrap_or_else(|| {
2899 panic!(
2900 "unity: virtual slot {}
2901 out of range (vtable len {}
2902) on the runtime class behind {}
2903 (method `{}
2904`)",
2905 28usize,
2906 __vt.len(),
2907 <SortedList_KeyList as ::unity::ClassIdentity>::NAME,
2908 "get_Item",
2909 )
2910 });
2911 let __inner: extern "C" fn(SortedList_KeyList, i32, ::unity::OptionalMethod) -> crate::system::object::Object =
2912 ::core::mem::transmute(__vi.method_ptr);
2913 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2914 __inner(__receiver, ::core::convert::Into::into(index), __mi)
2915 }
2916 }
2917 }
2918 #[doc = "`set_Item(i32, crate::system::object::Object)` overload"]
2919 fn set_item(self, index: impl ::core::convert::Into<i32>, value: impl ::core::convert::Into<crate::system::object::Object>) -> () {
2920 unsafe {
2921 let __receiver = <SortedList_KeyList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2922 {
2923 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2924 let __vi = *__vt.get(29usize).unwrap_or_else(|| {
2925 panic!(
2926 "unity: virtual slot {}
2927 out of range (vtable len {}
2928) on the runtime class behind {}
2929 (method `{}
2930`)",
2931 29usize,
2932 __vt.len(),
2933 <SortedList_KeyList as ::unity::ClassIdentity>::NAME,
2934 "set_Item",
2935 )
2936 });
2937 let __inner: extern "C" fn(SortedList_KeyList, i32, crate::system::object::Object, ::unity::OptionalMethod) -> () =
2938 ::core::mem::transmute(__vi.method_ptr);
2939 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2940 __inner(__receiver, ::core::convert::Into::into(index), ::core::convert::Into::into(value), __mi)
2941 }
2942 }
2943 }
2944 #[doc = "`GetEnumerator()` overload"]
2945 fn get_enumerator(self) -> crate::system::collections::ienumerator::IEnumerator {
2946 unsafe {
2947 let __receiver = <SortedList_KeyList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2948 {
2949 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2950 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
2951 panic!(
2952 "unity: virtual slot {}
2953 out of range (vtable len {}
2954) on the runtime class behind {}
2955 (method `{}
2956`)",
2957 30usize,
2958 __vt.len(),
2959 <SortedList_KeyList as ::unity::ClassIdentity>::NAME,
2960 "GetEnumerator",
2961 )
2962 });
2963 let __inner: extern "C" fn(SortedList_KeyList, ::unity::OptionalMethod) -> crate::system::collections::ienumerator::IEnumerator =
2964 ::core::mem::transmute(__vi.method_ptr);
2965 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2966 __inner(__receiver, __mi)
2967 }
2968 }
2969 }
2970 #[doc = "`IndexOf(crate::system::object::Object)` overload"]
2971 fn index_of(self, key: impl ::core::convert::Into<crate::system::object::Object>) -> i32 {
2972 unsafe {
2973 let __receiver = <SortedList_KeyList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2974 {
2975 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2976 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
2977 panic!(
2978 "unity: virtual slot {}
2979 out of range (vtable len {}
2980) on the runtime class behind {}
2981 (method `{}
2982`)",
2983 31usize,
2984 __vt.len(),
2985 <SortedList_KeyList as ::unity::ClassIdentity>::NAME,
2986 "IndexOf",
2987 )
2988 });
2989 let __inner: extern "C" fn(SortedList_KeyList, crate::system::object::Object, ::unity::OptionalMethod) -> i32 =
2990 ::core::mem::transmute(__vi.method_ptr);
2991 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2992 __inner(__receiver, ::core::convert::Into::into(key), __mi)
2993 }
2994 }
2995 }
2996 #[doc = "`Remove(crate::system::object::Object)` overload"]
2997 fn remove(self, key: impl ::core::convert::Into<crate::system::object::Object>) -> () {
2998 unsafe {
2999 let __receiver = <SortedList_KeyList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3000 {
3001 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3002 let __vi = *__vt.get(32usize).unwrap_or_else(|| {
3003 panic!(
3004 "unity: virtual slot {}
3005 out of range (vtable len {}
3006) on the runtime class behind {}
3007 (method `{}
3008`)",
3009 32usize,
3010 __vt.len(),
3011 <SortedList_KeyList as ::unity::ClassIdentity>::NAME,
3012 "Remove",
3013 )
3014 });
3015 let __inner: extern "C" fn(SortedList_KeyList, crate::system::object::Object, ::unity::OptionalMethod) -> () =
3016 ::core::mem::transmute(__vi.method_ptr);
3017 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3018 __inner(__receiver, ::core::convert::Into::into(key), __mi)
3019 }
3020 }
3021 }
3022 #[doc = "`RemoveAt(i32)` overload"]
3023 fn remove_at(self, index: impl ::core::convert::Into<i32>) -> () {
3024 unsafe {
3025 let __receiver = <SortedList_KeyList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3026 {
3027 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3028 let __vi = *__vt.get(33usize).unwrap_or_else(|| {
3029 panic!(
3030 "unity: virtual slot {}
3031 out of range (vtable len {}
3032) on the runtime class behind {}
3033 (method `{}
3034`)",
3035 33usize,
3036 __vt.len(),
3037 <SortedList_KeyList as ::unity::ClassIdentity>::NAME,
3038 "RemoveAt",
3039 )
3040 });
3041 let __inner: extern "C" fn(SortedList_KeyList, i32, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
3042 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3043 __inner(__receiver, ::core::convert::Into::into(index), __mi)
3044 }
3045 }
3046 }
3047}
3048
3049#[cfg(feature = "system-collections-sortedlist")]
3050impl<__T: ISortedList_KeyList> ISortedList_KeyListMethods for __T {}
3051
3052#[cfg(feature = "system-collections-sortedlist")]
3053impl SortedList_KeyList {
3054 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3055 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
3056 }
3057
3058 pub fn get_count_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3059 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
3060 }
3061
3062 pub fn get_is_read_only_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3063 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
3064 }
3065
3066 pub fn get_is_synchronized_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3067 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
3068 }
3069
3070 pub fn get_sync_root_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3071 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
3072 }
3073
3074 pub fn add_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3075 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
3076 }
3077
3078 pub fn clear_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3079 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
3080 }
3081
3082 pub fn contains_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3083 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
3084 }
3085
3086 pub fn copy_to_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3087 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[8]
3088 }
3089
3090 pub fn insert_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3091 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[9]
3092 }
3093
3094 pub fn get_item_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3095 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[10]
3096 }
3097
3098 pub fn set_item_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3099 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[11]
3100 }
3101
3102 pub fn get_enumerator_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3103 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[12]
3104 }
3105
3106 pub fn index_of_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3107 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[13]
3108 }
3109
3110 pub fn remove_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3111 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[14]
3112 }
3113
3114 pub fn remove_at_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3115 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[15]
3116 }
3117}
3118
3119#[cfg(feature = "system-collections-sortedlist")]
3120impl SortedList_KeyList {
3121 #[doc = "Direct (non-virtual) call to `SortedList_KeyList`'s own `get_Count`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3122 pub unsafe fn get_count(this: impl ::core::convert::Into<::unity::IlInstance>) -> i32 {
3123 let __mi = Self::get_count_method_info();
3124 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__mi.method_ptr);
3125 __inner(this.into(), ::core::option::Option::None)
3126 }
3127
3128 #[doc = "Direct (non-virtual) call to `SortedList_KeyList`'s own `get_IsReadOnly`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3129 pub unsafe fn get_is_read_only(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
3130 let __mi = Self::get_is_read_only_method_info();
3131 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
3132 __inner(this.into(), ::core::option::Option::None)
3133 }
3134
3135 #[doc = "Direct (non-virtual) call to `SortedList_KeyList`'s own `get_IsSynchronized`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3136 pub unsafe fn get_is_synchronized(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
3137 let __mi = Self::get_is_synchronized_method_info();
3138 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
3139 __inner(this.into(), ::core::option::Option::None)
3140 }
3141
3142 #[doc = "Direct (non-virtual) call to `SortedList_KeyList`'s own `get_SyncRoot`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3143 pub unsafe fn get_sync_root(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::system::object::Object {
3144 let __mi = Self::get_sync_root_method_info();
3145 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::system::object::Object =
3146 ::core::mem::transmute(__mi.method_ptr);
3147 __inner(this.into(), ::core::option::Option::None)
3148 }
3149
3150 #[doc = "Direct (non-virtual) call to `SortedList_KeyList`'s own `Add`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3151 pub unsafe fn add(this: impl ::core::convert::Into<::unity::IlInstance>, key: crate::system::object::Object) -> i32 {
3152 let __mi = Self::add_method_info();
3153 let __inner: extern "C" fn(::unity::IlInstance, crate::system::object::Object, ::unity::OptionalMethod) -> i32 =
3154 ::core::mem::transmute(__mi.method_ptr);
3155 __inner(this.into(), key, ::core::option::Option::None)
3156 }
3157
3158 #[doc = "Direct (non-virtual) call to `SortedList_KeyList`'s own `Clear`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3159 pub unsafe fn clear(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
3160 let __mi = Self::clear_method_info();
3161 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
3162 __inner(this.into(), ::core::option::Option::None)
3163 }
3164
3165 #[doc = "Direct (non-virtual) call to `SortedList_KeyList`'s own `Contains`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3166 pub unsafe fn contains(this: impl ::core::convert::Into<::unity::IlInstance>, key: crate::system::object::Object) -> bool {
3167 let __mi = Self::contains_method_info();
3168 let __inner: extern "C" fn(::unity::IlInstance, crate::system::object::Object, ::unity::OptionalMethod) -> bool =
3169 ::core::mem::transmute(__mi.method_ptr);
3170 __inner(this.into(), key, ::core::option::Option::None)
3171 }
3172
3173 #[doc = "Direct (non-virtual) call to `SortedList_KeyList`'s own `CopyTo`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3174 pub unsafe fn copy_to(this: impl ::core::convert::Into<::unity::IlInstance>, array: ::unity::IlInstance, array_index: i32) -> () {
3175 let __mi = Self::copy_to_method_info();
3176 let __inner: extern "C" fn(::unity::IlInstance, ::unity::IlInstance, i32, ::unity::OptionalMethod) -> () =
3177 ::core::mem::transmute(__mi.method_ptr);
3178 __inner(this.into(), array, array_index, ::core::option::Option::None)
3179 }
3180
3181 #[doc = "Direct (non-virtual) call to `SortedList_KeyList`'s own `Insert`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3182 pub unsafe fn insert(this: impl ::core::convert::Into<::unity::IlInstance>, index: i32, value: crate::system::object::Object) -> () {
3183 let __mi = Self::insert_method_info();
3184 let __inner: extern "C" fn(::unity::IlInstance, i32, crate::system::object::Object, ::unity::OptionalMethod) -> () =
3185 ::core::mem::transmute(__mi.method_ptr);
3186 __inner(this.into(), index, value, ::core::option::Option::None)
3187 }
3188
3189 #[doc = "Direct (non-virtual) call to `SortedList_KeyList`'s own `get_Item`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3190 pub unsafe fn get_item(this: impl ::core::convert::Into<::unity::IlInstance>, index: i32) -> crate::system::object::Object {
3191 let __mi = Self::get_item_method_info();
3192 let __inner: extern "C" fn(::unity::IlInstance, i32, ::unity::OptionalMethod) -> crate::system::object::Object =
3193 ::core::mem::transmute(__mi.method_ptr);
3194 __inner(this.into(), index, ::core::option::Option::None)
3195 }
3196
3197 #[doc = "Direct (non-virtual) call to `SortedList_KeyList`'s own `set_Item`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3198 pub unsafe fn set_item(this: impl ::core::convert::Into<::unity::IlInstance>, index: i32, value: crate::system::object::Object) -> () {
3199 let __mi = Self::set_item_method_info();
3200 let __inner: extern "C" fn(::unity::IlInstance, i32, crate::system::object::Object, ::unity::OptionalMethod) -> () =
3201 ::core::mem::transmute(__mi.method_ptr);
3202 __inner(this.into(), index, value, ::core::option::Option::None)
3203 }
3204
3205 #[doc = "Direct (non-virtual) call to `SortedList_KeyList`'s own `GetEnumerator`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3206 pub unsafe fn get_enumerator(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::system::collections::ienumerator::IEnumerator {
3207 let __mi = Self::get_enumerator_method_info();
3208 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::system::collections::ienumerator::IEnumerator =
3209 ::core::mem::transmute(__mi.method_ptr);
3210 __inner(this.into(), ::core::option::Option::None)
3211 }
3212
3213 #[doc = "Direct (non-virtual) call to `SortedList_KeyList`'s own `IndexOf`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3214 pub unsafe fn index_of(this: impl ::core::convert::Into<::unity::IlInstance>, key: crate::system::object::Object) -> i32 {
3215 let __mi = Self::index_of_method_info();
3216 let __inner: extern "C" fn(::unity::IlInstance, crate::system::object::Object, ::unity::OptionalMethod) -> i32 =
3217 ::core::mem::transmute(__mi.method_ptr);
3218 __inner(this.into(), key, ::core::option::Option::None)
3219 }
3220
3221 #[doc = "Direct (non-virtual) call to `SortedList_KeyList`'s own `Remove`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3222 pub unsafe fn remove(this: impl ::core::convert::Into<::unity::IlInstance>, key: crate::system::object::Object) -> () {
3223 let __mi = Self::remove_method_info();
3224 let __inner: extern "C" fn(::unity::IlInstance, crate::system::object::Object, ::unity::OptionalMethod) -> () =
3225 ::core::mem::transmute(__mi.method_ptr);
3226 __inner(this.into(), key, ::core::option::Option::None)
3227 }
3228
3229 #[doc = "Direct (non-virtual) call to `SortedList_KeyList`'s own `RemoveAt`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3230 pub unsafe fn remove_at(this: impl ::core::convert::Into<::unity::IlInstance>, index: i32) -> () {
3231 let __mi = Self::remove_at_method_info();
3232 let __inner: extern "C" fn(::unity::IlInstance, i32, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
3233 __inner(this.into(), index, ::core::option::Option::None)
3234 }
3235}
3236
3237#[cfg(feature = "system-collections-sortedlist")]
3238impl SortedList_KeyList {
3239 #[doc = "`.ctor(crate::system::collections::sortedlist::SortedList)` — overload selector"]
3240 pub fn new(sorted_list: crate::system::collections::sortedlist::SortedList) -> Self {
3241 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
3242 panic!(
3243 "{}
3244::{}
3245 failed to instantiate",
3246 ::core::stringify!(SortedList_KeyList),
3247 ::core::stringify!(new),
3248 )
3249 });
3250 <Self as ISortedList_KeyListMethods>::ctor(this, sorted_list);
3251 this
3252 }
3253}
3254
3255#[cfg(feature = "system-collections-sortedlist")]
3256pub trait ISortedList_ValueListMethods: ISortedList_ValueList {
3257 #[doc = "`.ctor(crate::system::collections::sortedlist::SortedList)` overload"]
3258 fn ctor(self, sorted_list: impl ::core::convert::Into<crate::system::collections::sortedlist::SortedList>) -> () {
3259 unsafe {
3260 let __receiver = <SortedList_ValueList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3261 ::unity::il2cpp_call!((::unity::module_base()+0x3c57720usize)as*mut u8,();
3262(SortedList_ValueList)__receiver,(crate::system::collections::sortedlist::SortedList)::core::convert::Into::into(sorted_list))
3263 }
3264 }
3265 #[doc = "`get_Count()` overload"]
3266 fn get_count(self) -> i32 {
3267 unsafe {
3268 let __receiver = <SortedList_ValueList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3269 {
3270 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3271 let __vi = *__vt.get(19usize).unwrap_or_else(|| {
3272 panic!(
3273 "unity: virtual slot {}
3274 out of range (vtable len {}
3275) on the runtime class behind {}
3276 (method `{}
3277`)",
3278 19usize,
3279 __vt.len(),
3280 <SortedList_ValueList as ::unity::ClassIdentity>::NAME,
3281 "get_Count",
3282 )
3283 });
3284 let __inner: extern "C" fn(SortedList_ValueList, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__vi.method_ptr);
3285 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3286 __inner(__receiver, __mi)
3287 }
3288 }
3289 }
3290 #[doc = "`get_IsReadOnly()` overload"]
3291 fn get_is_read_only(self) -> bool {
3292 unsafe {
3293 let __receiver = <SortedList_ValueList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3294 {
3295 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3296 let __vi = *__vt.get(20usize).unwrap_or_else(|| {
3297 panic!(
3298 "unity: virtual slot {}
3299 out of range (vtable len {}
3300) on the runtime class behind {}
3301 (method `{}
3302`)",
3303 20usize,
3304 __vt.len(),
3305 <SortedList_ValueList as ::unity::ClassIdentity>::NAME,
3306 "get_IsReadOnly",
3307 )
3308 });
3309 let __inner: extern "C" fn(SortedList_ValueList, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
3310 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3311 __inner(__receiver, __mi)
3312 }
3313 }
3314 }
3315 #[doc = "`get_IsSynchronized()` overload"]
3316 fn get_is_synchronized(self) -> bool {
3317 unsafe {
3318 let __receiver = <SortedList_ValueList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3319 {
3320 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3321 let __vi = *__vt.get(21usize).unwrap_or_else(|| {
3322 panic!(
3323 "unity: virtual slot {}
3324 out of range (vtable len {}
3325) on the runtime class behind {}
3326 (method `{}
3327`)",
3328 21usize,
3329 __vt.len(),
3330 <SortedList_ValueList as ::unity::ClassIdentity>::NAME,
3331 "get_IsSynchronized",
3332 )
3333 });
3334 let __inner: extern "C" fn(SortedList_ValueList, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
3335 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3336 __inner(__receiver, __mi)
3337 }
3338 }
3339 }
3340 #[doc = "`get_SyncRoot()` overload"]
3341 fn get_sync_root(self) -> crate::system::object::Object {
3342 unsafe {
3343 let __receiver = <SortedList_ValueList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3344 {
3345 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3346 let __vi = *__vt.get(22usize).unwrap_or_else(|| {
3347 panic!(
3348 "unity: virtual slot {}
3349 out of range (vtable len {}
3350) on the runtime class behind {}
3351 (method `{}
3352`)",
3353 22usize,
3354 __vt.len(),
3355 <SortedList_ValueList as ::unity::ClassIdentity>::NAME,
3356 "get_SyncRoot",
3357 )
3358 });
3359 let __inner: extern "C" fn(SortedList_ValueList, ::unity::OptionalMethod) -> crate::system::object::Object =
3360 ::core::mem::transmute(__vi.method_ptr);
3361 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3362 __inner(__receiver, __mi)
3363 }
3364 }
3365 }
3366 #[doc = "`Add(crate::system::object::Object)` overload"]
3367 fn add(self, key: impl ::core::convert::Into<crate::system::object::Object>) -> i32 {
3368 unsafe {
3369 let __receiver = <SortedList_ValueList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3370 {
3371 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3372 let __vi = *__vt.get(23usize).unwrap_or_else(|| {
3373 panic!(
3374 "unity: virtual slot {}
3375 out of range (vtable len {}
3376) on the runtime class behind {}
3377 (method `{}
3378`)",
3379 23usize,
3380 __vt.len(),
3381 <SortedList_ValueList as ::unity::ClassIdentity>::NAME,
3382 "Add",
3383 )
3384 });
3385 let __inner: extern "C" fn(SortedList_ValueList, crate::system::object::Object, ::unity::OptionalMethod) -> i32 =
3386 ::core::mem::transmute(__vi.method_ptr);
3387 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3388 __inner(__receiver, ::core::convert::Into::into(key), __mi)
3389 }
3390 }
3391 }
3392 #[doc = "`Clear()` overload"]
3393 fn clear(self) -> () {
3394 unsafe {
3395 let __receiver = <SortedList_ValueList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3396 {
3397 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3398 let __vi = *__vt.get(24usize).unwrap_or_else(|| {
3399 panic!(
3400 "unity: virtual slot {}
3401 out of range (vtable len {}
3402) on the runtime class behind {}
3403 (method `{}
3404`)",
3405 24usize,
3406 __vt.len(),
3407 <SortedList_ValueList as ::unity::ClassIdentity>::NAME,
3408 "Clear",
3409 )
3410 });
3411 let __inner: extern "C" fn(SortedList_ValueList, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
3412 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3413 __inner(__receiver, __mi)
3414 }
3415 }
3416 }
3417 #[doc = "`Contains(crate::system::object::Object)` overload"]
3418 fn contains(self, value: impl ::core::convert::Into<crate::system::object::Object>) -> bool {
3419 unsafe {
3420 let __receiver = <SortedList_ValueList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3421 {
3422 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3423 let __vi = *__vt.get(25usize).unwrap_or_else(|| {
3424 panic!(
3425 "unity: virtual slot {}
3426 out of range (vtable len {}
3427) on the runtime class behind {}
3428 (method `{}
3429`)",
3430 25usize,
3431 __vt.len(),
3432 <SortedList_ValueList as ::unity::ClassIdentity>::NAME,
3433 "Contains",
3434 )
3435 });
3436 let __inner: extern "C" fn(SortedList_ValueList, crate::system::object::Object, ::unity::OptionalMethod) -> bool =
3437 ::core::mem::transmute(__vi.method_ptr);
3438 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3439 __inner(__receiver, ::core::convert::Into::into(value), __mi)
3440 }
3441 }
3442 }
3443 #[doc = "`CopyTo(::unity::IlInstance, i32)` overload"]
3444 fn copy_to(self, array: impl ::core::convert::Into<::unity::IlInstance>, array_index: impl ::core::convert::Into<i32>) -> () {
3445 unsafe {
3446 let __receiver = <SortedList_ValueList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3447 {
3448 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3449 let __vi = *__vt.get(26usize).unwrap_or_else(|| {
3450 panic!(
3451 "unity: virtual slot {}
3452 out of range (vtable len {}
3453) on the runtime class behind {}
3454 (method `{}
3455`)",
3456 26usize,
3457 __vt.len(),
3458 <SortedList_ValueList as ::unity::ClassIdentity>::NAME,
3459 "CopyTo",
3460 )
3461 });
3462 let __inner: extern "C" fn(SortedList_ValueList, ::unity::IlInstance, i32, ::unity::OptionalMethod) -> () =
3463 ::core::mem::transmute(__vi.method_ptr);
3464 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3465 __inner(
3466 __receiver,
3467 ::core::convert::Into::into(array),
3468 ::core::convert::Into::into(array_index),
3469 __mi,
3470 )
3471 }
3472 }
3473 }
3474 #[doc = "`Insert(i32, crate::system::object::Object)` overload"]
3475 fn insert(self, index: impl ::core::convert::Into<i32>, value: impl ::core::convert::Into<crate::system::object::Object>) -> () {
3476 unsafe {
3477 let __receiver = <SortedList_ValueList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3478 {
3479 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3480 let __vi = *__vt.get(27usize).unwrap_or_else(|| {
3481 panic!(
3482 "unity: virtual slot {}
3483 out of range (vtable len {}
3484) on the runtime class behind {}
3485 (method `{}
3486`)",
3487 27usize,
3488 __vt.len(),
3489 <SortedList_ValueList as ::unity::ClassIdentity>::NAME,
3490 "Insert",
3491 )
3492 });
3493 let __inner: extern "C" fn(SortedList_ValueList, i32, crate::system::object::Object, ::unity::OptionalMethod) -> () =
3494 ::core::mem::transmute(__vi.method_ptr);
3495 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3496 __inner(__receiver, ::core::convert::Into::into(index), ::core::convert::Into::into(value), __mi)
3497 }
3498 }
3499 }
3500 #[doc = "`get_Item(i32)` overload"]
3501 fn get_item(self, index: impl ::core::convert::Into<i32>) -> crate::system::object::Object {
3502 unsafe {
3503 let __receiver = <SortedList_ValueList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3504 {
3505 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3506 let __vi = *__vt.get(28usize).unwrap_or_else(|| {
3507 panic!(
3508 "unity: virtual slot {}
3509 out of range (vtable len {}
3510) on the runtime class behind {}
3511 (method `{}
3512`)",
3513 28usize,
3514 __vt.len(),
3515 <SortedList_ValueList as ::unity::ClassIdentity>::NAME,
3516 "get_Item",
3517 )
3518 });
3519 let __inner: extern "C" fn(SortedList_ValueList, i32, ::unity::OptionalMethod) -> crate::system::object::Object =
3520 ::core::mem::transmute(__vi.method_ptr);
3521 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3522 __inner(__receiver, ::core::convert::Into::into(index), __mi)
3523 }
3524 }
3525 }
3526 #[doc = "`set_Item(i32, crate::system::object::Object)` overload"]
3527 fn set_item(self, index: impl ::core::convert::Into<i32>, value: impl ::core::convert::Into<crate::system::object::Object>) -> () {
3528 unsafe {
3529 let __receiver = <SortedList_ValueList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3530 {
3531 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3532 let __vi = *__vt.get(29usize).unwrap_or_else(|| {
3533 panic!(
3534 "unity: virtual slot {}
3535 out of range (vtable len {}
3536) on the runtime class behind {}
3537 (method `{}
3538`)",
3539 29usize,
3540 __vt.len(),
3541 <SortedList_ValueList as ::unity::ClassIdentity>::NAME,
3542 "set_Item",
3543 )
3544 });
3545 let __inner: extern "C" fn(SortedList_ValueList, i32, crate::system::object::Object, ::unity::OptionalMethod) -> () =
3546 ::core::mem::transmute(__vi.method_ptr);
3547 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3548 __inner(__receiver, ::core::convert::Into::into(index), ::core::convert::Into::into(value), __mi)
3549 }
3550 }
3551 }
3552 #[doc = "`GetEnumerator()` overload"]
3553 fn get_enumerator(self) -> crate::system::collections::ienumerator::IEnumerator {
3554 unsafe {
3555 let __receiver = <SortedList_ValueList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3556 {
3557 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3558 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
3559 panic!(
3560 "unity: virtual slot {}
3561 out of range (vtable len {}
3562) on the runtime class behind {}
3563 (method `{}
3564`)",
3565 30usize,
3566 __vt.len(),
3567 <SortedList_ValueList as ::unity::ClassIdentity>::NAME,
3568 "GetEnumerator",
3569 )
3570 });
3571 let __inner: extern "C" fn(SortedList_ValueList, ::unity::OptionalMethod) -> crate::system::collections::ienumerator::IEnumerator =
3572 ::core::mem::transmute(__vi.method_ptr);
3573 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3574 __inner(__receiver, __mi)
3575 }
3576 }
3577 }
3578 #[doc = "`IndexOf(crate::system::object::Object)` overload"]
3579 fn index_of(self, value: impl ::core::convert::Into<crate::system::object::Object>) -> i32 {
3580 unsafe {
3581 let __receiver = <SortedList_ValueList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3582 {
3583 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3584 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
3585 panic!(
3586 "unity: virtual slot {}
3587 out of range (vtable len {}
3588) on the runtime class behind {}
3589 (method `{}
3590`)",
3591 31usize,
3592 __vt.len(),
3593 <SortedList_ValueList as ::unity::ClassIdentity>::NAME,
3594 "IndexOf",
3595 )
3596 });
3597 let __inner: extern "C" fn(SortedList_ValueList, crate::system::object::Object, ::unity::OptionalMethod) -> i32 =
3598 ::core::mem::transmute(__vi.method_ptr);
3599 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3600 __inner(__receiver, ::core::convert::Into::into(value), __mi)
3601 }
3602 }
3603 }
3604 #[doc = "`Remove(crate::system::object::Object)` overload"]
3605 fn remove(self, value: impl ::core::convert::Into<crate::system::object::Object>) -> () {
3606 unsafe {
3607 let __receiver = <SortedList_ValueList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3608 {
3609 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3610 let __vi = *__vt.get(32usize).unwrap_or_else(|| {
3611 panic!(
3612 "unity: virtual slot {}
3613 out of range (vtable len {}
3614) on the runtime class behind {}
3615 (method `{}
3616`)",
3617 32usize,
3618 __vt.len(),
3619 <SortedList_ValueList as ::unity::ClassIdentity>::NAME,
3620 "Remove",
3621 )
3622 });
3623 let __inner: extern "C" fn(SortedList_ValueList, crate::system::object::Object, ::unity::OptionalMethod) -> () =
3624 ::core::mem::transmute(__vi.method_ptr);
3625 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3626 __inner(__receiver, ::core::convert::Into::into(value), __mi)
3627 }
3628 }
3629 }
3630 #[doc = "`RemoveAt(i32)` overload"]
3631 fn remove_at(self, index: impl ::core::convert::Into<i32>) -> () {
3632 unsafe {
3633 let __receiver = <SortedList_ValueList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3634 {
3635 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3636 let __vi = *__vt.get(33usize).unwrap_or_else(|| {
3637 panic!(
3638 "unity: virtual slot {}
3639 out of range (vtable len {}
3640) on the runtime class behind {}
3641 (method `{}
3642`)",
3643 33usize,
3644 __vt.len(),
3645 <SortedList_ValueList as ::unity::ClassIdentity>::NAME,
3646 "RemoveAt",
3647 )
3648 });
3649 let __inner: extern "C" fn(SortedList_ValueList, i32, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
3650 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3651 __inner(__receiver, ::core::convert::Into::into(index), __mi)
3652 }
3653 }
3654 }
3655}
3656
3657#[cfg(feature = "system-collections-sortedlist")]
3658impl<__T: ISortedList_ValueList> ISortedList_ValueListMethods for __T {}
3659
3660#[cfg(feature = "system-collections-sortedlist")]
3661impl SortedList_ValueList {
3662 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3663 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
3664 }
3665
3666 pub fn get_count_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3667 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
3668 }
3669
3670 pub fn get_is_read_only_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3671 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
3672 }
3673
3674 pub fn get_is_synchronized_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3675 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
3676 }
3677
3678 pub fn get_sync_root_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3679 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
3680 }
3681
3682 pub fn add_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3683 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
3684 }
3685
3686 pub fn clear_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3687 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
3688 }
3689
3690 pub fn contains_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3691 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
3692 }
3693
3694 pub fn copy_to_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3695 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[8]
3696 }
3697
3698 pub fn insert_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3699 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[9]
3700 }
3701
3702 pub fn get_item_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3703 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[10]
3704 }
3705
3706 pub fn set_item_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3707 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[11]
3708 }
3709
3710 pub fn get_enumerator_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3711 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[12]
3712 }
3713
3714 pub fn index_of_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3715 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[13]
3716 }
3717
3718 pub fn remove_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3719 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[14]
3720 }
3721
3722 pub fn remove_at_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3723 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[15]
3724 }
3725}
3726
3727#[cfg(feature = "system-collections-sortedlist")]
3728impl SortedList_ValueList {
3729 #[doc = "Direct (non-virtual) call to `SortedList_ValueList`'s own `get_Count`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3730 pub unsafe fn get_count(this: impl ::core::convert::Into<::unity::IlInstance>) -> i32 {
3731 let __mi = Self::get_count_method_info();
3732 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__mi.method_ptr);
3733 __inner(this.into(), ::core::option::Option::None)
3734 }
3735
3736 #[doc = "Direct (non-virtual) call to `SortedList_ValueList`'s own `get_IsReadOnly`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3737 pub unsafe fn get_is_read_only(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
3738 let __mi = Self::get_is_read_only_method_info();
3739 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
3740 __inner(this.into(), ::core::option::Option::None)
3741 }
3742
3743 #[doc = "Direct (non-virtual) call to `SortedList_ValueList`'s own `get_IsSynchronized`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3744 pub unsafe fn get_is_synchronized(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
3745 let __mi = Self::get_is_synchronized_method_info();
3746 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
3747 __inner(this.into(), ::core::option::Option::None)
3748 }
3749
3750 #[doc = "Direct (non-virtual) call to `SortedList_ValueList`'s own `get_SyncRoot`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3751 pub unsafe fn get_sync_root(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::system::object::Object {
3752 let __mi = Self::get_sync_root_method_info();
3753 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::system::object::Object =
3754 ::core::mem::transmute(__mi.method_ptr);
3755 __inner(this.into(), ::core::option::Option::None)
3756 }
3757
3758 #[doc = "Direct (non-virtual) call to `SortedList_ValueList`'s own `Add`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3759 pub unsafe fn add(this: impl ::core::convert::Into<::unity::IlInstance>, key: crate::system::object::Object) -> i32 {
3760 let __mi = Self::add_method_info();
3761 let __inner: extern "C" fn(::unity::IlInstance, crate::system::object::Object, ::unity::OptionalMethod) -> i32 =
3762 ::core::mem::transmute(__mi.method_ptr);
3763 __inner(this.into(), key, ::core::option::Option::None)
3764 }
3765
3766 #[doc = "Direct (non-virtual) call to `SortedList_ValueList`'s own `Clear`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3767 pub unsafe fn clear(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
3768 let __mi = Self::clear_method_info();
3769 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
3770 __inner(this.into(), ::core::option::Option::None)
3771 }
3772
3773 #[doc = "Direct (non-virtual) call to `SortedList_ValueList`'s own `Contains`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3774 pub unsafe fn contains(this: impl ::core::convert::Into<::unity::IlInstance>, value: crate::system::object::Object) -> bool {
3775 let __mi = Self::contains_method_info();
3776 let __inner: extern "C" fn(::unity::IlInstance, crate::system::object::Object, ::unity::OptionalMethod) -> bool =
3777 ::core::mem::transmute(__mi.method_ptr);
3778 __inner(this.into(), value, ::core::option::Option::None)
3779 }
3780
3781 #[doc = "Direct (non-virtual) call to `SortedList_ValueList`'s own `CopyTo`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3782 pub unsafe fn copy_to(this: impl ::core::convert::Into<::unity::IlInstance>, array: ::unity::IlInstance, array_index: i32) -> () {
3783 let __mi = Self::copy_to_method_info();
3784 let __inner: extern "C" fn(::unity::IlInstance, ::unity::IlInstance, i32, ::unity::OptionalMethod) -> () =
3785 ::core::mem::transmute(__mi.method_ptr);
3786 __inner(this.into(), array, array_index, ::core::option::Option::None)
3787 }
3788
3789 #[doc = "Direct (non-virtual) call to `SortedList_ValueList`'s own `Insert`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3790 pub unsafe fn insert(this: impl ::core::convert::Into<::unity::IlInstance>, index: i32, value: crate::system::object::Object) -> () {
3791 let __mi = Self::insert_method_info();
3792 let __inner: extern "C" fn(::unity::IlInstance, i32, crate::system::object::Object, ::unity::OptionalMethod) -> () =
3793 ::core::mem::transmute(__mi.method_ptr);
3794 __inner(this.into(), index, value, ::core::option::Option::None)
3795 }
3796
3797 #[doc = "Direct (non-virtual) call to `SortedList_ValueList`'s own `get_Item`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3798 pub unsafe fn get_item(this: impl ::core::convert::Into<::unity::IlInstance>, index: i32) -> crate::system::object::Object {
3799 let __mi = Self::get_item_method_info();
3800 let __inner: extern "C" fn(::unity::IlInstance, i32, ::unity::OptionalMethod) -> crate::system::object::Object =
3801 ::core::mem::transmute(__mi.method_ptr);
3802 __inner(this.into(), index, ::core::option::Option::None)
3803 }
3804
3805 #[doc = "Direct (non-virtual) call to `SortedList_ValueList`'s own `set_Item`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3806 pub unsafe fn set_item(this: impl ::core::convert::Into<::unity::IlInstance>, index: i32, value: crate::system::object::Object) -> () {
3807 let __mi = Self::set_item_method_info();
3808 let __inner: extern "C" fn(::unity::IlInstance, i32, crate::system::object::Object, ::unity::OptionalMethod) -> () =
3809 ::core::mem::transmute(__mi.method_ptr);
3810 __inner(this.into(), index, value, ::core::option::Option::None)
3811 }
3812
3813 #[doc = "Direct (non-virtual) call to `SortedList_ValueList`'s own `GetEnumerator`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3814 pub unsafe fn get_enumerator(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::system::collections::ienumerator::IEnumerator {
3815 let __mi = Self::get_enumerator_method_info();
3816 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::system::collections::ienumerator::IEnumerator =
3817 ::core::mem::transmute(__mi.method_ptr);
3818 __inner(this.into(), ::core::option::Option::None)
3819 }
3820
3821 #[doc = "Direct (non-virtual) call to `SortedList_ValueList`'s own `IndexOf`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3822 pub unsafe fn index_of(this: impl ::core::convert::Into<::unity::IlInstance>, value: crate::system::object::Object) -> i32 {
3823 let __mi = Self::index_of_method_info();
3824 let __inner: extern "C" fn(::unity::IlInstance, crate::system::object::Object, ::unity::OptionalMethod) -> i32 =
3825 ::core::mem::transmute(__mi.method_ptr);
3826 __inner(this.into(), value, ::core::option::Option::None)
3827 }
3828
3829 #[doc = "Direct (non-virtual) call to `SortedList_ValueList`'s own `Remove`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3830 pub unsafe fn remove(this: impl ::core::convert::Into<::unity::IlInstance>, value: crate::system::object::Object) -> () {
3831 let __mi = Self::remove_method_info();
3832 let __inner: extern "C" fn(::unity::IlInstance, crate::system::object::Object, ::unity::OptionalMethod) -> () =
3833 ::core::mem::transmute(__mi.method_ptr);
3834 __inner(this.into(), value, ::core::option::Option::None)
3835 }
3836
3837 #[doc = "Direct (non-virtual) call to `SortedList_ValueList`'s own `RemoveAt`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3838 pub unsafe fn remove_at(this: impl ::core::convert::Into<::unity::IlInstance>, index: i32) -> () {
3839 let __mi = Self::remove_at_method_info();
3840 let __inner: extern "C" fn(::unity::IlInstance, i32, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
3841 __inner(this.into(), index, ::core::option::Option::None)
3842 }
3843}
3844
3845#[cfg(feature = "system-collections-sortedlist")]
3846impl SortedList_ValueList {
3847 #[doc = "`.ctor(crate::system::collections::sortedlist::SortedList)` — overload selector"]
3848 pub fn new(sorted_list: crate::system::collections::sortedlist::SortedList) -> Self {
3849 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
3850 panic!(
3851 "{}
3852::{}
3853 failed to instantiate",
3854 ::core::stringify!(SortedList_ValueList),
3855 ::core::stringify!(new),
3856 )
3857 });
3858 <Self as ISortedList_ValueListMethods>::ctor(this, sorted_list);
3859 this
3860 }
3861}
3862
3863#[cfg(feature = "system-collections-sortedlist")]
3864#[doc(hidden)]
3865pub mod prelude {
3866 pub use super::{
3867 ISortedList, ISortedListMethods, ISortedList_KeyList, ISortedList_KeyListMethods, ISortedList_SortedListDebugView,
3868 ISortedList_SortedListEnumerator, ISortedList_SortedListEnumeratorMethods, ISortedList_SyncSortedList, ISortedList_SyncSortedListMethods,
3869 ISortedList_ValueList, ISortedList_ValueListMethods, SortedList, SortedList_KeyList, SortedList_SortedListDebugView,
3870 SortedList_SortedListEnumerator, SortedList_SyncSortedList, SortedList_ValueList,
3871 };
3872 pub use crate::system::object::IObject;
3873 #[cfg(feature = "system-object")]
3874 pub use crate::system::object::IObjectMethods;
3875}