1#[cfg(feature = "system-collections-hashtable-types")]
4mod __types {
5 #[allow(unused_imports)] use ::unity::prelude::*;
6
7 use super::*;
8 use crate::system::{
9 object::{IObject, Object},
10 valuetype::{IValueType, ValueType},
11 };
12
13 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/system/collections/hashtable/Hashtable_bucket.md"))]
14 #[repr(C)]
15 #[derive(::core::clone::Clone, ::core::marker::Copy)]
16 pub struct Hashtable_bucket {
17 pub key: ::unity::IlInstance,
18 pub val: ::unity::IlInstance,
19 pub hash_coll: i32,
20 }
21 impl ::unity::ClassIdentity for Hashtable_bucket {
22 const NAME: &'static str = "Hashtable.bucket";
23 const NAMESPACE: &'static str = "System.Collections";
24
25 fn class() -> ::unity::Class {
26 static CACHE: ::std::sync::OnceLock<::unity::Class> = ::std::sync::OnceLock::new();
27 *CACHE.get_or_init(|| ::unity::Class::lookup(Self::NAMESPACE, Self::NAME))
28 }
29 }
30 impl ::unity::IlType for Hashtable_bucket {
31 fn il_type() -> &'static ::unity::il2cpp::Il2CppType {
32 &<Self as ::unity::ClassIdentity>::class().raw()._1.byval_arg
33 }
34 }
35
36 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/system/collections/hashtable/Hashtable_KeyCollection.md"))]
37 #[::unity::class(namespace = "System.Collections", name = "Hashtable.KeyCollection")]
38 #[parent(crate::system::object::Object)]
39 pub struct Hashtable_KeyCollection {
40 #[offset(16)]
41 #[rename(name = "_hashtable")]
42 pub hashtable: crate::system::collections::hashtable::Hashtable,
43 }
44
45 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/system/collections/hashtable/Hashtable_ValueCollection.md"))]
46 #[::unity::class(namespace = "System.Collections", name = "Hashtable.ValueCollection")]
47 #[parent(crate::system::object::Object)]
48 pub struct Hashtable_ValueCollection {
49 #[offset(16)]
50 #[rename(name = "_hashtable")]
51 pub hashtable: crate::system::collections::hashtable::Hashtable,
52 }
53
54 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/system/collections/hashtable/Hashtable.md"))]
55 #[::unity::class(namespace = "System.Collections", name = "Hashtable")]
56 #[parent(crate::system::object::Object)]
57 pub struct Hashtable {
58 #[static_field]
59 #[rename(name = "HashPrime")]
60 pub hash_prime: i32,
61 #[static_field]
62 #[rename(name = "InitialSize")]
63 pub initial_size: i32,
64 #[static_field]
65 #[rename(name = "LoadFactorName")]
66 pub load_factor_name: ::unity::Il2CppString,
67 #[static_field]
68 #[rename(name = "VersionName")]
69 pub version_name: ::unity::Il2CppString,
70 #[static_field]
71 #[rename(name = "ComparerName")]
72 pub comparer_name: ::unity::Il2CppString,
73 #[static_field]
74 #[rename(name = "HashCodeProviderName")]
75 pub hash_code_provider_name: ::unity::Il2CppString,
76 #[static_field]
77 #[rename(name = "HashSizeName")]
78 pub hash_size_name: ::unity::Il2CppString,
79 #[static_field]
80 #[rename(name = "KeysName")]
81 pub keys_name: ::unity::Il2CppString,
82 #[static_field]
83 #[rename(name = "ValuesName")]
84 pub values_name: ::unity::Il2CppString,
85 #[static_field]
86 #[rename(name = "KeyComparerName")]
87 pub key_comparer_name: ::unity::Il2CppString,
88 #[offset(16)]
89 #[rename(name = "buckets")]
90 pub buckets: ::unity::Array<crate::system::collections::hashtable::Hashtable_bucket>,
91 #[offset(24)]
92 #[rename(name = "count")]
93 pub count: i32,
94 #[offset(28)]
95 #[rename(name = "occupancy")]
96 pub occupancy: i32,
97 #[offset(32)]
98 #[rename(name = "loadsize")]
99 pub loadsize: i32,
100 #[offset(36)]
101 #[rename(name = "loadFactor")]
102 pub load_factor: f32,
103 #[offset(40)]
104 #[rename(name = "version")]
105 pub version: i32,
106 #[offset(44)]
107 #[rename(name = "isWriterInProgress")]
108 pub is_writer_in_progress: bool,
109 #[offset(48)]
110 #[rename(name = "keys")]
111 pub keys: crate::system::collections::icollection::ICollection,
112 #[offset(56)]
113 #[rename(name = "values")]
114 pub values: crate::system::collections::icollection::ICollection,
115 #[offset(64)]
116 #[rename(name = "_keycomparer")]
117 pub keycomparer: crate::system::collections::iequalitycomparer::IEqualityComparer,
118 #[offset(72)]
119 #[rename(name = "_syncRoot")]
120 pub sync_root: ::unity::IlInstance,
121 }
122
123 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/system/collections/hashtable/Hashtable_HashtableDebugView.md"))]
124 #[::unity::class(namespace = "System.Collections", name = "Hashtable.HashtableDebugView")]
125 #[parent(crate::system::object::Object)]
126 pub struct Hashtable_HashtableDebugView {}
127
128 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/system/collections/hashtable/Hashtable_SyncHashtable.md"))]
129 #[::unity::class(namespace = "System.Collections", name = "Hashtable.SyncHashtable")]
130 #[parent(crate::system::collections::hashtable::Hashtable)]
131 pub struct Hashtable_SyncHashtable {
132 #[offset(80)]
133 #[rename(name = "_table")]
134 pub table: crate::system::collections::hashtable::Hashtable,
135 }
136
137 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/system/collections/hashtable/Hashtable_HashtableEnumerator.md"))]
138 #[::unity::class(namespace = "System.Collections", name = "Hashtable.HashtableEnumerator")]
139 #[parent(crate::system::object::Object)]
140 pub struct Hashtable_HashtableEnumerator {
141 #[offset(16)]
142 #[rename(name = "hashtable")]
143 pub hashtable: crate::system::collections::hashtable::Hashtable,
144 #[offset(24)]
145 #[rename(name = "bucket")]
146 pub bucket: i32,
147 #[offset(28)]
148 #[rename(name = "version")]
149 pub version: i32,
150 #[offset(32)]
151 #[rename(name = "current")]
152 pub current: bool,
153 #[offset(36)]
154 #[rename(name = "getObjectRetType")]
155 pub get_object_ret_type: i32,
156 #[offset(40)]
157 #[rename(name = "currentKey")]
158 pub current_key: ::unity::IlInstance,
159 #[offset(48)]
160 #[rename(name = "currentValue")]
161 pub current_value: ::unity::IlInstance,
162 }
163}
164
165#[cfg(feature = "system-collections-hashtable-types")]
166pub use __types::*;
167
168#[cfg(feature = "system-collections-hashtable")]
169pub trait IHashtable_KeyCollectionMethods: IHashtable_KeyCollection {
170 #[doc = "`.ctor(crate::system::collections::hashtable::Hashtable)` overload"]
171 fn ctor(self, hashtable: impl ::core::convert::Into<crate::system::collections::hashtable::Hashtable>) -> () {
172 unsafe {
173 let __receiver =
174 <Hashtable_KeyCollection as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
175 ::unity::il2cpp_call!((::unity::module_base()+0x34d7620usize)as*mut u8,();
176(Hashtable_KeyCollection)__receiver,(crate::system::collections::hashtable::Hashtable)::core::convert::Into::into(hashtable))
177 }
178 }
179 #[doc = "`CopyTo(::unity::IlInstance, i32)` overload"]
180 fn copy_to(self, array: impl ::core::convert::Into<::unity::IlInstance>, array_index: impl ::core::convert::Into<i32>) -> () {
181 unsafe {
182 let __receiver =
183 <Hashtable_KeyCollection as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
184 {
185 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
186 let __vi = *__vt.get(9usize).unwrap_or_else(|| {
187 panic!(
188 "unity: virtual slot {}
189 out of range (vtable len {}
190) on the runtime class behind {}
191 (method `{}
192`)",
193 9usize,
194 __vt.len(),
195 <Hashtable_KeyCollection as ::unity::ClassIdentity>::NAME,
196 "CopyTo",
197 )
198 });
199 let __inner: extern "C" fn(Hashtable_KeyCollection, ::unity::IlInstance, i32, ::unity::OptionalMethod) -> () =
200 ::core::mem::transmute(__vi.method_ptr);
201 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
202 __inner(
203 __receiver,
204 ::core::convert::Into::into(array),
205 ::core::convert::Into::into(array_index),
206 __mi,
207 )
208 }
209 }
210 }
211 #[doc = "`GetEnumerator()` overload"]
212 fn get_enumerator(self) -> crate::system::collections::ienumerator::IEnumerator {
213 unsafe {
214 let __receiver =
215 <Hashtable_KeyCollection as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
216 {
217 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
218 let __vi = *__vt.get(10usize).unwrap_or_else(|| {
219 panic!(
220 "unity: virtual slot {}
221 out of range (vtable len {}
222) on the runtime class behind {}
223 (method `{}
224`)",
225 10usize,
226 __vt.len(),
227 <Hashtable_KeyCollection as ::unity::ClassIdentity>::NAME,
228 "GetEnumerator",
229 )
230 });
231 let __inner: extern "C" fn(Hashtable_KeyCollection, ::unity::OptionalMethod) -> crate::system::collections::ienumerator::IEnumerator =
232 ::core::mem::transmute(__vi.method_ptr);
233 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
234 __inner(__receiver, __mi)
235 }
236 }
237 }
238 #[doc = "`get_IsSynchronized()` overload"]
239 fn get_is_synchronized(self) -> bool {
240 unsafe {
241 let __receiver =
242 <Hashtable_KeyCollection as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
243 {
244 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
245 let __vi = *__vt.get(11usize).unwrap_or_else(|| {
246 panic!(
247 "unity: virtual slot {}
248 out of range (vtable len {}
249) on the runtime class behind {}
250 (method `{}
251`)",
252 11usize,
253 __vt.len(),
254 <Hashtable_KeyCollection as ::unity::ClassIdentity>::NAME,
255 "get_IsSynchronized",
256 )
257 });
258 let __inner: extern "C" fn(Hashtable_KeyCollection, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
259 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
260 __inner(__receiver, __mi)
261 }
262 }
263 }
264 #[doc = "`get_SyncRoot()` overload"]
265 fn get_sync_root(self) -> crate::system::object::Object {
266 unsafe {
267 let __receiver =
268 <Hashtable_KeyCollection 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(12usize).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 12usize,
279 __vt.len(),
280 <Hashtable_KeyCollection as ::unity::ClassIdentity>::NAME,
281 "get_SyncRoot",
282 )
283 });
284 let __inner: extern "C" fn(Hashtable_KeyCollection, ::unity::OptionalMethod) -> crate::system::object::Object =
285 ::core::mem::transmute(__vi.method_ptr);
286 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
287 __inner(__receiver, __mi)
288 }
289 }
290 }
291 #[doc = "`get_Count()` overload"]
292 fn get_count(self) -> i32 {
293 unsafe {
294 let __receiver =
295 <Hashtable_KeyCollection as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
296 {
297 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
298 let __vi = *__vt.get(13usize).unwrap_or_else(|| {
299 panic!(
300 "unity: virtual slot {}
301 out of range (vtable len {}
302) on the runtime class behind {}
303 (method `{}
304`)",
305 13usize,
306 __vt.len(),
307 <Hashtable_KeyCollection as ::unity::ClassIdentity>::NAME,
308 "get_Count",
309 )
310 });
311 let __inner: extern "C" fn(Hashtable_KeyCollection, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__vi.method_ptr);
312 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
313 __inner(__receiver, __mi)
314 }
315 }
316 }
317}
318
319#[cfg(feature = "system-collections-hashtable")]
320impl<__T: IHashtable_KeyCollection> IHashtable_KeyCollectionMethods for __T {}
321
322#[cfg(feature = "system-collections-hashtable")]
323impl Hashtable_KeyCollection {
324 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
325 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
326 }
327
328 pub fn copy_to_method_info() -> &'static ::unity::il2cpp::MethodInfo {
329 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
330 }
331
332 pub fn get_enumerator_method_info() -> &'static ::unity::il2cpp::MethodInfo {
333 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
334 }
335
336 pub fn get_is_synchronized_method_info() -> &'static ::unity::il2cpp::MethodInfo {
337 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
338 }
339
340 pub fn get_sync_root_method_info() -> &'static ::unity::il2cpp::MethodInfo {
341 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
342 }
343
344 pub fn get_count_method_info() -> &'static ::unity::il2cpp::MethodInfo {
345 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
346 }
347}
348
349#[cfg(feature = "system-collections-hashtable")]
350impl Hashtable_KeyCollection {
351 #[doc = "Direct (non-virtual) call to `Hashtable_KeyCollection`'s own `CopyTo`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
352 pub unsafe fn copy_to(this: impl ::core::convert::Into<::unity::IlInstance>, array: ::unity::IlInstance, array_index: i32) -> () {
353 let __mi = Self::copy_to_method_info();
354 let __inner: extern "C" fn(::unity::IlInstance, ::unity::IlInstance, i32, ::unity::OptionalMethod) -> () =
355 ::core::mem::transmute(__mi.method_ptr);
356 __inner(this.into(), array, array_index, ::core::option::Option::None)
357 }
358
359 #[doc = "Direct (non-virtual) call to `Hashtable_KeyCollection`'s own `GetEnumerator`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
360 pub unsafe fn get_enumerator(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::system::collections::ienumerator::IEnumerator {
361 let __mi = Self::get_enumerator_method_info();
362 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::system::collections::ienumerator::IEnumerator =
363 ::core::mem::transmute(__mi.method_ptr);
364 __inner(this.into(), ::core::option::Option::None)
365 }
366
367 #[doc = "Direct (non-virtual) call to `Hashtable_KeyCollection`'s own `get_IsSynchronized`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
368 pub unsafe fn get_is_synchronized(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
369 let __mi = Self::get_is_synchronized_method_info();
370 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
371 __inner(this.into(), ::core::option::Option::None)
372 }
373
374 #[doc = "Direct (non-virtual) call to `Hashtable_KeyCollection`'s own `get_SyncRoot`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
375 pub unsafe fn get_sync_root(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::system::object::Object {
376 let __mi = Self::get_sync_root_method_info();
377 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::system::object::Object =
378 ::core::mem::transmute(__mi.method_ptr);
379 __inner(this.into(), ::core::option::Option::None)
380 }
381
382 #[doc = "Direct (non-virtual) call to `Hashtable_KeyCollection`'s own `get_Count`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
383 pub unsafe fn get_count(this: impl ::core::convert::Into<::unity::IlInstance>) -> i32 {
384 let __mi = Self::get_count_method_info();
385 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__mi.method_ptr);
386 __inner(this.into(), ::core::option::Option::None)
387 }
388}
389
390#[cfg(feature = "system-collections-hashtable")]
391impl Hashtable_KeyCollection {
392 #[doc = "`.ctor(crate::system::collections::hashtable::Hashtable)` — overload selector"]
393 pub fn new(hashtable: crate::system::collections::hashtable::Hashtable) -> Self {
394 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
395 panic!(
396 "{}
397::{}
398 failed to instantiate",
399 ::core::stringify!(Hashtable_KeyCollection),
400 ::core::stringify!(new),
401 )
402 });
403 <Self as IHashtable_KeyCollectionMethods>::ctor(this, hashtable);
404 this
405 }
406}
407
408#[cfg(feature = "system-collections-hashtable")]
409pub trait IHashtable_ValueCollectionMethods: IHashtable_ValueCollection {
410 #[doc = "`.ctor(crate::system::collections::hashtable::Hashtable)` overload"]
411 fn ctor(self, hashtable: impl ::core::convert::Into<crate::system::collections::hashtable::Hashtable>) -> () {
412 unsafe {
413 let __receiver =
414 <Hashtable_ValueCollection as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
415 ::unity::il2cpp_call!((::unity::module_base()+0x34d8670usize)as*mut u8,();
416(Hashtable_ValueCollection)__receiver,(crate::system::collections::hashtable::Hashtable)::core::convert::Into::into(hashtable))
417 }
418 }
419 #[doc = "`CopyTo(::unity::IlInstance, i32)` overload"]
420 fn copy_to(self, array: impl ::core::convert::Into<::unity::IlInstance>, array_index: impl ::core::convert::Into<i32>) -> () {
421 unsafe {
422 let __receiver =
423 <Hashtable_ValueCollection as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
424 {
425 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
426 let __vi = *__vt.get(9usize).unwrap_or_else(|| {
427 panic!(
428 "unity: virtual slot {}
429 out of range (vtable len {}
430) on the runtime class behind {}
431 (method `{}
432`)",
433 9usize,
434 __vt.len(),
435 <Hashtable_ValueCollection as ::unity::ClassIdentity>::NAME,
436 "CopyTo",
437 )
438 });
439 let __inner: extern "C" fn(Hashtable_ValueCollection, ::unity::IlInstance, i32, ::unity::OptionalMethod) -> () =
440 ::core::mem::transmute(__vi.method_ptr);
441 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
442 __inner(
443 __receiver,
444 ::core::convert::Into::into(array),
445 ::core::convert::Into::into(array_index),
446 __mi,
447 )
448 }
449 }
450 }
451 #[doc = "`GetEnumerator()` overload"]
452 fn get_enumerator(self) -> crate::system::collections::ienumerator::IEnumerator {
453 unsafe {
454 let __receiver =
455 <Hashtable_ValueCollection as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
456 {
457 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
458 let __vi = *__vt.get(10usize).unwrap_or_else(|| {
459 panic!(
460 "unity: virtual slot {}
461 out of range (vtable len {}
462) on the runtime class behind {}
463 (method `{}
464`)",
465 10usize,
466 __vt.len(),
467 <Hashtable_ValueCollection as ::unity::ClassIdentity>::NAME,
468 "GetEnumerator",
469 )
470 });
471 let __inner: extern "C" fn(
472 Hashtable_ValueCollection,
473 ::unity::OptionalMethod,
474 ) -> crate::system::collections::ienumerator::IEnumerator = ::core::mem::transmute(__vi.method_ptr);
475 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
476 __inner(__receiver, __mi)
477 }
478 }
479 }
480 #[doc = "`get_IsSynchronized()` overload"]
481 fn get_is_synchronized(self) -> bool {
482 unsafe {
483 let __receiver =
484 <Hashtable_ValueCollection as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
485 {
486 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
487 let __vi = *__vt.get(11usize).unwrap_or_else(|| {
488 panic!(
489 "unity: virtual slot {}
490 out of range (vtable len {}
491) on the runtime class behind {}
492 (method `{}
493`)",
494 11usize,
495 __vt.len(),
496 <Hashtable_ValueCollection as ::unity::ClassIdentity>::NAME,
497 "get_IsSynchronized",
498 )
499 });
500 let __inner: extern "C" fn(Hashtable_ValueCollection, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
501 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
502 __inner(__receiver, __mi)
503 }
504 }
505 }
506 #[doc = "`get_SyncRoot()` overload"]
507 fn get_sync_root(self) -> crate::system::object::Object {
508 unsafe {
509 let __receiver =
510 <Hashtable_ValueCollection as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
511 {
512 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
513 let __vi = *__vt.get(12usize).unwrap_or_else(|| {
514 panic!(
515 "unity: virtual slot {}
516 out of range (vtable len {}
517) on the runtime class behind {}
518 (method `{}
519`)",
520 12usize,
521 __vt.len(),
522 <Hashtable_ValueCollection as ::unity::ClassIdentity>::NAME,
523 "get_SyncRoot",
524 )
525 });
526 let __inner: extern "C" fn(Hashtable_ValueCollection, ::unity::OptionalMethod) -> crate::system::object::Object =
527 ::core::mem::transmute(__vi.method_ptr);
528 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
529 __inner(__receiver, __mi)
530 }
531 }
532 }
533 #[doc = "`get_Count()` overload"]
534 fn get_count(self) -> i32 {
535 unsafe {
536 let __receiver =
537 <Hashtable_ValueCollection as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
538 {
539 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
540 let __vi = *__vt.get(13usize).unwrap_or_else(|| {
541 panic!(
542 "unity: virtual slot {}
543 out of range (vtable len {}
544) on the runtime class behind {}
545 (method `{}
546`)",
547 13usize,
548 __vt.len(),
549 <Hashtable_ValueCollection as ::unity::ClassIdentity>::NAME,
550 "get_Count",
551 )
552 });
553 let __inner: extern "C" fn(Hashtable_ValueCollection, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__vi.method_ptr);
554 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
555 __inner(__receiver, __mi)
556 }
557 }
558 }
559}
560
561#[cfg(feature = "system-collections-hashtable")]
562impl<__T: IHashtable_ValueCollection> IHashtable_ValueCollectionMethods for __T {}
563
564#[cfg(feature = "system-collections-hashtable")]
565impl Hashtable_ValueCollection {
566 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
567 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
568 }
569
570 pub fn copy_to_method_info() -> &'static ::unity::il2cpp::MethodInfo {
571 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
572 }
573
574 pub fn get_enumerator_method_info() -> &'static ::unity::il2cpp::MethodInfo {
575 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
576 }
577
578 pub fn get_is_synchronized_method_info() -> &'static ::unity::il2cpp::MethodInfo {
579 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
580 }
581
582 pub fn get_sync_root_method_info() -> &'static ::unity::il2cpp::MethodInfo {
583 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
584 }
585
586 pub fn get_count_method_info() -> &'static ::unity::il2cpp::MethodInfo {
587 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
588 }
589}
590
591#[cfg(feature = "system-collections-hashtable")]
592impl Hashtable_ValueCollection {
593 #[doc = "Direct (non-virtual) call to `Hashtable_ValueCollection`'s own `CopyTo`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
594 pub unsafe fn copy_to(this: impl ::core::convert::Into<::unity::IlInstance>, array: ::unity::IlInstance, array_index: i32) -> () {
595 let __mi = Self::copy_to_method_info();
596 let __inner: extern "C" fn(::unity::IlInstance, ::unity::IlInstance, i32, ::unity::OptionalMethod) -> () =
597 ::core::mem::transmute(__mi.method_ptr);
598 __inner(this.into(), array, array_index, ::core::option::Option::None)
599 }
600
601 #[doc = "Direct (non-virtual) call to `Hashtable_ValueCollection`'s own `GetEnumerator`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
602 pub unsafe fn get_enumerator(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::system::collections::ienumerator::IEnumerator {
603 let __mi = Self::get_enumerator_method_info();
604 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::system::collections::ienumerator::IEnumerator =
605 ::core::mem::transmute(__mi.method_ptr);
606 __inner(this.into(), ::core::option::Option::None)
607 }
608
609 #[doc = "Direct (non-virtual) call to `Hashtable_ValueCollection`'s own `get_IsSynchronized`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
610 pub unsafe fn get_is_synchronized(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
611 let __mi = Self::get_is_synchronized_method_info();
612 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
613 __inner(this.into(), ::core::option::Option::None)
614 }
615
616 #[doc = "Direct (non-virtual) call to `Hashtable_ValueCollection`'s own `get_SyncRoot`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
617 pub unsafe fn get_sync_root(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::system::object::Object {
618 let __mi = Self::get_sync_root_method_info();
619 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::system::object::Object =
620 ::core::mem::transmute(__mi.method_ptr);
621 __inner(this.into(), ::core::option::Option::None)
622 }
623
624 #[doc = "Direct (non-virtual) call to `Hashtable_ValueCollection`'s own `get_Count`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
625 pub unsafe fn get_count(this: impl ::core::convert::Into<::unity::IlInstance>) -> i32 {
626 let __mi = Self::get_count_method_info();
627 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__mi.method_ptr);
628 __inner(this.into(), ::core::option::Option::None)
629 }
630}
631
632#[cfg(feature = "system-collections-hashtable")]
633impl Hashtable_ValueCollection {
634 #[doc = "`.ctor(crate::system::collections::hashtable::Hashtable)` — overload selector"]
635 pub fn new(hashtable: crate::system::collections::hashtable::Hashtable) -> Self {
636 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
637 panic!(
638 "{}
639::{}
640 failed to instantiate",
641 ::core::stringify!(Hashtable_ValueCollection),
642 ::core::stringify!(new),
643 )
644 });
645 <Self as IHashtable_ValueCollectionMethods>::ctor(this, hashtable);
646 this
647 }
648}
649
650#[cfg(feature = "system-collections-hashtable")]
651impl Hashtable {
652 #[doc = "`Synchronized(crate::system::collections::hashtable::Hashtable)` overload"]
653 pub fn synchronized(
654 table: impl ::core::convert::Into<crate::system::collections::hashtable::Hashtable>,
655 ) -> crate::system::collections::hashtable::Hashtable {
656 unsafe {
657 ::unity::il2cpp_call!((::unity::module_base()+0x3820770usize)as*mut u8,crate::system::collections::hashtable::Hashtable;
658(crate::system::collections::hashtable::Hashtable)::core::convert::Into::into(table))
659 }
660 }
661}
662
663#[cfg(feature = "system-collections-hashtable")]
664pub trait IHashtableMethods: IHashtable {
665 #[doc = "`.ctor(bool)` overload"]
666 fn ctor(self, trash: impl ::core::convert::Into<bool>) -> () {
667 unsafe {
668 let __receiver = <Hashtable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
669 ::unity::il2cpp_call!((::unity::module_base()+0x381e6e0usize)as*mut u8,();
670(Hashtable)__receiver,(bool)::core::convert::Into::into(trash))
671 }
672 }
673 #[doc = "`.ctor()` overload"]
674 fn ctor_2(self) -> () {
675 unsafe {
676 let __receiver = <Hashtable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
677 ::unity::il2cpp_call!((::unity::module_base()+0x381e6f0usize)as*mut u8,();
678(Hashtable)__receiver)
679 }
680 }
681 #[doc = "`.ctor(i32)` overload"]
682 fn ctor_3(self, capacity: impl ::core::convert::Into<i32>) -> () {
683 unsafe {
684 let __receiver = <Hashtable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
685 ::unity::il2cpp_call!((::unity::module_base()+0x381e9f0usize)as*mut u8,();
686(Hashtable)__receiver,(i32)::core::convert::Into::into(capacity))
687 }
688 }
689 #[doc = "`.ctor(i32, f32)` overload"]
690 fn ctor_4(self, capacity: impl ::core::convert::Into<i32>, load_factor: impl ::core::convert::Into<f32>) -> () {
691 unsafe {
692 let __receiver = <Hashtable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
693 ::unity::il2cpp_call!((::unity::module_base()+0x381e700usize)as*mut u8,();
694(Hashtable)__receiver,(i32)::core::convert::Into::into(capacity),(f32)::core::convert::Into::into(load_factor))
695 }
696 }
697 #[doc = "`.ctor(i32, f32, crate::system::collections::ihashcodeprovider::IHashCodeProvider, crate::system::collections::icomparer_interface::IComparer_Interface)` overload"]
698 fn ctor_5(
699 self,
700 capacity: impl ::core::convert::Into<i32>,
701 load_factor: impl ::core::convert::Into<f32>,
702 hcp: impl ::core::convert::Into<crate::system::collections::ihashcodeprovider::IHashCodeProvider>,
703 comparer: impl ::core::convert::Into<crate::system::collections::icomparer_interface::IComparer_Interface>,
704 ) -> () {
705 unsafe {
706 let __receiver = <Hashtable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
707 ::unity::il2cpp_call!((::unity::module_base()+0x381ea00usize)as*mut u8,();
708(Hashtable)__receiver,(i32)::core::convert::Into::into(capacity),(f32)::core::convert::Into::into(load_factor),(crate::system::collections::ihashcodeprovider::IHashCodeProvider)::core::convert::Into::into(hcp),(crate::system::collections::icomparer_interface::IComparer_Interface)::core::convert::Into::into(comparer))
709 }
710 }
711 #[doc = "`.ctor(i32, f32, crate::system::collections::iequalitycomparer::IEqualityComparer)` overload"]
712 fn ctor_6(
713 self,
714 capacity: impl ::core::convert::Into<i32>,
715 load_factor: impl ::core::convert::Into<f32>,
716 equality_comparer: impl ::core::convert::Into<crate::system::collections::iequalitycomparer::IEqualityComparer>,
717 ) -> () {
718 unsafe {
719 let __receiver = <Hashtable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
720 ::unity::il2cpp_call!((::unity::module_base()+0x381eac0usize)as*mut u8,();
721(Hashtable)__receiver,(i32)::core::convert::Into::into(capacity),(f32)::core::convert::Into::into(load_factor),(crate::system::collections::iequalitycomparer::IEqualityComparer)::core::convert::Into::into(equality_comparer))
722 }
723 }
724 #[doc = "`.ctor(crate::system::collections::ihashcodeprovider::IHashCodeProvider, crate::system::collections::icomparer_interface::IComparer_Interface)` overload"]
725 fn ctor_7(
726 self,
727 hcp: impl ::core::convert::Into<crate::system::collections::ihashcodeprovider::IHashCodeProvider>,
728 comparer: impl ::core::convert::Into<crate::system::collections::icomparer_interface::IComparer_Interface>,
729 ) -> () {
730 unsafe {
731 let __receiver = <Hashtable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
732 ::unity::il2cpp_call!((::unity::module_base()+0x381eaf0usize)as*mut u8,();
733(Hashtable)__receiver,(crate::system::collections::ihashcodeprovider::IHashCodeProvider)::core::convert::Into::into(hcp),(crate::system::collections::icomparer_interface::IComparer_Interface)::core::convert::Into::into(comparer))
734 }
735 }
736 #[doc = "`.ctor(crate::system::collections::iequalitycomparer::IEqualityComparer)` overload"]
737 fn ctor_8(self, equality_comparer: impl ::core::convert::Into<crate::system::collections::iequalitycomparer::IEqualityComparer>) -> () {
738 unsafe {
739 let __receiver = <Hashtable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
740 ::unity::il2cpp_call!((::unity::module_base()+0x381eba0usize)as*mut u8,();
741(Hashtable)__receiver,(crate::system::collections::iequalitycomparer::IEqualityComparer)::core::convert::Into::into(equality_comparer))
742 }
743 }
744 #[doc = "`.ctor(i32, crate::system::collections::iequalitycomparer::IEqualityComparer)` overload"]
745 fn ctor_9(
746 self,
747 capacity: impl ::core::convert::Into<i32>,
748 equality_comparer: impl ::core::convert::Into<crate::system::collections::iequalitycomparer::IEqualityComparer>,
749 ) -> () {
750 unsafe {
751 let __receiver = <Hashtable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
752 ::unity::il2cpp_call!((::unity::module_base()+0x381ebe0usize)as*mut u8,();
753(Hashtable)__receiver,(i32)::core::convert::Into::into(capacity),(crate::system::collections::iequalitycomparer::IEqualityComparer)::core::convert::Into::into(equality_comparer))
754 }
755 }
756 #[doc = "`InitHash(crate::system::object::Object, i32, *mutu32, *mutu32)` overload"]
757 fn init_hash(self, key: impl ::core::convert::Into<crate::system::object::Object>, hashsize: impl ::core::convert::Into<i32>) -> (u32, u32, u32) {
758 unsafe {
759 let __receiver = <Hashtable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
760 let mut __out_0 = ::core::mem::MaybeUninit::<u32>::uninit();
761 let mut __out_1 = ::core::mem::MaybeUninit::<u32>::uninit();
762 let __ret = {
763 ::unity::il2cpp_call!((::unity::module_base()+0x381ecc0usize)as*mut u8,u32;
764(Hashtable)__receiver,(crate::system::object::Object)::core::convert::Into::into(key),(i32)::core::convert::Into::into(hashsize),(*mut u32)__out_0.as_mut_ptr(),(*mut u32)__out_1.as_mut_ptr())
765 };
766 (__ret, __out_0.assume_init(), __out_1.assume_init())
767 }
768 }
769 #[doc = "`Add(crate::system::object::Object, crate::system::object::Object)` overload"]
770 fn add(
771 self,
772 key: impl ::core::convert::Into<crate::system::object::Object>,
773 value: impl ::core::convert::Into<crate::system::object::Object>,
774 ) -> () {
775 unsafe {
776 let __receiver = <Hashtable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
777 {
778 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
779 let __vi = *__vt.get(22usize).unwrap_or_else(|| {
780 panic!(
781 "unity: virtual slot {}
782 out of range (vtable len {}
783) on the runtime class behind {}
784 (method `{}
785`)",
786 22usize,
787 __vt.len(),
788 <Hashtable as ::unity::ClassIdentity>::NAME,
789 "Add",
790 )
791 });
792 let __inner: extern "C" fn(Hashtable, crate::system::object::Object, crate::system::object::Object, ::unity::OptionalMethod) -> () =
793 ::core::mem::transmute(__vi.method_ptr);
794 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
795 __inner(__receiver, ::core::convert::Into::into(key), ::core::convert::Into::into(value), __mi)
796 }
797 }
798 }
799 #[doc = "`Clear()` overload"]
800 fn clear(self) -> () {
801 unsafe {
802 let __receiver = <Hashtable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
803 {
804 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
805 let __vi = *__vt.get(23usize).unwrap_or_else(|| {
806 panic!(
807 "unity: virtual slot {}
808 out of range (vtable len {}
809) on the runtime class behind {}
810 (method `{}
811`)",
812 23usize,
813 __vt.len(),
814 <Hashtable as ::unity::ClassIdentity>::NAME,
815 "Clear",
816 )
817 });
818 let __inner: extern "C" fn(Hashtable, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
819 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
820 __inner(__receiver, __mi)
821 }
822 }
823 }
824 #[doc = "`Clone()` overload"]
825 fn clone(self) -> crate::system::object::Object {
826 unsafe {
827 let __receiver = <Hashtable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
828 {
829 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
830 let __vi = *__vt.get(24usize).unwrap_or_else(|| {
831 panic!(
832 "unity: virtual slot {}
833 out of range (vtable len {}
834) on the runtime class behind {}
835 (method `{}
836`)",
837 24usize,
838 __vt.len(),
839 <Hashtable as ::unity::ClassIdentity>::NAME,
840 "Clone",
841 )
842 });
843 let __inner: extern "C" fn(Hashtable, ::unity::OptionalMethod) -> crate::system::object::Object =
844 ::core::mem::transmute(__vi.method_ptr);
845 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
846 __inner(__receiver, __mi)
847 }
848 }
849 }
850 #[doc = "`Contains(crate::system::object::Object)` overload"]
851 fn contains(self, key: impl ::core::convert::Into<crate::system::object::Object>) -> bool {
852 unsafe {
853 let __receiver = <Hashtable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
854 {
855 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
856 let __vi = *__vt.get(25usize).unwrap_or_else(|| {
857 panic!(
858 "unity: virtual slot {}
859 out of range (vtable len {}
860) on the runtime class behind {}
861 (method `{}
862`)",
863 25usize,
864 __vt.len(),
865 <Hashtable as ::unity::ClassIdentity>::NAME,
866 "Contains",
867 )
868 });
869 let __inner: extern "C" fn(Hashtable, crate::system::object::Object, ::unity::OptionalMethod) -> bool =
870 ::core::mem::transmute(__vi.method_ptr);
871 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
872 __inner(__receiver, ::core::convert::Into::into(key), __mi)
873 }
874 }
875 }
876 #[doc = "`ContainsKey(crate::system::object::Object)` overload"]
877 fn contains_key(self, key: impl ::core::convert::Into<crate::system::object::Object>) -> bool {
878 unsafe {
879 let __receiver = <Hashtable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
880 {
881 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
882 let __vi = *__vt.get(26usize).unwrap_or_else(|| {
883 panic!(
884 "unity: virtual slot {}
885 out of range (vtable len {}
886) on the runtime class behind {}
887 (method `{}
888`)",
889 26usize,
890 __vt.len(),
891 <Hashtable as ::unity::ClassIdentity>::NAME,
892 "ContainsKey",
893 )
894 });
895 let __inner: extern "C" fn(Hashtable, crate::system::object::Object, ::unity::OptionalMethod) -> bool =
896 ::core::mem::transmute(__vi.method_ptr);
897 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
898 __inner(__receiver, ::core::convert::Into::into(key), __mi)
899 }
900 }
901 }
902 #[doc = "`CopyKeys(::unity::IlInstance, i32)` overload"]
903 fn copy_keys(self, array: impl ::core::convert::Into<::unity::IlInstance>, array_index: impl ::core::convert::Into<i32>) -> () {
904 unsafe {
905 let __receiver = <Hashtable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
906 ::unity::il2cpp_call!((::unity::module_base()+0x381f5f0usize)as*mut u8,();
907(Hashtable)__receiver,(::unity::IlInstance)::core::convert::Into::into(array),(i32)::core::convert::Into::into(array_index))
908 }
909 }
910 #[doc = "`CopyEntries(::unity::IlInstance, i32)` overload"]
911 fn copy_entries(self, array: impl ::core::convert::Into<::unity::IlInstance>, array_index: impl ::core::convert::Into<i32>) -> () {
912 unsafe {
913 let __receiver = <Hashtable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
914 ::unity::il2cpp_call!((::unity::module_base()+0x381f6a0usize)as*mut u8,();
915(Hashtable)__receiver,(::unity::IlInstance)::core::convert::Into::into(array),(i32)::core::convert::Into::into(array_index))
916 }
917 }
918 #[doc = "`CopyTo(::unity::IlInstance, i32)` overload"]
919 fn copy_to(self, array: impl ::core::convert::Into<::unity::IlInstance>, array_index: impl ::core::convert::Into<i32>) -> () {
920 unsafe {
921 let __receiver = <Hashtable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
922 {
923 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
924 let __vi = *__vt.get(27usize).unwrap_or_else(|| {
925 panic!(
926 "unity: virtual slot {}
927 out of range (vtable len {}
928) on the runtime class behind {}
929 (method `{}
930`)",
931 27usize,
932 __vt.len(),
933 <Hashtable as ::unity::ClassIdentity>::NAME,
934 "CopyTo",
935 )
936 });
937 let __inner: extern "C" fn(Hashtable, ::unity::IlInstance, i32, ::unity::OptionalMethod) -> () =
938 ::core::mem::transmute(__vi.method_ptr);
939 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
940 __inner(
941 __receiver,
942 ::core::convert::Into::into(array),
943 ::core::convert::Into::into(array_index),
944 __mi,
945 )
946 }
947 }
948 }
949 #[doc = "`CopyValues(::unity::IlInstance, i32)` overload"]
950 fn copy_values(self, array: impl ::core::convert::Into<::unity::IlInstance>, array_index: impl ::core::convert::Into<i32>) -> () {
951 unsafe {
952 let __receiver = <Hashtable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
953 ::unity::il2cpp_call!((::unity::module_base()+0x381f940usize)as*mut u8,();
954(Hashtable)__receiver,(::unity::IlInstance)::core::convert::Into::into(array),(i32)::core::convert::Into::into(array_index))
955 }
956 }
957 #[doc = "`get_Item(crate::system::object::Object)` overload"]
958 fn get_item(self, key: impl ::core::convert::Into<crate::system::object::Object>) -> crate::system::object::Object {
959 unsafe {
960 let __receiver = <Hashtable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
961 {
962 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
963 let __vi = *__vt.get(28usize).unwrap_or_else(|| {
964 panic!(
965 "unity: virtual slot {}
966 out of range (vtable len {}
967) on the runtime class behind {}
968 (method `{}
969`)",
970 28usize,
971 __vt.len(),
972 <Hashtable as ::unity::ClassIdentity>::NAME,
973 "get_Item",
974 )
975 });
976 let __inner: extern "C" fn(Hashtable, crate::system::object::Object, ::unity::OptionalMethod) -> crate::system::object::Object =
977 ::core::mem::transmute(__vi.method_ptr);
978 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
979 __inner(__receiver, ::core::convert::Into::into(key), __mi)
980 }
981 }
982 }
983 #[doc = "`set_Item(crate::system::object::Object, crate::system::object::Object)` overload"]
984 fn set_item(
985 self,
986 key: impl ::core::convert::Into<crate::system::object::Object>,
987 value: impl ::core::convert::Into<crate::system::object::Object>,
988 ) -> () {
989 unsafe {
990 let __receiver = <Hashtable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
991 {
992 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
993 let __vi = *__vt.get(29usize).unwrap_or_else(|| {
994 panic!(
995 "unity: virtual slot {}
996 out of range (vtable len {}
997) on the runtime class behind {}
998 (method `{}
999`)",
1000 29usize,
1001 __vt.len(),
1002 <Hashtable as ::unity::ClassIdentity>::NAME,
1003 "set_Item",
1004 )
1005 });
1006 let __inner: extern "C" fn(Hashtable, crate::system::object::Object, crate::system::object::Object, ::unity::OptionalMethod) -> () =
1007 ::core::mem::transmute(__vi.method_ptr);
1008 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1009 __inner(__receiver, ::core::convert::Into::into(key), ::core::convert::Into::into(value), __mi)
1010 }
1011 }
1012 }
1013 #[doc = "`expand()` overload"]
1014 fn expand(self) -> () {
1015 unsafe {
1016 let __receiver = <Hashtable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1017 ::unity::il2cpp_call!((::unity::module_base()+0x381fc30usize)as*mut u8,();
1018(Hashtable)__receiver)
1019 }
1020 }
1021 #[doc = "`rehash()` overload"]
1022 fn rehash(self) -> () {
1023 unsafe {
1024 let __receiver = <Hashtable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1025 ::unity::il2cpp_call!((::unity::module_base()+0x381ff20usize)as*mut u8,();
1026(Hashtable)__receiver)
1027 }
1028 }
1029 #[doc = "`UpdateVersion()` overload"]
1030 fn update_version(self) -> () {
1031 unsafe {
1032 let __receiver = <Hashtable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1033 ::unity::il2cpp_call!((::unity::module_base()+0x381f300usize)as*mut u8,();
1034(Hashtable)__receiver)
1035 }
1036 }
1037 #[doc = "`rehash(i32, bool)` overload"]
1038 fn rehash_2(self, newsize: impl ::core::convert::Into<i32>, force_new_hash_code: impl ::core::convert::Into<bool>) -> () {
1039 unsafe {
1040 let __receiver = <Hashtable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1041 ::unity::il2cpp_call!((::unity::module_base()+0x381fd30usize)as*mut u8,();
1042(Hashtable)__receiver,(i32)::core::convert::Into::into(newsize),(bool)::core::convert::Into::into(force_new_hash_code))
1043 }
1044 }
1045 #[doc = "`System.Collections.IEnumerable.GetEnumerator()` overload"]
1046 fn system_collections_i_enumerable_get_enumerator(self) -> crate::system::collections::ienumerator::IEnumerator {
1047 unsafe {
1048 let __receiver = <Hashtable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1049 {
1050 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1051 let __vi = *__vt.get(18usize).unwrap_or_else(|| {
1052 panic!(
1053 "unity: virtual slot {}
1054 out of range (vtable len {}
1055) on the runtime class behind {}
1056 (method `{}
1057`)",
1058 18usize,
1059 __vt.len(),
1060 <Hashtable as ::unity::ClassIdentity>::NAME,
1061 "System.Collections.IEnumerable.GetEnumerator",
1062 )
1063 });
1064 let __inner: extern "C" fn(Hashtable, ::unity::OptionalMethod) -> crate::system::collections::ienumerator::IEnumerator =
1065 ::core::mem::transmute(__vi.method_ptr);
1066 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1067 __inner(__receiver, __mi)
1068 }
1069 }
1070 }
1071 #[doc = "`GetEnumerator()` overload"]
1072 fn get_enumerator(self) -> crate::system::collections::idictionaryenumerator::IDictionaryEnumerator {
1073 unsafe {
1074 let __receiver = <Hashtable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1075 {
1076 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1077 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
1078 panic!(
1079 "unity: virtual slot {}
1080 out of range (vtable len {}
1081) on the runtime class behind {}
1082 (method `{}
1083`)",
1084 30usize,
1085 __vt.len(),
1086 <Hashtable as ::unity::ClassIdentity>::NAME,
1087 "GetEnumerator",
1088 )
1089 });
1090 let __inner: extern "C" fn(
1091 Hashtable,
1092 ::unity::OptionalMethod,
1093 ) -> crate::system::collections::idictionaryenumerator::IDictionaryEnumerator = ::core::mem::transmute(__vi.method_ptr);
1094 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1095 __inner(__receiver, __mi)
1096 }
1097 }
1098 }
1099 #[doc = "`GetHash(crate::system::object::Object)` overload"]
1100 fn get_hash(self, key: impl ::core::convert::Into<crate::system::object::Object>) -> i32 {
1101 unsafe {
1102 let __receiver = <Hashtable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1103 {
1104 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1105 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
1106 panic!(
1107 "unity: virtual slot {}
1108 out of range (vtable len {}
1109) on the runtime class behind {}
1110 (method `{}
1111`)",
1112 31usize,
1113 __vt.len(),
1114 <Hashtable as ::unity::ClassIdentity>::NAME,
1115 "GetHash",
1116 )
1117 });
1118 let __inner: extern "C" fn(Hashtable, crate::system::object::Object, ::unity::OptionalMethod) -> i32 =
1119 ::core::mem::transmute(__vi.method_ptr);
1120 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1121 __inner(__receiver, ::core::convert::Into::into(key), __mi)
1122 }
1123 }
1124 }
1125 #[doc = "`get_IsReadOnly()` overload"]
1126 fn get_is_read_only(self) -> bool {
1127 unsafe {
1128 let __receiver = <Hashtable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1129 {
1130 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1131 let __vi = *__vt.get(32usize).unwrap_or_else(|| {
1132 panic!(
1133 "unity: virtual slot {}
1134 out of range (vtable len {}
1135) on the runtime class behind {}
1136 (method `{}
1137`)",
1138 32usize,
1139 __vt.len(),
1140 <Hashtable as ::unity::ClassIdentity>::NAME,
1141 "get_IsReadOnly",
1142 )
1143 });
1144 let __inner: extern "C" fn(Hashtable, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
1145 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1146 __inner(__receiver, __mi)
1147 }
1148 }
1149 }
1150 #[doc = "`get_IsFixedSize()` overload"]
1151 fn get_is_fixed_size(self) -> bool {
1152 unsafe {
1153 let __receiver = <Hashtable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1154 {
1155 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1156 let __vi = *__vt.get(33usize).unwrap_or_else(|| {
1157 panic!(
1158 "unity: virtual slot {}
1159 out of range (vtable len {}
1160) on the runtime class behind {}
1161 (method `{}
1162`)",
1163 33usize,
1164 __vt.len(),
1165 <Hashtable as ::unity::ClassIdentity>::NAME,
1166 "get_IsFixedSize",
1167 )
1168 });
1169 let __inner: extern "C" fn(Hashtable, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
1170 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1171 __inner(__receiver, __mi)
1172 }
1173 }
1174 }
1175 #[doc = "`get_IsSynchronized()` overload"]
1176 fn get_is_synchronized(self) -> bool {
1177 unsafe {
1178 let __receiver = <Hashtable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1179 {
1180 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1181 let __vi = *__vt.get(34usize).unwrap_or_else(|| {
1182 panic!(
1183 "unity: virtual slot {}
1184 out of range (vtable len {}
1185) on the runtime class behind {}
1186 (method `{}
1187`)",
1188 34usize,
1189 __vt.len(),
1190 <Hashtable as ::unity::ClassIdentity>::NAME,
1191 "get_IsSynchronized",
1192 )
1193 });
1194 let __inner: extern "C" fn(Hashtable, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
1195 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1196 __inner(__receiver, __mi)
1197 }
1198 }
1199 }
1200 #[doc = "`KeyEquals(crate::system::object::Object, crate::system::object::Object)` overload"]
1201 fn key_equals(
1202 self,
1203 item: impl ::core::convert::Into<crate::system::object::Object>,
1204 key: impl ::core::convert::Into<crate::system::object::Object>,
1205 ) -> bool {
1206 unsafe {
1207 let __receiver = <Hashtable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1208 {
1209 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1210 let __vi = *__vt.get(35usize).unwrap_or_else(|| {
1211 panic!(
1212 "unity: virtual slot {}
1213 out of range (vtable len {}
1214) on the runtime class behind {}
1215 (method `{}
1216`)",
1217 35usize,
1218 __vt.len(),
1219 <Hashtable as ::unity::ClassIdentity>::NAME,
1220 "KeyEquals",
1221 )
1222 });
1223 let __inner: extern "C" fn(Hashtable, crate::system::object::Object, crate::system::object::Object, ::unity::OptionalMethod) -> bool =
1224 ::core::mem::transmute(__vi.method_ptr);
1225 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1226 __inner(__receiver, ::core::convert::Into::into(item), ::core::convert::Into::into(key), __mi)
1227 }
1228 }
1229 }
1230 #[doc = "`get_Keys()` overload"]
1231 fn get_keys(self) -> crate::system::collections::icollection::ICollection {
1232 unsafe {
1233 let __receiver = <Hashtable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1234 {
1235 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1236 let __vi = *__vt.get(36usize).unwrap_or_else(|| {
1237 panic!(
1238 "unity: virtual slot {}
1239 out of range (vtable len {}
1240) on the runtime class behind {}
1241 (method `{}
1242`)",
1243 36usize,
1244 __vt.len(),
1245 <Hashtable as ::unity::ClassIdentity>::NAME,
1246 "get_Keys",
1247 )
1248 });
1249 let __inner: extern "C" fn(Hashtable, ::unity::OptionalMethod) -> crate::system::collections::icollection::ICollection =
1250 ::core::mem::transmute(__vi.method_ptr);
1251 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1252 __inner(__receiver, __mi)
1253 }
1254 }
1255 }
1256 #[doc = "`get_Values()` overload"]
1257 fn get_values(self) -> crate::system::collections::icollection::ICollection {
1258 unsafe {
1259 let __receiver = <Hashtable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1260 {
1261 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1262 let __vi = *__vt.get(37usize).unwrap_or_else(|| {
1263 panic!(
1264 "unity: virtual slot {}
1265 out of range (vtable len {}
1266) on the runtime class behind {}
1267 (method `{}
1268`)",
1269 37usize,
1270 __vt.len(),
1271 <Hashtable as ::unity::ClassIdentity>::NAME,
1272 "get_Values",
1273 )
1274 });
1275 let __inner: extern "C" fn(Hashtable, ::unity::OptionalMethod) -> crate::system::collections::icollection::ICollection =
1276 ::core::mem::transmute(__vi.method_ptr);
1277 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1278 __inner(__receiver, __mi)
1279 }
1280 }
1281 }
1282 #[doc = "`Insert(crate::system::object::Object, crate::system::object::Object, bool)` overload"]
1283 fn insert(
1284 self,
1285 key: impl ::core::convert::Into<crate::system::object::Object>,
1286 nvalue: impl ::core::convert::Into<crate::system::object::Object>,
1287 add: impl ::core::convert::Into<bool>,
1288 ) -> () {
1289 unsafe {
1290 let __receiver = <Hashtable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1291 ::unity::il2cpp_call!((::unity::module_base()+0x381ed30usize)as*mut u8,();
1292(Hashtable)__receiver,(crate::system::object::Object)::core::convert::Into::into(key),(crate::system::object::Object)::core::convert::Into::into(nvalue),(bool)::core::convert::Into::into(add))
1293 }
1294 }
1295 #[doc = "`putEntry(::unity::Array<crate::system::collections::hashtable::Hashtable_bucket>, crate::system::object::Object, crate::system::object::Object, i32)` overload"]
1296 fn put_entry(
1297 self,
1298 new_buckets: impl ::core::convert::Into<::unity::Array<crate::system::collections::hashtable::Hashtable_bucket>>,
1299 key: impl ::core::convert::Into<crate::system::object::Object>,
1300 nvalue: impl ::core::convert::Into<crate::system::object::Object>,
1301 hashcode: impl ::core::convert::Into<i32>,
1302 ) -> () {
1303 unsafe {
1304 let __receiver = <Hashtable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1305 ::unity::il2cpp_call!((::unity::module_base()+0x381ff30usize)as*mut u8,();
1306(Hashtable)__receiver,(::unity::Array<crate::system::collections::hashtable::Hashtable_bucket>)::core::convert::Into::into(new_buckets),(crate::system::object::Object)::core::convert::Into::into(key),(crate::system::object::Object)::core::convert::Into::into(nvalue),(i32)::core::convert::Into::into(hashcode))
1307 }
1308 }
1309 #[doc = "`Remove(crate::system::object::Object)` overload"]
1310 fn remove(self, key: impl ::core::convert::Into<crate::system::object::Object>) -> () {
1311 unsafe {
1312 let __receiver = <Hashtable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1313 {
1314 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1315 let __vi = *__vt.get(38usize).unwrap_or_else(|| {
1316 panic!(
1317 "unity: virtual slot {}
1318 out of range (vtable len {}
1319) on the runtime class behind {}
1320 (method `{}
1321`)",
1322 38usize,
1323 __vt.len(),
1324 <Hashtable as ::unity::ClassIdentity>::NAME,
1325 "Remove",
1326 )
1327 });
1328 let __inner: extern "C" fn(Hashtable, crate::system::object::Object, ::unity::OptionalMethod) -> () =
1329 ::core::mem::transmute(__vi.method_ptr);
1330 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1331 __inner(__receiver, ::core::convert::Into::into(key), __mi)
1332 }
1333 }
1334 }
1335 #[doc = "`get_SyncRoot()` overload"]
1336 fn get_sync_root(self) -> crate::system::object::Object {
1337 unsafe {
1338 let __receiver = <Hashtable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1339 {
1340 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1341 let __vi = *__vt.get(39usize).unwrap_or_else(|| {
1342 panic!(
1343 "unity: virtual slot {}
1344 out of range (vtable len {}
1345) on the runtime class behind {}
1346 (method `{}
1347`)",
1348 39usize,
1349 __vt.len(),
1350 <Hashtable as ::unity::ClassIdentity>::NAME,
1351 "get_SyncRoot",
1352 )
1353 });
1354 let __inner: extern "C" fn(Hashtable, ::unity::OptionalMethod) -> crate::system::object::Object =
1355 ::core::mem::transmute(__vi.method_ptr);
1356 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1357 __inner(__receiver, __mi)
1358 }
1359 }
1360 }
1361 #[doc = "`get_Count()` overload"]
1362 fn get_count(self) -> i32 {
1363 unsafe {
1364 let __receiver = <Hashtable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1365 {
1366 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1367 let __vi = *__vt.get(40usize).unwrap_or_else(|| {
1368 panic!(
1369 "unity: virtual slot {}
1370 out of range (vtable len {}
1371) on the runtime class behind {}
1372 (method `{}
1373`)",
1374 40usize,
1375 __vt.len(),
1376 <Hashtable as ::unity::ClassIdentity>::NAME,
1377 "get_Count",
1378 )
1379 });
1380 let __inner: extern "C" fn(Hashtable, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__vi.method_ptr);
1381 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1382 __inner(__receiver, __mi)
1383 }
1384 }
1385 }
1386 #[doc = "`OnDeserialization(crate::system::object::Object)` overload"]
1387 fn on_deserialization(self, sender: impl ::core::convert::Into<crate::system::object::Object>) -> () {
1388 unsafe {
1389 let __receiver = <Hashtable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1390 {
1391 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1392 let __vi = *__vt.get(42usize).unwrap_or_else(|| {
1393 panic!(
1394 "unity: virtual slot {}
1395 out of range (vtable len {}
1396) on the runtime class behind {}
1397 (method `{}
1398`)",
1399 42usize,
1400 __vt.len(),
1401 <Hashtable as ::unity::ClassIdentity>::NAME,
1402 "OnDeserialization",
1403 )
1404 });
1405 let __inner: extern "C" fn(Hashtable, crate::system::object::Object, ::unity::OptionalMethod) -> () =
1406 ::core::mem::transmute(__vi.method_ptr);
1407 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1408 __inner(__receiver, ::core::convert::Into::into(sender), __mi)
1409 }
1410 }
1411 }
1412}
1413
1414#[cfg(feature = "system-collections-hashtable")]
1415impl<__T: IHashtable> IHashtableMethods for __T {}
1416
1417#[cfg(feature = "system-collections-hashtable")]
1418impl Hashtable {
1419 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1420 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
1421 }
1422
1423 pub fn ctor_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1424 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
1425 }
1426
1427 pub fn ctor_3_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1428 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
1429 }
1430
1431 pub fn ctor_4_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1432 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
1433 }
1434
1435 pub fn ctor_5_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1436 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
1437 }
1438
1439 pub fn ctor_6_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1440 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
1441 }
1442
1443 pub fn ctor_7_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1444 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
1445 }
1446
1447 pub fn ctor_8_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1448 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
1449 }
1450
1451 pub fn ctor_9_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1452 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[8]
1453 }
1454
1455 pub fn init_hash_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1456 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[10]
1457 }
1458
1459 pub fn add_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1460 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[11]
1461 }
1462
1463 pub fn clear_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1464 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[12]
1465 }
1466
1467 pub fn clone_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1468 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[13]
1469 }
1470
1471 pub fn contains_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1472 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[14]
1473 }
1474
1475 pub fn contains_key_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1476 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[15]
1477 }
1478
1479 pub fn copy_keys_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1480 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[16]
1481 }
1482
1483 pub fn copy_entries_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1484 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[17]
1485 }
1486
1487 pub fn copy_to_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1488 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[18]
1489 }
1490
1491 pub fn copy_values_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1492 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[19]
1493 }
1494
1495 pub fn get_item_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1496 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[20]
1497 }
1498
1499 pub fn set_item_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1500 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[21]
1501 }
1502
1503 pub fn expand_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1504 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[22]
1505 }
1506
1507 pub fn rehash_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1508 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[23]
1509 }
1510
1511 pub fn update_version_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1512 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[24]
1513 }
1514
1515 pub fn rehash_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1516 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[25]
1517 }
1518
1519 pub fn system_collections_i_enumerable_get_enumerator_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1520 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[26]
1521 }
1522
1523 pub fn get_enumerator_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1524 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[27]
1525 }
1526
1527 pub fn get_hash_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1528 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[28]
1529 }
1530
1531 pub fn get_is_read_only_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1532 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[29]
1533 }
1534
1535 pub fn get_is_fixed_size_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1536 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[30]
1537 }
1538
1539 pub fn get_is_synchronized_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1540 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[31]
1541 }
1542
1543 pub fn key_equals_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1544 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[32]
1545 }
1546
1547 pub fn get_keys_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1548 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[33]
1549 }
1550
1551 pub fn get_values_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1552 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[34]
1553 }
1554
1555 pub fn insert_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1556 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[35]
1557 }
1558
1559 pub fn put_entry_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1560 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[36]
1561 }
1562
1563 pub fn remove_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1564 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[37]
1565 }
1566
1567 pub fn get_sync_root_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1568 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[38]
1569 }
1570
1571 pub fn get_count_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1572 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[39]
1573 }
1574
1575 pub fn synchronized_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1576 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[40]
1577 }
1578
1579 pub fn on_deserialization_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1580 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[42]
1581 }
1582}
1583
1584#[cfg(feature = "system-collections-hashtable")]
1585impl Hashtable {
1586 #[doc = "Direct (non-virtual) call to `Hashtable`'s own `Add`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1587 pub unsafe fn add(
1588 this: impl ::core::convert::Into<::unity::IlInstance>,
1589 key: crate::system::object::Object,
1590 value: crate::system::object::Object,
1591 ) -> () {
1592 let __mi = Self::add_method_info();
1593 let __inner: extern "C" fn(::unity::IlInstance, crate::system::object::Object, crate::system::object::Object, ::unity::OptionalMethod) -> () =
1594 ::core::mem::transmute(__mi.method_ptr);
1595 __inner(this.into(), key, value, ::core::option::Option::None)
1596 }
1597
1598 #[doc = "Direct (non-virtual) call to `Hashtable`'s own `Clear`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1599 pub unsafe fn clear(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
1600 let __mi = Self::clear_method_info();
1601 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
1602 __inner(this.into(), ::core::option::Option::None)
1603 }
1604
1605 #[doc = "Direct (non-virtual) call to `Hashtable`'s own `Clone`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1606 pub unsafe fn clone(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::system::object::Object {
1607 let __mi = Self::clone_method_info();
1608 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::system::object::Object =
1609 ::core::mem::transmute(__mi.method_ptr);
1610 __inner(this.into(), ::core::option::Option::None)
1611 }
1612
1613 #[doc = "Direct (non-virtual) call to `Hashtable`'s own `Contains`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1614 pub unsafe fn contains(this: impl ::core::convert::Into<::unity::IlInstance>, key: crate::system::object::Object) -> bool {
1615 let __mi = Self::contains_method_info();
1616 let __inner: extern "C" fn(::unity::IlInstance, crate::system::object::Object, ::unity::OptionalMethod) -> bool =
1617 ::core::mem::transmute(__mi.method_ptr);
1618 __inner(this.into(), key, ::core::option::Option::None)
1619 }
1620
1621 #[doc = "Direct (non-virtual) call to `Hashtable`'s own `ContainsKey`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1622 pub unsafe fn contains_key(this: impl ::core::convert::Into<::unity::IlInstance>, key: crate::system::object::Object) -> bool {
1623 let __mi = Self::contains_key_method_info();
1624 let __inner: extern "C" fn(::unity::IlInstance, crate::system::object::Object, ::unity::OptionalMethod) -> bool =
1625 ::core::mem::transmute(__mi.method_ptr);
1626 __inner(this.into(), key, ::core::option::Option::None)
1627 }
1628
1629 #[doc = "Direct (non-virtual) call to `Hashtable`'s own `CopyTo`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1630 pub unsafe fn copy_to(this: impl ::core::convert::Into<::unity::IlInstance>, array: ::unity::IlInstance, array_index: i32) -> () {
1631 let __mi = Self::copy_to_method_info();
1632 let __inner: extern "C" fn(::unity::IlInstance, ::unity::IlInstance, i32, ::unity::OptionalMethod) -> () =
1633 ::core::mem::transmute(__mi.method_ptr);
1634 __inner(this.into(), array, array_index, ::core::option::Option::None)
1635 }
1636
1637 #[doc = "Direct (non-virtual) call to `Hashtable`'s own `get_Item`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1638 pub unsafe fn get_item(
1639 this: impl ::core::convert::Into<::unity::IlInstance>,
1640 key: crate::system::object::Object,
1641 ) -> crate::system::object::Object {
1642 let __mi = Self::get_item_method_info();
1643 let __inner: extern "C" fn(::unity::IlInstance, crate::system::object::Object, ::unity::OptionalMethod) -> crate::system::object::Object =
1644 ::core::mem::transmute(__mi.method_ptr);
1645 __inner(this.into(), key, ::core::option::Option::None)
1646 }
1647
1648 #[doc = "Direct (non-virtual) call to `Hashtable`'s own `set_Item`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1649 pub unsafe fn set_item(
1650 this: impl ::core::convert::Into<::unity::IlInstance>,
1651 key: crate::system::object::Object,
1652 value: crate::system::object::Object,
1653 ) -> () {
1654 let __mi = Self::set_item_method_info();
1655 let __inner: extern "C" fn(::unity::IlInstance, crate::system::object::Object, crate::system::object::Object, ::unity::OptionalMethod) -> () =
1656 ::core::mem::transmute(__mi.method_ptr);
1657 __inner(this.into(), key, value, ::core::option::Option::None)
1658 }
1659
1660 #[doc = "Direct (non-virtual) call to `Hashtable`'s own `System.Collections.IEnumerable.GetEnumerator`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1661 pub unsafe fn system_collections_i_enumerable_get_enumerator(
1662 this: impl ::core::convert::Into<::unity::IlInstance>,
1663 ) -> crate::system::collections::ienumerator::IEnumerator {
1664 let __mi = Self::system_collections_i_enumerable_get_enumerator_method_info();
1665 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::system::collections::ienumerator::IEnumerator =
1666 ::core::mem::transmute(__mi.method_ptr);
1667 __inner(this.into(), ::core::option::Option::None)
1668 }
1669
1670 #[doc = "Direct (non-virtual) call to `Hashtable`'s own `GetEnumerator`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1671 pub unsafe fn get_enumerator(
1672 this: impl ::core::convert::Into<::unity::IlInstance>,
1673 ) -> crate::system::collections::idictionaryenumerator::IDictionaryEnumerator {
1674 let __mi = Self::get_enumerator_method_info();
1675 let __inner: extern "C" fn(
1676 ::unity::IlInstance,
1677 ::unity::OptionalMethod,
1678 ) -> crate::system::collections::idictionaryenumerator::IDictionaryEnumerator = ::core::mem::transmute(__mi.method_ptr);
1679 __inner(this.into(), ::core::option::Option::None)
1680 }
1681
1682 #[doc = "Direct (non-virtual) call to `Hashtable`'s own `GetHash`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1683 pub unsafe fn get_hash(this: impl ::core::convert::Into<::unity::IlInstance>, key: crate::system::object::Object) -> i32 {
1684 let __mi = Self::get_hash_method_info();
1685 let __inner: extern "C" fn(::unity::IlInstance, crate::system::object::Object, ::unity::OptionalMethod) -> i32 =
1686 ::core::mem::transmute(__mi.method_ptr);
1687 __inner(this.into(), key, ::core::option::Option::None)
1688 }
1689
1690 #[doc = "Direct (non-virtual) call to `Hashtable`'s own `get_IsReadOnly`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1691 pub unsafe fn get_is_read_only(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
1692 let __mi = Self::get_is_read_only_method_info();
1693 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
1694 __inner(this.into(), ::core::option::Option::None)
1695 }
1696
1697 #[doc = "Direct (non-virtual) call to `Hashtable`'s own `get_IsFixedSize`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1698 pub unsafe fn get_is_fixed_size(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
1699 let __mi = Self::get_is_fixed_size_method_info();
1700 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
1701 __inner(this.into(), ::core::option::Option::None)
1702 }
1703
1704 #[doc = "Direct (non-virtual) call to `Hashtable`'s own `get_IsSynchronized`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1705 pub unsafe fn get_is_synchronized(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
1706 let __mi = Self::get_is_synchronized_method_info();
1707 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
1708 __inner(this.into(), ::core::option::Option::None)
1709 }
1710
1711 #[doc = "Direct (non-virtual) call to `Hashtable`'s own `KeyEquals`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1712 pub unsafe fn key_equals(
1713 this: impl ::core::convert::Into<::unity::IlInstance>,
1714 item: crate::system::object::Object,
1715 key: crate::system::object::Object,
1716 ) -> bool {
1717 let __mi = Self::key_equals_method_info();
1718 let __inner: extern "C" fn(
1719 ::unity::IlInstance,
1720 crate::system::object::Object,
1721 crate::system::object::Object,
1722 ::unity::OptionalMethod,
1723 ) -> bool = ::core::mem::transmute(__mi.method_ptr);
1724 __inner(this.into(), item, key, ::core::option::Option::None)
1725 }
1726
1727 #[doc = "Direct (non-virtual) call to `Hashtable`'s own `get_Keys`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1728 pub unsafe fn get_keys(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::system::collections::icollection::ICollection {
1729 let __mi = Self::get_keys_method_info();
1730 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::system::collections::icollection::ICollection =
1731 ::core::mem::transmute(__mi.method_ptr);
1732 __inner(this.into(), ::core::option::Option::None)
1733 }
1734
1735 #[doc = "Direct (non-virtual) call to `Hashtable`'s own `get_Values`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1736 pub unsafe fn get_values(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::system::collections::icollection::ICollection {
1737 let __mi = Self::get_values_method_info();
1738 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::system::collections::icollection::ICollection =
1739 ::core::mem::transmute(__mi.method_ptr);
1740 __inner(this.into(), ::core::option::Option::None)
1741 }
1742
1743 #[doc = "Direct (non-virtual) call to `Hashtable`'s own `Remove`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1744 pub unsafe fn remove(this: impl ::core::convert::Into<::unity::IlInstance>, key: crate::system::object::Object) -> () {
1745 let __mi = Self::remove_method_info();
1746 let __inner: extern "C" fn(::unity::IlInstance, crate::system::object::Object, ::unity::OptionalMethod) -> () =
1747 ::core::mem::transmute(__mi.method_ptr);
1748 __inner(this.into(), key, ::core::option::Option::None)
1749 }
1750
1751 #[doc = "Direct (non-virtual) call to `Hashtable`'s own `get_SyncRoot`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1752 pub unsafe fn get_sync_root(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::system::object::Object {
1753 let __mi = Self::get_sync_root_method_info();
1754 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::system::object::Object =
1755 ::core::mem::transmute(__mi.method_ptr);
1756 __inner(this.into(), ::core::option::Option::None)
1757 }
1758
1759 #[doc = "Direct (non-virtual) call to `Hashtable`'s own `get_Count`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1760 pub unsafe fn get_count(this: impl ::core::convert::Into<::unity::IlInstance>) -> i32 {
1761 let __mi = Self::get_count_method_info();
1762 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__mi.method_ptr);
1763 __inner(this.into(), ::core::option::Option::None)
1764 }
1765
1766 #[doc = "Direct (non-virtual) call to `Hashtable`'s own `OnDeserialization`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1767 pub unsafe fn on_deserialization(this: impl ::core::convert::Into<::unity::IlInstance>, sender: crate::system::object::Object) -> () {
1768 let __mi = Self::on_deserialization_method_info();
1769 let __inner: extern "C" fn(::unity::IlInstance, crate::system::object::Object, ::unity::OptionalMethod) -> () =
1770 ::core::mem::transmute(__mi.method_ptr);
1771 __inner(this.into(), sender, ::core::option::Option::None)
1772 }
1773}
1774
1775#[cfg(feature = "system-collections-hashtable")]
1776impl Hashtable {
1777 #[doc = "`.ctor(bool)` — overload selector"]
1778 pub fn new(trash: bool) -> Self {
1779 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1780 panic!(
1781 "{}
1782::{}
1783 failed to instantiate",
1784 ::core::stringify!(Hashtable),
1785 ::core::stringify!(new),
1786 )
1787 });
1788 <Self as IHashtableMethods>::ctor(this, trash);
1789 this
1790 }
1791
1792 #[doc = "`.ctor()` — no args"]
1793 pub fn new_2() -> Self {
1794 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1795 panic!(
1796 "{}
1797::{}
1798 failed to instantiate",
1799 ::core::stringify!(Hashtable),
1800 ::core::stringify!(new_2),
1801 )
1802 });
1803 <Self as IHashtableMethods>::ctor_2(this);
1804 this
1805 }
1806
1807 #[doc = "`.ctor(i32)` — overload selector"]
1808 pub fn new_3(capacity: i32) -> Self {
1809 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1810 panic!(
1811 "{}
1812::{}
1813 failed to instantiate",
1814 ::core::stringify!(Hashtable),
1815 ::core::stringify!(new_3),
1816 )
1817 });
1818 <Self as IHashtableMethods>::ctor_3(this, capacity);
1819 this
1820 }
1821
1822 #[doc = "`.ctor(i32, f32)` — overload selector"]
1823 pub fn new_4(capacity: i32, load_factor: f32) -> Self {
1824 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1825 panic!(
1826 "{}
1827::{}
1828 failed to instantiate",
1829 ::core::stringify!(Hashtable),
1830 ::core::stringify!(new_4),
1831 )
1832 });
1833 <Self as IHashtableMethods>::ctor_4(this, capacity, load_factor);
1834 this
1835 }
1836
1837 #[doc = "`.ctor(i32, f32, crate::system::collections::ihashcodeprovider::IHashCodeProvider, crate::system::collections::icomparer_interface::IComparer_Interface)` — overload selector"]
1838 pub fn new_5(
1839 capacity: i32,
1840 load_factor: f32,
1841 hcp: crate::system::collections::ihashcodeprovider::IHashCodeProvider,
1842 comparer: crate::system::collections::icomparer_interface::IComparer_Interface,
1843 ) -> Self {
1844 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1845 panic!(
1846 "{}
1847::{}
1848 failed to instantiate",
1849 ::core::stringify!(Hashtable),
1850 ::core::stringify!(new_5),
1851 )
1852 });
1853 <Self as IHashtableMethods>::ctor_5(this, capacity, load_factor, hcp, comparer);
1854 this
1855 }
1856
1857 #[doc = "`.ctor(i32, f32, crate::system::collections::iequalitycomparer::IEqualityComparer)` — overload selector"]
1858 pub fn new_6(capacity: i32, load_factor: f32, equality_comparer: crate::system::collections::iequalitycomparer::IEqualityComparer) -> Self {
1859 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1860 panic!(
1861 "{}
1862::{}
1863 failed to instantiate",
1864 ::core::stringify!(Hashtable),
1865 ::core::stringify!(new_6),
1866 )
1867 });
1868 <Self as IHashtableMethods>::ctor_6(this, capacity, load_factor, equality_comparer);
1869 this
1870 }
1871
1872 #[doc = "`.ctor(crate::system::collections::ihashcodeprovider::IHashCodeProvider, crate::system::collections::icomparer_interface::IComparer_Interface)` — overload selector"]
1873 pub fn new_7(
1874 hcp: crate::system::collections::ihashcodeprovider::IHashCodeProvider,
1875 comparer: crate::system::collections::icomparer_interface::IComparer_Interface,
1876 ) -> Self {
1877 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1878 panic!(
1879 "{}
1880::{}
1881 failed to instantiate",
1882 ::core::stringify!(Hashtable),
1883 ::core::stringify!(new_7),
1884 )
1885 });
1886 <Self as IHashtableMethods>::ctor_7(this, hcp, comparer);
1887 this
1888 }
1889
1890 #[doc = "`.ctor(crate::system::collections::iequalitycomparer::IEqualityComparer)` — overload selector"]
1891 pub fn new_8(equality_comparer: crate::system::collections::iequalitycomparer::IEqualityComparer) -> Self {
1892 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1893 panic!(
1894 "{}
1895::{}
1896 failed to instantiate",
1897 ::core::stringify!(Hashtable),
1898 ::core::stringify!(new_8),
1899 )
1900 });
1901 <Self as IHashtableMethods>::ctor_8(this, equality_comparer);
1902 this
1903 }
1904
1905 #[doc = "`.ctor(i32, crate::system::collections::iequalitycomparer::IEqualityComparer)` — overload selector"]
1906 pub fn new_9(capacity: i32, equality_comparer: crate::system::collections::iequalitycomparer::IEqualityComparer) -> Self {
1907 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1908 panic!(
1909 "{}
1910::{}
1911 failed to instantiate",
1912 ::core::stringify!(Hashtable),
1913 ::core::stringify!(new_9),
1914 )
1915 });
1916 <Self as IHashtableMethods>::ctor_9(this, capacity, equality_comparer);
1917 this
1918 }
1919}
1920
1921#[cfg(feature = "system-collections-hashtable")]
1922pub trait IHashtable_SyncHashtableMethods: IHashtable_SyncHashtable {
1923 #[doc = "`.ctor(crate::system::collections::hashtable::Hashtable)` overload"]
1924 fn ctor(self, table: impl ::core::convert::Into<crate::system::collections::hashtable::Hashtable>) -> () {
1925 unsafe {
1926 let __receiver =
1927 <Hashtable_SyncHashtable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1928 ::unity::il2cpp_call!((::unity::module_base()+0x34d78c0usize)as*mut u8,();
1929(Hashtable_SyncHashtable)__receiver,(crate::system::collections::hashtable::Hashtable)::core::convert::Into::into(table))
1930 }
1931 }
1932 #[doc = "`get_Count()` overload"]
1933 fn get_count(self) -> i32 {
1934 unsafe {
1935 let __receiver =
1936 <Hashtable_SyncHashtable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1937 {
1938 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1939 let __vi = *__vt.get(40usize).unwrap_or_else(|| {
1940 panic!(
1941 "unity: virtual slot {}
1942 out of range (vtable len {}
1943) on the runtime class behind {}
1944 (method `{}
1945`)",
1946 40usize,
1947 __vt.len(),
1948 <Hashtable_SyncHashtable as ::unity::ClassIdentity>::NAME,
1949 "get_Count",
1950 )
1951 });
1952 let __inner: extern "C" fn(Hashtable_SyncHashtable, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__vi.method_ptr);
1953 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1954 __inner(__receiver, __mi)
1955 }
1956 }
1957 }
1958 #[doc = "`get_IsReadOnly()` overload"]
1959 fn get_is_read_only(self) -> bool {
1960 unsafe {
1961 let __receiver =
1962 <Hashtable_SyncHashtable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1963 {
1964 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1965 let __vi = *__vt.get(32usize).unwrap_or_else(|| {
1966 panic!(
1967 "unity: virtual slot {}
1968 out of range (vtable len {}
1969) on the runtime class behind {}
1970 (method `{}
1971`)",
1972 32usize,
1973 __vt.len(),
1974 <Hashtable_SyncHashtable as ::unity::ClassIdentity>::NAME,
1975 "get_IsReadOnly",
1976 )
1977 });
1978 let __inner: extern "C" fn(Hashtable_SyncHashtable, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
1979 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1980 __inner(__receiver, __mi)
1981 }
1982 }
1983 }
1984 #[doc = "`get_IsFixedSize()` overload"]
1985 fn get_is_fixed_size(self) -> bool {
1986 unsafe {
1987 let __receiver =
1988 <Hashtable_SyncHashtable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1989 {
1990 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1991 let __vi = *__vt.get(33usize).unwrap_or_else(|| {
1992 panic!(
1993 "unity: virtual slot {}
1994 out of range (vtable len {}
1995) on the runtime class behind {}
1996 (method `{}
1997`)",
1998 33usize,
1999 __vt.len(),
2000 <Hashtable_SyncHashtable as ::unity::ClassIdentity>::NAME,
2001 "get_IsFixedSize",
2002 )
2003 });
2004 let __inner: extern "C" fn(Hashtable_SyncHashtable, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
2005 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2006 __inner(__receiver, __mi)
2007 }
2008 }
2009 }
2010 #[doc = "`get_IsSynchronized()` overload"]
2011 fn get_is_synchronized(self) -> bool {
2012 unsafe {
2013 let __receiver =
2014 <Hashtable_SyncHashtable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2015 {
2016 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2017 let __vi = *__vt.get(34usize).unwrap_or_else(|| {
2018 panic!(
2019 "unity: virtual slot {}
2020 out of range (vtable len {}
2021) on the runtime class behind {}
2022 (method `{}
2023`)",
2024 34usize,
2025 __vt.len(),
2026 <Hashtable_SyncHashtable as ::unity::ClassIdentity>::NAME,
2027 "get_IsSynchronized",
2028 )
2029 });
2030 let __inner: extern "C" fn(Hashtable_SyncHashtable, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
2031 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2032 __inner(__receiver, __mi)
2033 }
2034 }
2035 }
2036 #[doc = "`get_Item(crate::system::object::Object)` overload"]
2037 fn get_item(self, key: impl ::core::convert::Into<crate::system::object::Object>) -> crate::system::object::Object {
2038 unsafe {
2039 let __receiver =
2040 <Hashtable_SyncHashtable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2041 {
2042 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2043 let __vi = *__vt.get(28usize).unwrap_or_else(|| {
2044 panic!(
2045 "unity: virtual slot {}
2046 out of range (vtable len {}
2047) on the runtime class behind {}
2048 (method `{}
2049`)",
2050 28usize,
2051 __vt.len(),
2052 <Hashtable_SyncHashtable as ::unity::ClassIdentity>::NAME,
2053 "get_Item",
2054 )
2055 });
2056 let __inner: extern "C" fn(
2057 Hashtable_SyncHashtable,
2058 crate::system::object::Object,
2059 ::unity::OptionalMethod,
2060 ) -> crate::system::object::Object = ::core::mem::transmute(__vi.method_ptr);
2061 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2062 __inner(__receiver, ::core::convert::Into::into(key), __mi)
2063 }
2064 }
2065 }
2066 #[doc = "`set_Item(crate::system::object::Object, crate::system::object::Object)` overload"]
2067 fn set_item(
2068 self,
2069 key: impl ::core::convert::Into<crate::system::object::Object>,
2070 value: impl ::core::convert::Into<crate::system::object::Object>,
2071 ) -> () {
2072 unsafe {
2073 let __receiver =
2074 <Hashtable_SyncHashtable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2075 {
2076 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2077 let __vi = *__vt.get(29usize).unwrap_or_else(|| {
2078 panic!(
2079 "unity: virtual slot {}
2080 out of range (vtable len {}
2081) on the runtime class behind {}
2082 (method `{}
2083`)",
2084 29usize,
2085 __vt.len(),
2086 <Hashtable_SyncHashtable as ::unity::ClassIdentity>::NAME,
2087 "set_Item",
2088 )
2089 });
2090 let __inner: extern "C" fn(
2091 Hashtable_SyncHashtable,
2092 crate::system::object::Object,
2093 crate::system::object::Object,
2094 ::unity::OptionalMethod,
2095 ) -> () = ::core::mem::transmute(__vi.method_ptr);
2096 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2097 __inner(__receiver, ::core::convert::Into::into(key), ::core::convert::Into::into(value), __mi)
2098 }
2099 }
2100 }
2101 #[doc = "`get_SyncRoot()` overload"]
2102 fn get_sync_root(self) -> crate::system::object::Object {
2103 unsafe {
2104 let __receiver =
2105 <Hashtable_SyncHashtable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2106 {
2107 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2108 let __vi = *__vt.get(39usize).unwrap_or_else(|| {
2109 panic!(
2110 "unity: virtual slot {}
2111 out of range (vtable len {}
2112) on the runtime class behind {}
2113 (method `{}
2114`)",
2115 39usize,
2116 __vt.len(),
2117 <Hashtable_SyncHashtable as ::unity::ClassIdentity>::NAME,
2118 "get_SyncRoot",
2119 )
2120 });
2121 let __inner: extern "C" fn(Hashtable_SyncHashtable, ::unity::OptionalMethod) -> crate::system::object::Object =
2122 ::core::mem::transmute(__vi.method_ptr);
2123 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2124 __inner(__receiver, __mi)
2125 }
2126 }
2127 }
2128 #[doc = "`Add(crate::system::object::Object, crate::system::object::Object)` overload"]
2129 fn add(
2130 self,
2131 key: impl ::core::convert::Into<crate::system::object::Object>,
2132 value: impl ::core::convert::Into<crate::system::object::Object>,
2133 ) -> () {
2134 unsafe {
2135 let __receiver =
2136 <Hashtable_SyncHashtable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2137 {
2138 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2139 let __vi = *__vt.get(22usize).unwrap_or_else(|| {
2140 panic!(
2141 "unity: virtual slot {}
2142 out of range (vtable len {}
2143) on the runtime class behind {}
2144 (method `{}
2145`)",
2146 22usize,
2147 __vt.len(),
2148 <Hashtable_SyncHashtable as ::unity::ClassIdentity>::NAME,
2149 "Add",
2150 )
2151 });
2152 let __inner: extern "C" fn(
2153 Hashtable_SyncHashtable,
2154 crate::system::object::Object,
2155 crate::system::object::Object,
2156 ::unity::OptionalMethod,
2157 ) -> () = ::core::mem::transmute(__vi.method_ptr);
2158 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2159 __inner(__receiver, ::core::convert::Into::into(key), ::core::convert::Into::into(value), __mi)
2160 }
2161 }
2162 }
2163 #[doc = "`Clear()` overload"]
2164 fn clear(self) -> () {
2165 unsafe {
2166 let __receiver =
2167 <Hashtable_SyncHashtable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2168 {
2169 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2170 let __vi = *__vt.get(23usize).unwrap_or_else(|| {
2171 panic!(
2172 "unity: virtual slot {}
2173 out of range (vtable len {}
2174) on the runtime class behind {}
2175 (method `{}
2176`)",
2177 23usize,
2178 __vt.len(),
2179 <Hashtable_SyncHashtable as ::unity::ClassIdentity>::NAME,
2180 "Clear",
2181 )
2182 });
2183 let __inner: extern "C" fn(Hashtable_SyncHashtable, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
2184 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2185 __inner(__receiver, __mi)
2186 }
2187 }
2188 }
2189 #[doc = "`Contains(crate::system::object::Object)` overload"]
2190 fn contains(self, key: impl ::core::convert::Into<crate::system::object::Object>) -> bool {
2191 unsafe {
2192 let __receiver =
2193 <Hashtable_SyncHashtable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2194 {
2195 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2196 let __vi = *__vt.get(25usize).unwrap_or_else(|| {
2197 panic!(
2198 "unity: virtual slot {}
2199 out of range (vtable len {}
2200) on the runtime class behind {}
2201 (method `{}
2202`)",
2203 25usize,
2204 __vt.len(),
2205 <Hashtable_SyncHashtable as ::unity::ClassIdentity>::NAME,
2206 "Contains",
2207 )
2208 });
2209 let __inner: extern "C" fn(Hashtable_SyncHashtable, crate::system::object::Object, ::unity::OptionalMethod) -> bool =
2210 ::core::mem::transmute(__vi.method_ptr);
2211 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2212 __inner(__receiver, ::core::convert::Into::into(key), __mi)
2213 }
2214 }
2215 }
2216 #[doc = "`ContainsKey(crate::system::object::Object)` overload"]
2217 fn contains_key(self, key: impl ::core::convert::Into<crate::system::object::Object>) -> bool {
2218 unsafe {
2219 let __receiver =
2220 <Hashtable_SyncHashtable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2221 {
2222 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2223 let __vi = *__vt.get(26usize).unwrap_or_else(|| {
2224 panic!(
2225 "unity: virtual slot {}
2226 out of range (vtable len {}
2227) on the runtime class behind {}
2228 (method `{}
2229`)",
2230 26usize,
2231 __vt.len(),
2232 <Hashtable_SyncHashtable as ::unity::ClassIdentity>::NAME,
2233 "ContainsKey",
2234 )
2235 });
2236 let __inner: extern "C" fn(Hashtable_SyncHashtable, crate::system::object::Object, ::unity::OptionalMethod) -> bool =
2237 ::core::mem::transmute(__vi.method_ptr);
2238 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2239 __inner(__receiver, ::core::convert::Into::into(key), __mi)
2240 }
2241 }
2242 }
2243 #[doc = "`CopyTo(::unity::IlInstance, i32)` overload"]
2244 fn copy_to(self, array: impl ::core::convert::Into<::unity::IlInstance>, array_index: impl ::core::convert::Into<i32>) -> () {
2245 unsafe {
2246 let __receiver =
2247 <Hashtable_SyncHashtable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2248 {
2249 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2250 let __vi = *__vt.get(27usize).unwrap_or_else(|| {
2251 panic!(
2252 "unity: virtual slot {}
2253 out of range (vtable len {}
2254) on the runtime class behind {}
2255 (method `{}
2256`)",
2257 27usize,
2258 __vt.len(),
2259 <Hashtable_SyncHashtable as ::unity::ClassIdentity>::NAME,
2260 "CopyTo",
2261 )
2262 });
2263 let __inner: extern "C" fn(Hashtable_SyncHashtable, ::unity::IlInstance, i32, ::unity::OptionalMethod) -> () =
2264 ::core::mem::transmute(__vi.method_ptr);
2265 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2266 __inner(
2267 __receiver,
2268 ::core::convert::Into::into(array),
2269 ::core::convert::Into::into(array_index),
2270 __mi,
2271 )
2272 }
2273 }
2274 }
2275 #[doc = "`Clone()` overload"]
2276 fn clone(self) -> crate::system::object::Object {
2277 unsafe {
2278 let __receiver =
2279 <Hashtable_SyncHashtable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2280 {
2281 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2282 let __vi = *__vt.get(24usize).unwrap_or_else(|| {
2283 panic!(
2284 "unity: virtual slot {}
2285 out of range (vtable len {}
2286) on the runtime class behind {}
2287 (method `{}
2288`)",
2289 24usize,
2290 __vt.len(),
2291 <Hashtable_SyncHashtable as ::unity::ClassIdentity>::NAME,
2292 "Clone",
2293 )
2294 });
2295 let __inner: extern "C" fn(Hashtable_SyncHashtable, ::unity::OptionalMethod) -> crate::system::object::Object =
2296 ::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, __mi)
2299 }
2300 }
2301 }
2302 #[doc = "`System.Collections.IEnumerable.GetEnumerator()` overload"]
2303 fn system_collections_i_enumerable_get_enumerator(self) -> crate::system::collections::ienumerator::IEnumerator {
2304 unsafe {
2305 let __receiver =
2306 <Hashtable_SyncHashtable 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(18usize).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 18usize,
2317 __vt.len(),
2318 <Hashtable_SyncHashtable as ::unity::ClassIdentity>::NAME,
2319 "System.Collections.IEnumerable.GetEnumerator",
2320 )
2321 });
2322 let __inner: extern "C" fn(Hashtable_SyncHashtable, ::unity::OptionalMethod) -> crate::system::collections::ienumerator::IEnumerator =
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, __mi)
2326 }
2327 }
2328 }
2329 #[doc = "`GetEnumerator()` overload"]
2330 fn get_enumerator(self) -> crate::system::collections::idictionaryenumerator::IDictionaryEnumerator {
2331 unsafe {
2332 let __receiver =
2333 <Hashtable_SyncHashtable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2334 {
2335 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2336 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
2337 panic!(
2338 "unity: virtual slot {}
2339 out of range (vtable len {}
2340) on the runtime class behind {}
2341 (method `{}
2342`)",
2343 30usize,
2344 __vt.len(),
2345 <Hashtable_SyncHashtable as ::unity::ClassIdentity>::NAME,
2346 "GetEnumerator",
2347 )
2348 });
2349 let __inner: extern "C" fn(
2350 Hashtable_SyncHashtable,
2351 ::unity::OptionalMethod,
2352 ) -> crate::system::collections::idictionaryenumerator::IDictionaryEnumerator = ::core::mem::transmute(__vi.method_ptr);
2353 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2354 __inner(__receiver, __mi)
2355 }
2356 }
2357 }
2358 #[doc = "`get_Keys()` overload"]
2359 fn get_keys(self) -> crate::system::collections::icollection::ICollection {
2360 unsafe {
2361 let __receiver =
2362 <Hashtable_SyncHashtable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2363 {
2364 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2365 let __vi = *__vt.get(36usize).unwrap_or_else(|| {
2366 panic!(
2367 "unity: virtual slot {}
2368 out of range (vtable len {}
2369) on the runtime class behind {}
2370 (method `{}
2371`)",
2372 36usize,
2373 __vt.len(),
2374 <Hashtable_SyncHashtable as ::unity::ClassIdentity>::NAME,
2375 "get_Keys",
2376 )
2377 });
2378 let __inner: extern "C" fn(Hashtable_SyncHashtable, ::unity::OptionalMethod) -> crate::system::collections::icollection::ICollection =
2379 ::core::mem::transmute(__vi.method_ptr);
2380 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2381 __inner(__receiver, __mi)
2382 }
2383 }
2384 }
2385 #[doc = "`get_Values()` overload"]
2386 fn get_values(self) -> crate::system::collections::icollection::ICollection {
2387 unsafe {
2388 let __receiver =
2389 <Hashtable_SyncHashtable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2390 {
2391 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2392 let __vi = *__vt.get(37usize).unwrap_or_else(|| {
2393 panic!(
2394 "unity: virtual slot {}
2395 out of range (vtable len {}
2396) on the runtime class behind {}
2397 (method `{}
2398`)",
2399 37usize,
2400 __vt.len(),
2401 <Hashtable_SyncHashtable as ::unity::ClassIdentity>::NAME,
2402 "get_Values",
2403 )
2404 });
2405 let __inner: extern "C" fn(Hashtable_SyncHashtable, ::unity::OptionalMethod) -> crate::system::collections::icollection::ICollection =
2406 ::core::mem::transmute(__vi.method_ptr);
2407 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2408 __inner(__receiver, __mi)
2409 }
2410 }
2411 }
2412 #[doc = "`Remove(crate::system::object::Object)` overload"]
2413 fn remove(self, key: impl ::core::convert::Into<crate::system::object::Object>) -> () {
2414 unsafe {
2415 let __receiver =
2416 <Hashtable_SyncHashtable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2417 {
2418 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2419 let __vi = *__vt.get(38usize).unwrap_or_else(|| {
2420 panic!(
2421 "unity: virtual slot {}
2422 out of range (vtable len {}
2423) on the runtime class behind {}
2424 (method `{}
2425`)",
2426 38usize,
2427 __vt.len(),
2428 <Hashtable_SyncHashtable as ::unity::ClassIdentity>::NAME,
2429 "Remove",
2430 )
2431 });
2432 let __inner: extern "C" fn(Hashtable_SyncHashtable, crate::system::object::Object, ::unity::OptionalMethod) -> () =
2433 ::core::mem::transmute(__vi.method_ptr);
2434 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2435 __inner(__receiver, ::core::convert::Into::into(key), __mi)
2436 }
2437 }
2438 }
2439 #[doc = "`OnDeserialization(crate::system::object::Object)` overload"]
2440 fn on_deserialization(self, sender: impl ::core::convert::Into<crate::system::object::Object>) -> () {
2441 unsafe {
2442 let __receiver =
2443 <Hashtable_SyncHashtable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2444 {
2445 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2446 let __vi = *__vt.get(42usize).unwrap_or_else(|| {
2447 panic!(
2448 "unity: virtual slot {}
2449 out of range (vtable len {}
2450) on the runtime class behind {}
2451 (method `{}
2452`)",
2453 42usize,
2454 __vt.len(),
2455 <Hashtable_SyncHashtable as ::unity::ClassIdentity>::NAME,
2456 "OnDeserialization",
2457 )
2458 });
2459 let __inner: extern "C" fn(Hashtable_SyncHashtable, crate::system::object::Object, ::unity::OptionalMethod) -> () =
2460 ::core::mem::transmute(__vi.method_ptr);
2461 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2462 __inner(__receiver, ::core::convert::Into::into(sender), __mi)
2463 }
2464 }
2465 }
2466}
2467
2468#[cfg(feature = "system-collections-hashtable")]
2469impl<__T: IHashtable_SyncHashtable> IHashtable_SyncHashtableMethods for __T {}
2470
2471#[cfg(feature = "system-collections-hashtable")]
2472impl Hashtable_SyncHashtable {
2473 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2474 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
2475 }
2476
2477 pub fn get_count_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2478 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
2479 }
2480
2481 pub fn get_is_read_only_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2482 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
2483 }
2484
2485 pub fn get_is_fixed_size_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2486 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
2487 }
2488
2489 pub fn get_is_synchronized_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2490 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
2491 }
2492
2493 pub fn get_item_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2494 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
2495 }
2496
2497 pub fn set_item_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2498 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[8]
2499 }
2500
2501 pub fn get_sync_root_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2502 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[9]
2503 }
2504
2505 pub fn add_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2506 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[10]
2507 }
2508
2509 pub fn clear_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2510 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[11]
2511 }
2512
2513 pub fn contains_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2514 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[12]
2515 }
2516
2517 pub fn contains_key_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2518 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[13]
2519 }
2520
2521 pub fn copy_to_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2522 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[14]
2523 }
2524
2525 pub fn clone_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2526 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[15]
2527 }
2528
2529 pub fn system_collections_i_enumerable_get_enumerator_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2530 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[16]
2531 }
2532
2533 pub fn get_enumerator_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2534 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[17]
2535 }
2536
2537 pub fn get_keys_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2538 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[18]
2539 }
2540
2541 pub fn get_values_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2542 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[19]
2543 }
2544
2545 pub fn remove_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2546 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[20]
2547 }
2548
2549 pub fn on_deserialization_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2550 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[21]
2551 }
2552}
2553
2554#[cfg(feature = "system-collections-hashtable")]
2555impl Hashtable_SyncHashtable {
2556 #[doc = "Direct (non-virtual) call to `Hashtable_SyncHashtable`'s own `get_Count`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2557 pub unsafe fn get_count(this: impl ::core::convert::Into<::unity::IlInstance>) -> i32 {
2558 let __mi = Self::get_count_method_info();
2559 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__mi.method_ptr);
2560 __inner(this.into(), ::core::option::Option::None)
2561 }
2562
2563 #[doc = "Direct (non-virtual) call to `Hashtable_SyncHashtable`'s own `get_IsReadOnly`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2564 pub unsafe fn get_is_read_only(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
2565 let __mi = Self::get_is_read_only_method_info();
2566 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
2567 __inner(this.into(), ::core::option::Option::None)
2568 }
2569
2570 #[doc = "Direct (non-virtual) call to `Hashtable_SyncHashtable`'s own `get_IsFixedSize`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2571 pub unsafe fn get_is_fixed_size(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
2572 let __mi = Self::get_is_fixed_size_method_info();
2573 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
2574 __inner(this.into(), ::core::option::Option::None)
2575 }
2576
2577 #[doc = "Direct (non-virtual) call to `Hashtable_SyncHashtable`'s own `get_IsSynchronized`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2578 pub unsafe fn get_is_synchronized(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
2579 let __mi = Self::get_is_synchronized_method_info();
2580 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
2581 __inner(this.into(), ::core::option::Option::None)
2582 }
2583
2584 #[doc = "Direct (non-virtual) call to `Hashtable_SyncHashtable`'s own `get_Item`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2585 pub unsafe fn get_item(
2586 this: impl ::core::convert::Into<::unity::IlInstance>,
2587 key: crate::system::object::Object,
2588 ) -> crate::system::object::Object {
2589 let __mi = Self::get_item_method_info();
2590 let __inner: extern "C" fn(::unity::IlInstance, crate::system::object::Object, ::unity::OptionalMethod) -> crate::system::object::Object =
2591 ::core::mem::transmute(__mi.method_ptr);
2592 __inner(this.into(), key, ::core::option::Option::None)
2593 }
2594
2595 #[doc = "Direct (non-virtual) call to `Hashtable_SyncHashtable`'s own `set_Item`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2596 pub unsafe fn set_item(
2597 this: impl ::core::convert::Into<::unity::IlInstance>,
2598 key: crate::system::object::Object,
2599 value: crate::system::object::Object,
2600 ) -> () {
2601 let __mi = Self::set_item_method_info();
2602 let __inner: extern "C" fn(::unity::IlInstance, crate::system::object::Object, crate::system::object::Object, ::unity::OptionalMethod) -> () =
2603 ::core::mem::transmute(__mi.method_ptr);
2604 __inner(this.into(), key, value, ::core::option::Option::None)
2605 }
2606
2607 #[doc = "Direct (non-virtual) call to `Hashtable_SyncHashtable`'s own `get_SyncRoot`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2608 pub unsafe fn get_sync_root(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::system::object::Object {
2609 let __mi = Self::get_sync_root_method_info();
2610 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::system::object::Object =
2611 ::core::mem::transmute(__mi.method_ptr);
2612 __inner(this.into(), ::core::option::Option::None)
2613 }
2614
2615 #[doc = "Direct (non-virtual) call to `Hashtable_SyncHashtable`'s own `Add`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2616 pub unsafe fn add(
2617 this: impl ::core::convert::Into<::unity::IlInstance>,
2618 key: crate::system::object::Object,
2619 value: crate::system::object::Object,
2620 ) -> () {
2621 let __mi = Self::add_method_info();
2622 let __inner: extern "C" fn(::unity::IlInstance, crate::system::object::Object, crate::system::object::Object, ::unity::OptionalMethod) -> () =
2623 ::core::mem::transmute(__mi.method_ptr);
2624 __inner(this.into(), key, value, ::core::option::Option::None)
2625 }
2626
2627 #[doc = "Direct (non-virtual) call to `Hashtable_SyncHashtable`'s own `Clear`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2628 pub unsafe fn clear(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
2629 let __mi = Self::clear_method_info();
2630 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
2631 __inner(this.into(), ::core::option::Option::None)
2632 }
2633
2634 #[doc = "Direct (non-virtual) call to `Hashtable_SyncHashtable`'s own `Contains`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2635 pub unsafe fn contains(this: impl ::core::convert::Into<::unity::IlInstance>, key: crate::system::object::Object) -> bool {
2636 let __mi = Self::contains_method_info();
2637 let __inner: extern "C" fn(::unity::IlInstance, crate::system::object::Object, ::unity::OptionalMethod) -> bool =
2638 ::core::mem::transmute(__mi.method_ptr);
2639 __inner(this.into(), key, ::core::option::Option::None)
2640 }
2641
2642 #[doc = "Direct (non-virtual) call to `Hashtable_SyncHashtable`'s own `ContainsKey`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2643 pub unsafe fn contains_key(this: impl ::core::convert::Into<::unity::IlInstance>, key: crate::system::object::Object) -> bool {
2644 let __mi = Self::contains_key_method_info();
2645 let __inner: extern "C" fn(::unity::IlInstance, crate::system::object::Object, ::unity::OptionalMethod) -> bool =
2646 ::core::mem::transmute(__mi.method_ptr);
2647 __inner(this.into(), key, ::core::option::Option::None)
2648 }
2649
2650 #[doc = "Direct (non-virtual) call to `Hashtable_SyncHashtable`'s own `CopyTo`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2651 pub unsafe fn copy_to(this: impl ::core::convert::Into<::unity::IlInstance>, array: ::unity::IlInstance, array_index: i32) -> () {
2652 let __mi = Self::copy_to_method_info();
2653 let __inner: extern "C" fn(::unity::IlInstance, ::unity::IlInstance, i32, ::unity::OptionalMethod) -> () =
2654 ::core::mem::transmute(__mi.method_ptr);
2655 __inner(this.into(), array, array_index, ::core::option::Option::None)
2656 }
2657
2658 #[doc = "Direct (non-virtual) call to `Hashtable_SyncHashtable`'s own `Clone`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2659 pub unsafe fn clone(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::system::object::Object {
2660 let __mi = Self::clone_method_info();
2661 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::system::object::Object =
2662 ::core::mem::transmute(__mi.method_ptr);
2663 __inner(this.into(), ::core::option::Option::None)
2664 }
2665
2666 #[doc = "Direct (non-virtual) call to `Hashtable_SyncHashtable`'s own `System.Collections.IEnumerable.GetEnumerator`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2667 pub unsafe fn system_collections_i_enumerable_get_enumerator(
2668 this: impl ::core::convert::Into<::unity::IlInstance>,
2669 ) -> crate::system::collections::ienumerator::IEnumerator {
2670 let __mi = Self::system_collections_i_enumerable_get_enumerator_method_info();
2671 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::system::collections::ienumerator::IEnumerator =
2672 ::core::mem::transmute(__mi.method_ptr);
2673 __inner(this.into(), ::core::option::Option::None)
2674 }
2675
2676 #[doc = "Direct (non-virtual) call to `Hashtable_SyncHashtable`'s own `GetEnumerator`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2677 pub unsafe fn get_enumerator(
2678 this: impl ::core::convert::Into<::unity::IlInstance>,
2679 ) -> crate::system::collections::idictionaryenumerator::IDictionaryEnumerator {
2680 let __mi = Self::get_enumerator_method_info();
2681 let __inner: extern "C" fn(
2682 ::unity::IlInstance,
2683 ::unity::OptionalMethod,
2684 ) -> crate::system::collections::idictionaryenumerator::IDictionaryEnumerator = ::core::mem::transmute(__mi.method_ptr);
2685 __inner(this.into(), ::core::option::Option::None)
2686 }
2687
2688 #[doc = "Direct (non-virtual) call to `Hashtable_SyncHashtable`'s own `get_Keys`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2689 pub unsafe fn get_keys(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::system::collections::icollection::ICollection {
2690 let __mi = Self::get_keys_method_info();
2691 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::system::collections::icollection::ICollection =
2692 ::core::mem::transmute(__mi.method_ptr);
2693 __inner(this.into(), ::core::option::Option::None)
2694 }
2695
2696 #[doc = "Direct (non-virtual) call to `Hashtable_SyncHashtable`'s own `get_Values`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2697 pub unsafe fn get_values(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::system::collections::icollection::ICollection {
2698 let __mi = Self::get_values_method_info();
2699 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::system::collections::icollection::ICollection =
2700 ::core::mem::transmute(__mi.method_ptr);
2701 __inner(this.into(), ::core::option::Option::None)
2702 }
2703
2704 #[doc = "Direct (non-virtual) call to `Hashtable_SyncHashtable`'s own `Remove`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2705 pub unsafe fn remove(this: impl ::core::convert::Into<::unity::IlInstance>, key: crate::system::object::Object) -> () {
2706 let __mi = Self::remove_method_info();
2707 let __inner: extern "C" fn(::unity::IlInstance, crate::system::object::Object, ::unity::OptionalMethod) -> () =
2708 ::core::mem::transmute(__mi.method_ptr);
2709 __inner(this.into(), key, ::core::option::Option::None)
2710 }
2711
2712 #[doc = "Direct (non-virtual) call to `Hashtable_SyncHashtable`'s own `OnDeserialization`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2713 pub unsafe fn on_deserialization(this: impl ::core::convert::Into<::unity::IlInstance>, sender: crate::system::object::Object) -> () {
2714 let __mi = Self::on_deserialization_method_info();
2715 let __inner: extern "C" fn(::unity::IlInstance, crate::system::object::Object, ::unity::OptionalMethod) -> () =
2716 ::core::mem::transmute(__mi.method_ptr);
2717 __inner(this.into(), sender, ::core::option::Option::None)
2718 }
2719}
2720
2721#[cfg(feature = "system-collections-hashtable")]
2722impl Hashtable_SyncHashtable {
2723 #[doc = "`.ctor(crate::system::collections::hashtable::Hashtable)` — overload selector"]
2724 pub fn new(table: crate::system::collections::hashtable::Hashtable) -> Self {
2725 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
2726 panic!(
2727 "{}
2728::{}
2729 failed to instantiate",
2730 ::core::stringify!(Hashtable_SyncHashtable),
2731 ::core::stringify!(new),
2732 )
2733 });
2734 <Self as IHashtable_SyncHashtableMethods>::ctor(this, table);
2735 this
2736 }
2737}
2738
2739#[cfg(feature = "system-collections-hashtable")]
2740pub trait IHashtable_HashtableEnumeratorMethods: IHashtable_HashtableEnumerator {
2741 #[doc = "`.ctor(crate::system::collections::hashtable::Hashtable, i32)` overload"]
2742 fn ctor(
2743 self,
2744 hashtable: impl ::core::convert::Into<crate::system::collections::hashtable::Hashtable>,
2745 get_obj_ret_type: impl ::core::convert::Into<i32>,
2746 ) -> () {
2747 unsafe {
2748 let __receiver =
2749 <Hashtable_HashtableEnumerator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2750 ::unity::il2cpp_call!((::unity::module_base()+0x34d7110usize)as*mut u8,();
2751(Hashtable_HashtableEnumerator)__receiver,(crate::system::collections::hashtable::Hashtable)::core::convert::Into::into(hashtable),(i32)::core::convert::Into::into(get_obj_ret_type))
2752 }
2753 }
2754 #[doc = "`Clone()` overload"]
2755 fn clone(self) -> crate::system::object::Object {
2756 unsafe {
2757 let __receiver =
2758 <Hashtable_HashtableEnumerator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2759 {
2760 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2761 let __vi = *__vt.get(10usize).unwrap_or_else(|| {
2762 panic!(
2763 "unity: virtual slot {}
2764 out of range (vtable len {}
2765) on the runtime class behind {}
2766 (method `{}
2767`)",
2768 10usize,
2769 __vt.len(),
2770 <Hashtable_HashtableEnumerator as ::unity::ClassIdentity>::NAME,
2771 "Clone",
2772 )
2773 });
2774 let __inner: extern "C" fn(Hashtable_HashtableEnumerator, ::unity::OptionalMethod) -> crate::system::object::Object =
2775 ::core::mem::transmute(__vi.method_ptr);
2776 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2777 __inner(__receiver, __mi)
2778 }
2779 }
2780 }
2781 #[doc = "`get_Key()` overload"]
2782 fn get_key(self) -> crate::system::object::Object {
2783 unsafe {
2784 let __receiver =
2785 <Hashtable_HashtableEnumerator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2786 {
2787 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2788 let __vi = *__vt.get(11usize).unwrap_or_else(|| {
2789 panic!(
2790 "unity: virtual slot {}
2791 out of range (vtable len {}
2792) on the runtime class behind {}
2793 (method `{}
2794`)",
2795 11usize,
2796 __vt.len(),
2797 <Hashtable_HashtableEnumerator as ::unity::ClassIdentity>::NAME,
2798 "get_Key",
2799 )
2800 });
2801 let __inner: extern "C" fn(Hashtable_HashtableEnumerator, ::unity::OptionalMethod) -> crate::system::object::Object =
2802 ::core::mem::transmute(__vi.method_ptr);
2803 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2804 __inner(__receiver, __mi)
2805 }
2806 }
2807 }
2808 #[doc = "`MoveNext()` overload"]
2809 fn move_next(self) -> bool {
2810 unsafe {
2811 let __receiver =
2812 <Hashtable_HashtableEnumerator 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(12usize).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 12usize,
2823 __vt.len(),
2824 <Hashtable_HashtableEnumerator as ::unity::ClassIdentity>::NAME,
2825 "MoveNext",
2826 )
2827 });
2828 let __inner: extern "C" fn(Hashtable_HashtableEnumerator, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
2829 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2830 __inner(__receiver, __mi)
2831 }
2832 }
2833 }
2834 #[doc = "`get_Entry()` overload"]
2835 fn get_entry(self) -> crate::system::collections::dictionaryentry::DictionaryEntry {
2836 unsafe {
2837 let __receiver =
2838 <Hashtable_HashtableEnumerator 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(13usize).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 13usize,
2849 __vt.len(),
2850 <Hashtable_HashtableEnumerator as ::unity::ClassIdentity>::NAME,
2851 "get_Entry",
2852 )
2853 });
2854 let __inner: extern "C" fn(
2855 Hashtable_HashtableEnumerator,
2856 ::unity::OptionalMethod,
2857 ) -> crate::system::collections::dictionaryentry::DictionaryEntry = ::core::mem::transmute(__vi.method_ptr);
2858 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2859 __inner(__receiver, __mi)
2860 }
2861 }
2862 }
2863 #[doc = "`get_Current()` overload"]
2864 fn get_current(self) -> crate::system::object::Object {
2865 unsafe {
2866 let __receiver =
2867 <Hashtable_HashtableEnumerator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2868 {
2869 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2870 let __vi = *__vt.get(14usize).unwrap_or_else(|| {
2871 panic!(
2872 "unity: virtual slot {}
2873 out of range (vtable len {}
2874) on the runtime class behind {}
2875 (method `{}
2876`)",
2877 14usize,
2878 __vt.len(),
2879 <Hashtable_HashtableEnumerator as ::unity::ClassIdentity>::NAME,
2880 "get_Current",
2881 )
2882 });
2883 let __inner: extern "C" fn(Hashtable_HashtableEnumerator, ::unity::OptionalMethod) -> crate::system::object::Object =
2884 ::core::mem::transmute(__vi.method_ptr);
2885 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2886 __inner(__receiver, __mi)
2887 }
2888 }
2889 }
2890 #[doc = "`get_Value()` overload"]
2891 fn get_value(self) -> crate::system::object::Object {
2892 unsafe {
2893 let __receiver =
2894 <Hashtable_HashtableEnumerator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2895 {
2896 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2897 let __vi = *__vt.get(15usize).unwrap_or_else(|| {
2898 panic!(
2899 "unity: virtual slot {}
2900 out of range (vtable len {}
2901) on the runtime class behind {}
2902 (method `{}
2903`)",
2904 15usize,
2905 __vt.len(),
2906 <Hashtable_HashtableEnumerator as ::unity::ClassIdentity>::NAME,
2907 "get_Value",
2908 )
2909 });
2910 let __inner: extern "C" fn(Hashtable_HashtableEnumerator, ::unity::OptionalMethod) -> crate::system::object::Object =
2911 ::core::mem::transmute(__vi.method_ptr);
2912 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2913 __inner(__receiver, __mi)
2914 }
2915 }
2916 }
2917 #[doc = "`Reset()` overload"]
2918 fn reset(self) -> () {
2919 unsafe {
2920 let __receiver =
2921 <Hashtable_HashtableEnumerator 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(16usize).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 16usize,
2932 __vt.len(),
2933 <Hashtable_HashtableEnumerator as ::unity::ClassIdentity>::NAME,
2934 "Reset",
2935 )
2936 });
2937 let __inner: extern "C" fn(Hashtable_HashtableEnumerator, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
2938 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2939 __inner(__receiver, __mi)
2940 }
2941 }
2942 }
2943}
2944
2945#[cfg(feature = "system-collections-hashtable")]
2946impl<__T: IHashtable_HashtableEnumerator> IHashtable_HashtableEnumeratorMethods for __T {}
2947
2948#[cfg(feature = "system-collections-hashtable")]
2949impl Hashtable_HashtableEnumerator {
2950 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2951 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
2952 }
2953
2954 pub fn clone_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2955 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
2956 }
2957
2958 pub fn get_key_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2959 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
2960 }
2961
2962 pub fn move_next_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2963 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
2964 }
2965
2966 pub fn get_entry_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2967 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
2968 }
2969
2970 pub fn get_current_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2971 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
2972 }
2973
2974 pub fn get_value_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2975 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
2976 }
2977
2978 pub fn reset_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2979 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
2980 }
2981}
2982
2983#[cfg(feature = "system-collections-hashtable")]
2984impl Hashtable_HashtableEnumerator {
2985 #[doc = "Direct (non-virtual) call to `Hashtable_HashtableEnumerator`'s own `Clone`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2986 pub unsafe fn clone(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::system::object::Object {
2987 let __mi = Self::clone_method_info();
2988 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::system::object::Object =
2989 ::core::mem::transmute(__mi.method_ptr);
2990 __inner(this.into(), ::core::option::Option::None)
2991 }
2992
2993 #[doc = "Direct (non-virtual) call to `Hashtable_HashtableEnumerator`'s own `get_Key`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2994 pub unsafe fn get_key(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::system::object::Object {
2995 let __mi = Self::get_key_method_info();
2996 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::system::object::Object =
2997 ::core::mem::transmute(__mi.method_ptr);
2998 __inner(this.into(), ::core::option::Option::None)
2999 }
3000
3001 #[doc = "Direct (non-virtual) call to `Hashtable_HashtableEnumerator`'s own `MoveNext`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3002 pub unsafe fn move_next(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
3003 let __mi = Self::move_next_method_info();
3004 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
3005 __inner(this.into(), ::core::option::Option::None)
3006 }
3007
3008 #[doc = "Direct (non-virtual) call to `Hashtable_HashtableEnumerator`'s own `get_Entry`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3009 pub unsafe fn get_entry(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::system::collections::dictionaryentry::DictionaryEntry {
3010 let __mi = Self::get_entry_method_info();
3011 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::system::collections::dictionaryentry::DictionaryEntry =
3012 ::core::mem::transmute(__mi.method_ptr);
3013 __inner(this.into(), ::core::option::Option::None)
3014 }
3015
3016 #[doc = "Direct (non-virtual) call to `Hashtable_HashtableEnumerator`'s own `get_Current`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3017 pub unsafe fn get_current(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::system::object::Object {
3018 let __mi = Self::get_current_method_info();
3019 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::system::object::Object =
3020 ::core::mem::transmute(__mi.method_ptr);
3021 __inner(this.into(), ::core::option::Option::None)
3022 }
3023
3024 #[doc = "Direct (non-virtual) call to `Hashtable_HashtableEnumerator`'s own `get_Value`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3025 pub unsafe fn get_value(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::system::object::Object {
3026 let __mi = Self::get_value_method_info();
3027 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::system::object::Object =
3028 ::core::mem::transmute(__mi.method_ptr);
3029 __inner(this.into(), ::core::option::Option::None)
3030 }
3031
3032 #[doc = "Direct (non-virtual) call to `Hashtable_HashtableEnumerator`'s own `Reset`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3033 pub unsafe fn reset(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
3034 let __mi = Self::reset_method_info();
3035 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
3036 __inner(this.into(), ::core::option::Option::None)
3037 }
3038}
3039
3040#[cfg(feature = "system-collections-hashtable")]
3041impl Hashtable_HashtableEnumerator {
3042 #[doc = "`.ctor(crate::system::collections::hashtable::Hashtable, i32)` — overload selector"]
3043 pub fn new(hashtable: crate::system::collections::hashtable::Hashtable, get_obj_ret_type: i32) -> Self {
3044 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
3045 panic!(
3046 "{}
3047::{}
3048 failed to instantiate",
3049 ::core::stringify!(Hashtable_HashtableEnumerator),
3050 ::core::stringify!(new),
3051 )
3052 });
3053 <Self as IHashtable_HashtableEnumeratorMethods>::ctor(this, hashtable, get_obj_ret_type);
3054 this
3055 }
3056}
3057
3058#[cfg(feature = "system-collections-hashtable")]
3059#[doc(hidden)]
3060pub mod prelude {
3061 pub use super::{
3062 Hashtable, Hashtable_HashtableDebugView, Hashtable_HashtableEnumerator, Hashtable_KeyCollection, Hashtable_SyncHashtable,
3063 Hashtable_ValueCollection, Hashtable_bucket, IHashtable, IHashtableMethods, IHashtable_HashtableDebugView, IHashtable_HashtableEnumerator,
3064 IHashtable_HashtableEnumeratorMethods, IHashtable_KeyCollection, IHashtable_KeyCollectionMethods, IHashtable_SyncHashtable,
3065 IHashtable_SyncHashtableMethods, IHashtable_ValueCollection, IHashtable_ValueCollectionMethods,
3066 };
3067 #[cfg(feature = "system-object")]
3068 pub use crate::system::object::IObjectMethods;
3069 #[cfg(feature = "system-valuetype")]
3070 pub use crate::system::valuetype::IValueTypeMethods;
3071 pub use crate::system::{object::IObject, valuetype::IValueType};
3072}