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