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