1#[cfg(feature = "system-collections-specialized-hybriddictionary-types")]
4mod __types {
5 #[allow(unused_imports)] use ::unity::prelude::*;
6
7 use super::*;
8 use crate::system::object::{IObject, Object};
9
10 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/system/collections/specialized/hybriddictionary/HybridDictionary.md"))]
11 #[::unity::class(namespace = "System.Collections.Specialized", name = "HybridDictionary")]
12 #[parent(crate::system::object::Object)]
13 pub struct HybridDictionary {
14 #[offset(16)]
15 #[rename(name = "list")]
16 pub list: crate::system::collections::specialized::listdictionary::ListDictionary,
17 #[offset(24)]
18 #[rename(name = "hashtable")]
19 pub hashtable: crate::system::collections::hashtable::Hashtable,
20 #[offset(32)]
21 #[rename(name = "caseInsensitive")]
22 pub case_insensitive: bool,
23 }
24}
25
26#[cfg(feature = "system-collections-specialized-hybriddictionary-types")]
27pub use __types::*;
28
29#[cfg(feature = "system-collections-specialized-hybriddictionary")]
30pub trait IHybridDictionaryMethods: IHybridDictionary {
31 #[doc = "`.ctor()` overload"]
32 fn ctor(self) -> () {
33 unsafe {
34 let __receiver = <HybridDictionary as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
35 ::unity::il2cpp_call!((::unity::module_base()+0x34ab420usize)as*mut u8,();
36(HybridDictionary)__receiver)
37 }
38 }
39 #[doc = "`get_Item(crate::system::object::Object)` overload"]
40 fn get_item(self, key: impl ::core::convert::Into<crate::system::object::Object>) -> crate::system::object::Object {
41 unsafe {
42 let __receiver = <HybridDictionary as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
43 {
44 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
45 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
46 panic!(
47 "unity: virtual slot {}
48 out of range (vtable len {}
49) on the runtime class behind {}
50 (method `{}
51`)",
52 4usize,
53 __vt.len(),
54 <HybridDictionary as ::unity::ClassIdentity>::NAME,
55 "get_Item",
56 )
57 });
58 let __inner: extern "C" fn(
59 HybridDictionary,
60 crate::system::object::Object,
61 ::unity::OptionalMethod,
62 ) -> crate::system::object::Object = ::core::mem::transmute(__vi.method_ptr);
63 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
64 __inner(__receiver, ::core::convert::Into::into(key), __mi)
65 }
66 }
67 }
68 #[doc = "`set_Item(crate::system::object::Object, crate::system::object::Object)` overload"]
69 fn set_item(
70 self,
71 key: impl ::core::convert::Into<crate::system::object::Object>,
72 value: impl ::core::convert::Into<crate::system::object::Object>,
73 ) -> () {
74 unsafe {
75 let __receiver = <HybridDictionary as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
76 {
77 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
78 let __vi = *__vt.get(5usize).unwrap_or_else(|| {
79 panic!(
80 "unity: virtual slot {}
81 out of range (vtable len {}
82) on the runtime class behind {}
83 (method `{}
84`)",
85 5usize,
86 __vt.len(),
87 <HybridDictionary as ::unity::ClassIdentity>::NAME,
88 "set_Item",
89 )
90 });
91 let __inner: extern "C" fn(
92 HybridDictionary,
93 crate::system::object::Object,
94 crate::system::object::Object,
95 ::unity::OptionalMethod,
96 ) -> () = ::core::mem::transmute(__vi.method_ptr);
97 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
98 __inner(__receiver, ::core::convert::Into::into(key), ::core::convert::Into::into(value), __mi)
99 }
100 }
101 }
102 #[doc = "`get_List()` overload"]
103 fn get_list(self) -> crate::system::collections::specialized::listdictionary::ListDictionary {
104 unsafe {
105 let __receiver = <HybridDictionary as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
106 ::unity::il2cpp_call!((::unity::module_base()+0x34ab930usize)as*mut u8,crate::system::collections::specialized::listdictionary::ListDictionary;
107(HybridDictionary)__receiver)
108 }
109 }
110 #[doc = "`ChangeOver()` overload"]
111 fn change_over(self) -> () {
112 unsafe {
113 let __receiver = <HybridDictionary as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
114 ::unity::il2cpp_call!((::unity::module_base()+0x34ab660usize)as*mut u8,();
115(HybridDictionary)__receiver)
116 }
117 }
118 #[doc = "`get_Count()` overload"]
119 fn get_count(self) -> i32 {
120 unsafe {
121 let __receiver = <HybridDictionary as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
122 {
123 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
124 let __vi = *__vt.get(15usize).unwrap_or_else(|| {
125 panic!(
126 "unity: virtual slot {}
127 out of range (vtable len {}
128) on the runtime class behind {}
129 (method `{}
130`)",
131 15usize,
132 __vt.len(),
133 <HybridDictionary as ::unity::ClassIdentity>::NAME,
134 "get_Count",
135 )
136 });
137 let __inner: extern "C" fn(HybridDictionary, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__vi.method_ptr);
138 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
139 __inner(__receiver, __mi)
140 }
141 }
142 }
143 #[doc = "`get_Keys()` overload"]
144 fn get_keys(self) -> crate::system::collections::icollection::ICollection {
145 unsafe {
146 let __receiver = <HybridDictionary as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
147 {
148 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
149 let __vi = *__vt.get(6usize).unwrap_or_else(|| {
150 panic!(
151 "unity: virtual slot {}
152 out of range (vtable len {}
153) on the runtime class behind {}
154 (method `{}
155`)",
156 6usize,
157 __vt.len(),
158 <HybridDictionary as ::unity::ClassIdentity>::NAME,
159 "get_Keys",
160 )
161 });
162 let __inner: extern "C" fn(HybridDictionary, ::unity::OptionalMethod) -> crate::system::collections::icollection::ICollection =
163 ::core::mem::transmute(__vi.method_ptr);
164 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
165 __inner(__receiver, __mi)
166 }
167 }
168 }
169 #[doc = "`get_IsReadOnly()` overload"]
170 fn get_is_read_only(self) -> bool {
171 unsafe {
172 let __receiver = <HybridDictionary as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
173 {
174 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
175 let __vi = *__vt.get(10usize).unwrap_or_else(|| {
176 panic!(
177 "unity: virtual slot {}
178 out of range (vtable len {}
179) on the runtime class behind {}
180 (method `{}
181`)",
182 10usize,
183 __vt.len(),
184 <HybridDictionary as ::unity::ClassIdentity>::NAME,
185 "get_IsReadOnly",
186 )
187 });
188 let __inner: extern "C" fn(HybridDictionary, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
189 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
190 __inner(__receiver, __mi)
191 }
192 }
193 }
194 #[doc = "`get_IsFixedSize()` overload"]
195 fn get_is_fixed_size(self) -> bool {
196 unsafe {
197 let __receiver = <HybridDictionary as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
198 {
199 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
200 let __vi = *__vt.get(11usize).unwrap_or_else(|| {
201 panic!(
202 "unity: virtual slot {}
203 out of range (vtable len {}
204) on the runtime class behind {}
205 (method `{}
206`)",
207 11usize,
208 __vt.len(),
209 <HybridDictionary as ::unity::ClassIdentity>::NAME,
210 "get_IsFixedSize",
211 )
212 });
213 let __inner: extern "C" fn(HybridDictionary, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
214 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
215 __inner(__receiver, __mi)
216 }
217 }
218 }
219 #[doc = "`get_IsSynchronized()` overload"]
220 fn get_is_synchronized(self) -> bool {
221 unsafe {
222 let __receiver = <HybridDictionary as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
223 {
224 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
225 let __vi = *__vt.get(17usize).unwrap_or_else(|| {
226 panic!(
227 "unity: virtual slot {}
228 out of range (vtable len {}
229) on the runtime class behind {}
230 (method `{}
231`)",
232 17usize,
233 __vt.len(),
234 <HybridDictionary as ::unity::ClassIdentity>::NAME,
235 "get_IsSynchronized",
236 )
237 });
238 let __inner: extern "C" fn(HybridDictionary, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
239 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
240 __inner(__receiver, __mi)
241 }
242 }
243 }
244 #[doc = "`get_SyncRoot()` overload"]
245 fn get_sync_root(self) -> crate::system::object::Object {
246 unsafe {
247 let __receiver = <HybridDictionary as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
248 {
249 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
250 let __vi = *__vt.get(16usize).unwrap_or_else(|| {
251 panic!(
252 "unity: virtual slot {}
253 out of range (vtable len {}
254) on the runtime class behind {}
255 (method `{}
256`)",
257 16usize,
258 __vt.len(),
259 <HybridDictionary as ::unity::ClassIdentity>::NAME,
260 "get_SyncRoot",
261 )
262 });
263 let __inner: extern "C" fn(HybridDictionary, ::unity::OptionalMethod) -> crate::system::object::Object =
264 ::core::mem::transmute(__vi.method_ptr);
265 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
266 __inner(__receiver, __mi)
267 }
268 }
269 }
270 #[doc = "`get_Values()` overload"]
271 fn get_values(self) -> crate::system::collections::icollection::ICollection {
272 unsafe {
273 let __receiver = <HybridDictionary as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
274 {
275 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
276 let __vi = *__vt.get(7usize).unwrap_or_else(|| {
277 panic!(
278 "unity: virtual slot {}
279 out of range (vtable len {}
280) on the runtime class behind {}
281 (method `{}
282`)",
283 7usize,
284 __vt.len(),
285 <HybridDictionary as ::unity::ClassIdentity>::NAME,
286 "get_Values",
287 )
288 });
289 let __inner: extern "C" fn(HybridDictionary, ::unity::OptionalMethod) -> crate::system::collections::icollection::ICollection =
290 ::core::mem::transmute(__vi.method_ptr);
291 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
292 __inner(__receiver, __mi)
293 }
294 }
295 }
296 #[doc = "`Add(crate::system::object::Object, crate::system::object::Object)` overload"]
297 fn add(
298 self,
299 key: impl ::core::convert::Into<crate::system::object::Object>,
300 value: impl ::core::convert::Into<crate::system::object::Object>,
301 ) -> () {
302 unsafe {
303 let __receiver = <HybridDictionary as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
304 {
305 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
306 let __vi = *__vt.get(9usize).unwrap_or_else(|| {
307 panic!(
308 "unity: virtual slot {}
309 out of range (vtable len {}
310) on the runtime class behind {}
311 (method `{}
312`)",
313 9usize,
314 __vt.len(),
315 <HybridDictionary as ::unity::ClassIdentity>::NAME,
316 "Add",
317 )
318 });
319 let __inner: extern "C" fn(
320 HybridDictionary,
321 crate::system::object::Object,
322 crate::system::object::Object,
323 ::unity::OptionalMethod,
324 ) -> () = ::core::mem::transmute(__vi.method_ptr);
325 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
326 __inner(__receiver, ::core::convert::Into::into(key), ::core::convert::Into::into(value), __mi)
327 }
328 }
329 }
330 #[doc = "`Contains(crate::system::object::Object)` overload"]
331 fn contains(self, key: impl ::core::convert::Into<crate::system::object::Object>) -> bool {
332 unsafe {
333 let __receiver = <HybridDictionary as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
334 {
335 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
336 let __vi = *__vt.get(8usize).unwrap_or_else(|| {
337 panic!(
338 "unity: virtual slot {}
339 out of range (vtable len {}
340) on the runtime class behind {}
341 (method `{}
342`)",
343 8usize,
344 __vt.len(),
345 <HybridDictionary as ::unity::ClassIdentity>::NAME,
346 "Contains",
347 )
348 });
349 let __inner: extern "C" fn(HybridDictionary, crate::system::object::Object, ::unity::OptionalMethod) -> bool =
350 ::core::mem::transmute(__vi.method_ptr);
351 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
352 __inner(__receiver, ::core::convert::Into::into(key), __mi)
353 }
354 }
355 }
356 #[doc = "`CopyTo(::unity::IlInstance, i32)` overload"]
357 fn copy_to(self, array: impl ::core::convert::Into<::unity::IlInstance>, index: impl ::core::convert::Into<i32>) -> () {
358 unsafe {
359 let __receiver = <HybridDictionary as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
360 {
361 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
362 let __vi = *__vt.get(14usize).unwrap_or_else(|| {
363 panic!(
364 "unity: virtual slot {}
365 out of range (vtable len {}
366) on the runtime class behind {}
367 (method `{}
368`)",
369 14usize,
370 __vt.len(),
371 <HybridDictionary as ::unity::ClassIdentity>::NAME,
372 "CopyTo",
373 )
374 });
375 let __inner: extern "C" fn(HybridDictionary, ::unity::IlInstance, i32, ::unity::OptionalMethod) -> () =
376 ::core::mem::transmute(__vi.method_ptr);
377 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
378 __inner(__receiver, ::core::convert::Into::into(array), ::core::convert::Into::into(index), __mi)
379 }
380 }
381 }
382 #[doc = "`GetEnumerator()` overload"]
383 fn get_enumerator(self) -> crate::system::collections::idictionaryenumerator::IDictionaryEnumerator {
384 unsafe {
385 let __receiver = <HybridDictionary as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
386 {
387 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
388 let __vi = *__vt.get(12usize).unwrap_or_else(|| {
389 panic!(
390 "unity: virtual slot {}
391 out of range (vtable len {}
392) on the runtime class behind {}
393 (method `{}
394`)",
395 12usize,
396 __vt.len(),
397 <HybridDictionary as ::unity::ClassIdentity>::NAME,
398 "GetEnumerator",
399 )
400 });
401 let __inner: extern "C" fn(
402 HybridDictionary,
403 ::unity::OptionalMethod,
404 ) -> crate::system::collections::idictionaryenumerator::IDictionaryEnumerator = ::core::mem::transmute(__vi.method_ptr);
405 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
406 __inner(__receiver, __mi)
407 }
408 }
409 }
410 #[doc = "`System.Collections.IEnumerable.GetEnumerator()` overload"]
411 fn system_collections_i_enumerable_get_enumerator(self) -> crate::system::collections::ienumerator::IEnumerator {
412 unsafe {
413 let __receiver = <HybridDictionary as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
414 {
415 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
416 let __vi = *__vt.get(18usize).unwrap_or_else(|| {
417 panic!(
418 "unity: virtual slot {}
419 out of range (vtable len {}
420) on the runtime class behind {}
421 (method `{}
422`)",
423 18usize,
424 __vt.len(),
425 <HybridDictionary as ::unity::ClassIdentity>::NAME,
426 "System.Collections.IEnumerable.GetEnumerator",
427 )
428 });
429 let __inner: extern "C" fn(HybridDictionary, ::unity::OptionalMethod) -> crate::system::collections::ienumerator::IEnumerator =
430 ::core::mem::transmute(__vi.method_ptr);
431 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
432 __inner(__receiver, __mi)
433 }
434 }
435 }
436 #[doc = "`Remove(crate::system::object::Object)` overload"]
437 fn remove(self, key: impl ::core::convert::Into<crate::system::object::Object>) -> () {
438 unsafe {
439 let __receiver = <HybridDictionary as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
440 {
441 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
442 let __vi = *__vt.get(13usize).unwrap_or_else(|| {
443 panic!(
444 "unity: virtual slot {}
445 out of range (vtable len {}
446) on the runtime class behind {}
447 (method `{}
448`)",
449 13usize,
450 __vt.len(),
451 <HybridDictionary as ::unity::ClassIdentity>::NAME,
452 "Remove",
453 )
454 });
455 let __inner: extern "C" fn(HybridDictionary, crate::system::object::Object, ::unity::OptionalMethod) -> () =
456 ::core::mem::transmute(__vi.method_ptr);
457 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
458 __inner(__receiver, ::core::convert::Into::into(key), __mi)
459 }
460 }
461 }
462}
463
464#[cfg(feature = "system-collections-specialized-hybriddictionary")]
465impl<__T: IHybridDictionary> IHybridDictionaryMethods for __T {}
466
467#[cfg(feature = "system-collections-specialized-hybriddictionary")]
468impl HybridDictionary {
469 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
470 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
471 }
472
473 pub fn get_item_method_info() -> &'static ::unity::il2cpp::MethodInfo {
474 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
475 }
476
477 pub fn set_item_method_info() -> &'static ::unity::il2cpp::MethodInfo {
478 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
479 }
480
481 pub fn get_list_method_info() -> &'static ::unity::il2cpp::MethodInfo {
482 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
483 }
484
485 pub fn change_over_method_info() -> &'static ::unity::il2cpp::MethodInfo {
486 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
487 }
488
489 pub fn get_count_method_info() -> &'static ::unity::il2cpp::MethodInfo {
490 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
491 }
492
493 pub fn get_keys_method_info() -> &'static ::unity::il2cpp::MethodInfo {
494 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
495 }
496
497 pub fn get_is_read_only_method_info() -> &'static ::unity::il2cpp::MethodInfo {
498 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
499 }
500
501 pub fn get_is_fixed_size_method_info() -> &'static ::unity::il2cpp::MethodInfo {
502 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[8]
503 }
504
505 pub fn get_is_synchronized_method_info() -> &'static ::unity::il2cpp::MethodInfo {
506 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[9]
507 }
508
509 pub fn get_sync_root_method_info() -> &'static ::unity::il2cpp::MethodInfo {
510 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[10]
511 }
512
513 pub fn get_values_method_info() -> &'static ::unity::il2cpp::MethodInfo {
514 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[11]
515 }
516
517 pub fn add_method_info() -> &'static ::unity::il2cpp::MethodInfo {
518 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[12]
519 }
520
521 pub fn contains_method_info() -> &'static ::unity::il2cpp::MethodInfo {
522 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[13]
523 }
524
525 pub fn copy_to_method_info() -> &'static ::unity::il2cpp::MethodInfo {
526 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[14]
527 }
528
529 pub fn get_enumerator_method_info() -> &'static ::unity::il2cpp::MethodInfo {
530 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[15]
531 }
532
533 pub fn system_collections_i_enumerable_get_enumerator_method_info() -> &'static ::unity::il2cpp::MethodInfo {
534 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[16]
535 }
536
537 pub fn remove_method_info() -> &'static ::unity::il2cpp::MethodInfo {
538 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[17]
539 }
540}
541
542#[cfg(feature = "system-collections-specialized-hybriddictionary")]
543impl HybridDictionary {
544 #[doc = "Direct (non-virtual) call to `HybridDictionary`'s own `get_Item`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
545 pub unsafe fn get_item(
546 this: impl ::core::convert::Into<::unity::IlInstance>,
547 key: crate::system::object::Object,
548 ) -> crate::system::object::Object {
549 let __mi = Self::get_item_method_info();
550 let __inner: extern "C" fn(::unity::IlInstance, crate::system::object::Object, ::unity::OptionalMethod) -> crate::system::object::Object =
551 ::core::mem::transmute(__mi.method_ptr);
552 __inner(this.into(), key, ::core::option::Option::None)
553 }
554
555 #[doc = "Direct (non-virtual) call to `HybridDictionary`'s own `set_Item`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
556 pub unsafe fn set_item(
557 this: impl ::core::convert::Into<::unity::IlInstance>,
558 key: crate::system::object::Object,
559 value: crate::system::object::Object,
560 ) -> () {
561 let __mi = Self::set_item_method_info();
562 let __inner: extern "C" fn(::unity::IlInstance, crate::system::object::Object, crate::system::object::Object, ::unity::OptionalMethod) -> () =
563 ::core::mem::transmute(__mi.method_ptr);
564 __inner(this.into(), key, value, ::core::option::Option::None)
565 }
566
567 #[doc = "Direct (non-virtual) call to `HybridDictionary`'s own `get_Count`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
568 pub unsafe fn get_count(this: impl ::core::convert::Into<::unity::IlInstance>) -> i32 {
569 let __mi = Self::get_count_method_info();
570 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__mi.method_ptr);
571 __inner(this.into(), ::core::option::Option::None)
572 }
573
574 #[doc = "Direct (non-virtual) call to `HybridDictionary`'s own `get_Keys`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
575 pub unsafe fn get_keys(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::system::collections::icollection::ICollection {
576 let __mi = Self::get_keys_method_info();
577 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::system::collections::icollection::ICollection =
578 ::core::mem::transmute(__mi.method_ptr);
579 __inner(this.into(), ::core::option::Option::None)
580 }
581
582 #[doc = "Direct (non-virtual) call to `HybridDictionary`'s own `get_IsReadOnly`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
583 pub unsafe fn get_is_read_only(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
584 let __mi = Self::get_is_read_only_method_info();
585 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
586 __inner(this.into(), ::core::option::Option::None)
587 }
588
589 #[doc = "Direct (non-virtual) call to `HybridDictionary`'s own `get_IsFixedSize`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
590 pub unsafe fn get_is_fixed_size(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
591 let __mi = Self::get_is_fixed_size_method_info();
592 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
593 __inner(this.into(), ::core::option::Option::None)
594 }
595
596 #[doc = "Direct (non-virtual) call to `HybridDictionary`'s own `get_IsSynchronized`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
597 pub unsafe fn get_is_synchronized(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
598 let __mi = Self::get_is_synchronized_method_info();
599 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
600 __inner(this.into(), ::core::option::Option::None)
601 }
602
603 #[doc = "Direct (non-virtual) call to `HybridDictionary`'s own `get_SyncRoot`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
604 pub unsafe fn get_sync_root(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::system::object::Object {
605 let __mi = Self::get_sync_root_method_info();
606 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::system::object::Object =
607 ::core::mem::transmute(__mi.method_ptr);
608 __inner(this.into(), ::core::option::Option::None)
609 }
610
611 #[doc = "Direct (non-virtual) call to `HybridDictionary`'s own `get_Values`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
612 pub unsafe fn get_values(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::system::collections::icollection::ICollection {
613 let __mi = Self::get_values_method_info();
614 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::system::collections::icollection::ICollection =
615 ::core::mem::transmute(__mi.method_ptr);
616 __inner(this.into(), ::core::option::Option::None)
617 }
618
619 #[doc = "Direct (non-virtual) call to `HybridDictionary`'s own `Add`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
620 pub unsafe fn add(
621 this: impl ::core::convert::Into<::unity::IlInstance>,
622 key: crate::system::object::Object,
623 value: crate::system::object::Object,
624 ) -> () {
625 let __mi = Self::add_method_info();
626 let __inner: extern "C" fn(::unity::IlInstance, crate::system::object::Object, crate::system::object::Object, ::unity::OptionalMethod) -> () =
627 ::core::mem::transmute(__mi.method_ptr);
628 __inner(this.into(), key, value, ::core::option::Option::None)
629 }
630
631 #[doc = "Direct (non-virtual) call to `HybridDictionary`'s own `Contains`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
632 pub unsafe fn contains(this: impl ::core::convert::Into<::unity::IlInstance>, key: crate::system::object::Object) -> bool {
633 let __mi = Self::contains_method_info();
634 let __inner: extern "C" fn(::unity::IlInstance, crate::system::object::Object, ::unity::OptionalMethod) -> bool =
635 ::core::mem::transmute(__mi.method_ptr);
636 __inner(this.into(), key, ::core::option::Option::None)
637 }
638
639 #[doc = "Direct (non-virtual) call to `HybridDictionary`'s own `CopyTo`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
640 pub unsafe fn copy_to(this: impl ::core::convert::Into<::unity::IlInstance>, array: ::unity::IlInstance, index: i32) -> () {
641 let __mi = Self::copy_to_method_info();
642 let __inner: extern "C" fn(::unity::IlInstance, ::unity::IlInstance, i32, ::unity::OptionalMethod) -> () =
643 ::core::mem::transmute(__mi.method_ptr);
644 __inner(this.into(), array, index, ::core::option::Option::None)
645 }
646
647 #[doc = "Direct (non-virtual) call to `HybridDictionary`'s own `GetEnumerator`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
648 pub unsafe fn get_enumerator(
649 this: impl ::core::convert::Into<::unity::IlInstance>,
650 ) -> crate::system::collections::idictionaryenumerator::IDictionaryEnumerator {
651 let __mi = Self::get_enumerator_method_info();
652 let __inner: extern "C" fn(
653 ::unity::IlInstance,
654 ::unity::OptionalMethod,
655 ) -> crate::system::collections::idictionaryenumerator::IDictionaryEnumerator = ::core::mem::transmute(__mi.method_ptr);
656 __inner(this.into(), ::core::option::Option::None)
657 }
658
659 #[doc = "Direct (non-virtual) call to `HybridDictionary`'s own `System.Collections.IEnumerable.GetEnumerator`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
660 pub unsafe fn system_collections_i_enumerable_get_enumerator(
661 this: impl ::core::convert::Into<::unity::IlInstance>,
662 ) -> crate::system::collections::ienumerator::IEnumerator {
663 let __mi = Self::system_collections_i_enumerable_get_enumerator_method_info();
664 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::system::collections::ienumerator::IEnumerator =
665 ::core::mem::transmute(__mi.method_ptr);
666 __inner(this.into(), ::core::option::Option::None)
667 }
668
669 #[doc = "Direct (non-virtual) call to `HybridDictionary`'s own `Remove`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
670 pub unsafe fn remove(this: impl ::core::convert::Into<::unity::IlInstance>, key: crate::system::object::Object) -> () {
671 let __mi = Self::remove_method_info();
672 let __inner: extern "C" fn(::unity::IlInstance, crate::system::object::Object, ::unity::OptionalMethod) -> () =
673 ::core::mem::transmute(__mi.method_ptr);
674 __inner(this.into(), key, ::core::option::Option::None)
675 }
676}
677
678#[cfg(feature = "system-collections-specialized-hybriddictionary")]
679impl HybridDictionary {
680 #[doc = "`.ctor()` — no args"]
681 pub fn new() -> Self {
682 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
683 panic!(
684 "{}
685::{}
686 failed to instantiate",
687 ::core::stringify!(HybridDictionary),
688 ::core::stringify!(new),
689 )
690 });
691 <Self as IHybridDictionaryMethods>::ctor(this);
692 this
693 }
694}
695
696#[cfg(feature = "system-collections-specialized-hybriddictionary")]
697#[doc(hidden)]
698pub mod prelude {
699 pub use super::{HybridDictionary, IHybridDictionary, IHybridDictionaryMethods};
700 pub use crate::system::object::IObject;
701 #[cfg(feature = "system-object")]
702 pub use crate::system::object::IObjectMethods;
703}