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