1#[cfg(feature = "unity_engine-resource_management-async_operations-asyncoperationhandle-types")]
4mod __types {
5 #[allow(unused_imports)] use ::unity::prelude::*;
6
7 use super::*;
8 use crate::system::{
9 object::{IObject, Object},
10 valuetype::{IValueType, ValueType},
11 };
12
13 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/unity_engine/resource_management/async_operations/asyncoperationhandle/AsyncOperationHandle.md"))]
14 #[repr(C)]
15 #[derive(::core::clone::Clone, ::core::marker::Copy)]
16 pub struct AsyncOperationHandle {
17 pub m_internal_op: crate::unity_engine::resource_management::async_operations::iasyncoperation::IAsyncOperation,
18 pub m_version: i32,
19 pub m_location_name: ::unity::Il2CppString,
20 }
21 impl ::unity::ClassIdentity for AsyncOperationHandle {
22 const NAME: &'static str = "AsyncOperationHandle";
23 const NAMESPACE: &'static str = "UnityEngine.ResourceManagement.AsyncOperations";
24
25 fn class() -> ::unity::Class {
26 static CACHE: ::std::sync::OnceLock<::unity::Class> = ::std::sync::OnceLock::new();
27 *CACHE.get_or_init(|| ::unity::Class::lookup(Self::NAMESPACE, Self::NAME))
28 }
29 }
30 impl ::unity::IlType for AsyncOperationHandle {
31 fn il_type() -> &'static ::unity::il2cpp::Il2CppType {
32 &<Self as ::unity::ClassIdentity>::class().raw()._1.byval_arg
33 }
34 }
35 impl AsyncOperationHandle {
36 #[inline]
37 pub fn m_is_waiting_for_completion() -> bool {
38 static OFFSET: ::std::sync::OnceLock<usize> = ::std::sync::OnceLock::new();
39 let __offset = ::unity::cached_field_offset_static::<Self>(&OFFSET, "m_IsWaitingForCompletion");
40 ::unity::static_field_get_value_at_offset(<Self as ::unity::ClassIdentity>::class(), __offset)
41 }
42
43 #[inline]
44 pub fn set_m_is_waiting_for_completion(value: bool) {
45 static OFFSET: ::std::sync::OnceLock<usize> = ::std::sync::OnceLock::new();
46 let __offset = ::unity::cached_field_offset_static::<Self>(&OFFSET, "m_IsWaitingForCompletion");
47 ::unity::static_field_set_value_at_offset(<Self as ::unity::ClassIdentity>::class(), __offset, value);
48 }
49 }
50}
51
52#[cfg(feature = "unity_engine-resource_management-async_operations-asyncoperationhandle-types")]
53pub use __types::*;
54
55#[cfg(feature = "unity_engine-resource_management-async_operations-asyncoperationhandle")]
56#[doc(hidden)]
57#[allow(non_snake_case, non_camel_case_types, clippy::too_many_arguments)]
58mod __AsyncOperationHandle_unity_raw {
59 use super::*;
60 #[doc(hidden)]
61 #[allow(non_snake_case)]
62 pub mod __lookup_get_is_waiting_for_completion {
63 use super::*;
64 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
65 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
66 ::unity::lookup::method_info_on_class_with_signature(
67 <AsyncOperationHandle as ::unity::ClassIdentity>::class(),
68 "get_IsWaitingForCompletion",
69 0,
70 param_types,
71 true,
72 )
73 });
74 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
75 match &*METHOD {
76 ::core::result::Result::Ok(mi) => *mi,
77 ::core::result::Result::Err(e) => {
78 panic!(
79 "method lookup failed: {}
80::{}
81: {}
82",
83 <AsyncOperationHandle as ::unity::ClassIdentity>::NAME,
84 "get_IsWaitingForCompletion",
85 e
86 )
87 },
88 }
89 }
90 }
91 #[doc(hidden)]
92 #[allow(non_snake_case)]
93 pub mod __lookup_set_is_waiting_for_completion {
94 use super::*;
95 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
96 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[<bool as ::unity::IlType>::il_type()];
97 ::unity::lookup::method_info_on_class_with_signature(
98 <AsyncOperationHandle as ::unity::ClassIdentity>::class(),
99 "set_IsWaitingForCompletion",
100 1,
101 param_types,
102 true,
103 )
104 });
105 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
106 match &*METHOD {
107 ::core::result::Result::Ok(mi) => *mi,
108 ::core::result::Result::Err(e) => {
109 panic!(
110 "method lookup failed: {}
111::{}
112: {}
113",
114 <AsyncOperationHandle as ::unity::ClassIdentity>::NAME,
115 "set_IsWaitingForCompletion",
116 e
117 )
118 },
119 }
120 }
121 }
122 #[doc(hidden)]
123 #[allow(non_snake_case)]
124 pub mod __lookup_get_location_name {
125 use super::*;
126 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
127 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
128 ::unity::lookup::method_info_on_class_with_signature(
129 <AsyncOperationHandle as ::unity::ClassIdentity>::class(),
130 "get_LocationName",
131 0,
132 param_types,
133 false,
134 )
135 });
136 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
137 match &*METHOD {
138 ::core::result::Result::Ok(mi) => *mi,
139 ::core::result::Result::Err(e) => {
140 panic!(
141 "method lookup failed: {}
142::{}
143: {}
144",
145 <AsyncOperationHandle as ::unity::ClassIdentity>::NAME,
146 "get_LocationName",
147 e
148 )
149 },
150 }
151 }
152 }
153 #[doc(hidden)]
154 #[allow(non_snake_case)]
155 pub mod __lookup_set_location_name {
156 use super::*;
157 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
158 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[<::unity::Il2CppString as ::unity::IlType>::il_type()];
159 ::unity::lookup::method_info_on_class_with_signature(
160 <AsyncOperationHandle as ::unity::ClassIdentity>::class(),
161 "set_LocationName",
162 1,
163 param_types,
164 false,
165 )
166 });
167 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
168 match &*METHOD {
169 ::core::result::Result::Ok(mi) => *mi,
170 ::core::result::Result::Err(e) => {
171 panic!(
172 "method lookup failed: {}
173::{}
174: {}
175",
176 <AsyncOperationHandle as ::unity::ClassIdentity>::NAME,
177 "set_LocationName",
178 e
179 )
180 },
181 }
182 }
183 }
184 #[doc(hidden)]
185 #[allow(non_snake_case)]
186 pub mod __lookup_ctor {
187 use super::*;
188 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
189 let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
190 &[<crate::unity_engine::resource_management::async_operations::iasyncoperation::IAsyncOperation as ::unity::IlType>::il_type()];
191 ::unity::lookup::method_info_on_class_with_signature(
192 <AsyncOperationHandle as ::unity::ClassIdentity>::class(),
193 ".ctor",
194 1,
195 param_types,
196 false,
197 )
198 });
199 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
200 match &*METHOD {
201 ::core::result::Result::Ok(mi) => *mi,
202 ::core::result::Result::Err(e) => {
203 panic!(
204 "method lookup failed: {}
205::{}
206: {}
207",
208 <AsyncOperationHandle as ::unity::ClassIdentity>::NAME,
209 ".ctor",
210 e
211 )
212 },
213 }
214 }
215 }
216 #[doc(hidden)]
217 #[allow(non_snake_case)]
218 pub mod __lookup_ctor_2 {
219 use super::*;
220 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
221 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
222 <crate::unity_engine::resource_management::async_operations::iasyncoperation::IAsyncOperation as ::unity::IlType>::il_type(),
223 <i32 as ::unity::IlType>::il_type(),
224 ];
225 ::unity::lookup::method_info_on_class_with_signature(
226 <AsyncOperationHandle as ::unity::ClassIdentity>::class(),
227 ".ctor",
228 2,
229 param_types,
230 false,
231 )
232 });
233 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
234 match &*METHOD {
235 ::core::result::Result::Ok(mi) => *mi,
236 ::core::result::Result::Err(e) => {
237 panic!(
238 "method lookup failed: {}
239::{}
240: {}
241",
242 <AsyncOperationHandle as ::unity::ClassIdentity>::NAME,
243 ".ctor",
244 e
245 )
246 },
247 }
248 }
249 }
250 #[doc(hidden)]
251 #[allow(non_snake_case)]
252 pub mod __lookup_ctor_3 {
253 use super::*;
254 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
255 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
256 <crate::unity_engine::resource_management::async_operations::iasyncoperation::IAsyncOperation as ::unity::IlType>::il_type(),
257 <::unity::Il2CppString as ::unity::IlType>::il_type(),
258 ];
259 ::unity::lookup::method_info_on_class_with_signature(
260 <AsyncOperationHandle as ::unity::ClassIdentity>::class(),
261 ".ctor",
262 2,
263 param_types,
264 false,
265 )
266 });
267 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
268 match &*METHOD {
269 ::core::result::Result::Ok(mi) => *mi,
270 ::core::result::Result::Err(e) => {
271 panic!(
272 "method lookup failed: {}
273::{}
274: {}
275",
276 <AsyncOperationHandle as ::unity::ClassIdentity>::NAME,
277 ".ctor",
278 e
279 )
280 },
281 }
282 }
283 }
284 #[doc(hidden)]
285 #[allow(non_snake_case)]
286 pub mod __lookup_ctor_4 {
287 use super::*;
288 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
289 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
290 <crate::unity_engine::resource_management::async_operations::iasyncoperation::IAsyncOperation as ::unity::IlType>::il_type(),
291 <i32 as ::unity::IlType>::il_type(),
292 <::unity::Il2CppString as ::unity::IlType>::il_type(),
293 ];
294 ::unity::lookup::method_info_on_class_with_signature(
295 <AsyncOperationHandle as ::unity::ClassIdentity>::class(),
296 ".ctor",
297 3,
298 param_types,
299 false,
300 )
301 });
302 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
303 match &*METHOD {
304 ::core::result::Result::Ok(mi) => *mi,
305 ::core::result::Result::Err(e) => {
306 panic!(
307 "method lookup failed: {}
308::{}
309: {}
310",
311 <AsyncOperationHandle as ::unity::ClassIdentity>::NAME,
312 ".ctor",
313 e
314 )
315 },
316 }
317 }
318 }
319 #[doc(hidden)]
320 #[allow(non_snake_case)]
321 pub mod __lookup_acquire {
322 use super::*;
323 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
324 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
325 ::unity::lookup::method_info_on_class_with_signature(
326 <AsyncOperationHandle as ::unity::ClassIdentity>::class(),
327 "Acquire",
328 0,
329 param_types,
330 false,
331 )
332 });
333 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
334 match &*METHOD {
335 ::core::result::Result::Ok(mi) => *mi,
336 ::core::result::Result::Err(e) => {
337 panic!(
338 "method lookup failed: {}
339::{}
340: {}
341",
342 <AsyncOperationHandle as ::unity::ClassIdentity>::NAME,
343 "Acquire",
344 e
345 )
346 },
347 }
348 }
349 }
350 #[doc(hidden)]
351 #[allow(non_snake_case)]
352 pub mod __lookup_add_completed {
353 use super::*;
354 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
355 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[<crate::system::action_1::Action_1<
356 crate::unity_engine::resource_management::async_operations::asyncoperationhandle::AsyncOperationHandle,
357 > as ::unity::IlType>::il_type()];
358 ::unity::lookup::method_info_on_class_with_signature(
359 <AsyncOperationHandle as ::unity::ClassIdentity>::class(),
360 "add_Completed",
361 1,
362 param_types,
363 false,
364 )
365 });
366 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
367 match &*METHOD {
368 ::core::result::Result::Ok(mi) => *mi,
369 ::core::result::Result::Err(e) => {
370 panic!(
371 "method lookup failed: {}
372::{}
373: {}
374",
375 <AsyncOperationHandle as ::unity::ClassIdentity>::NAME,
376 "add_Completed",
377 e
378 )
379 },
380 }
381 }
382 }
383 #[doc(hidden)]
384 #[allow(non_snake_case)]
385 pub mod __lookup_remove_completed {
386 use super::*;
387 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
388 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[<crate::system::action_1::Action_1<
389 crate::unity_engine::resource_management::async_operations::asyncoperationhandle::AsyncOperationHandle,
390 > as ::unity::IlType>::il_type()];
391 ::unity::lookup::method_info_on_class_with_signature(
392 <AsyncOperationHandle as ::unity::ClassIdentity>::class(),
393 "remove_Completed",
394 1,
395 param_types,
396 false,
397 )
398 });
399 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
400 match &*METHOD {
401 ::core::result::Result::Ok(mi) => *mi,
402 ::core::result::Result::Err(e) => {
403 panic!(
404 "method lookup failed: {}
405::{}
406: {}
407",
408 <AsyncOperationHandle as ::unity::ClassIdentity>::NAME,
409 "remove_Completed",
410 e
411 )
412 },
413 }
414 }
415 }
416 #[doc(hidden)]
417 #[allow(non_snake_case)]
418 pub mod __lookup_equals {
419 use super::*;
420 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
421 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
422 <crate::unity_engine::resource_management::async_operations::asyncoperationhandle::AsyncOperationHandle as ::unity::IlType>::il_type(
423 ),
424 ];
425 ::unity::lookup::method_info_on_class_with_signature(
426 <AsyncOperationHandle as ::unity::ClassIdentity>::class(),
427 "Equals",
428 1,
429 param_types,
430 false,
431 )
432 });
433 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
434 match &*METHOD {
435 ::core::result::Result::Ok(mi) => *mi,
436 ::core::result::Result::Err(e) => {
437 panic!(
438 "method lookup failed: {}
439::{}
440: {}
441",
442 <AsyncOperationHandle as ::unity::ClassIdentity>::NAME,
443 "Equals",
444 e
445 )
446 },
447 }
448 }
449 }
450 #[doc(hidden)]
451 #[allow(non_snake_case)]
452 pub mod __lookup_get_debug_name {
453 use super::*;
454 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
455 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
456 ::unity::lookup::method_info_on_class_with_signature(
457 <AsyncOperationHandle as ::unity::ClassIdentity>::class(),
458 "get_DebugName",
459 0,
460 param_types,
461 false,
462 )
463 });
464 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
465 match &*METHOD {
466 ::core::result::Result::Ok(mi) => *mi,
467 ::core::result::Result::Err(e) => {
468 panic!(
469 "method lookup failed: {}
470::{}
471: {}
472",
473 <AsyncOperationHandle as ::unity::ClassIdentity>::NAME,
474 "get_DebugName",
475 e
476 )
477 },
478 }
479 }
480 }
481 #[doc(hidden)]
482 #[allow(non_snake_case)]
483 pub mod __lookup_add_destroyed {
484 use super::*;
485 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
486 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[<crate::system::action_1::Action_1<
487 crate::unity_engine::resource_management::async_operations::asyncoperationhandle::AsyncOperationHandle,
488 > as ::unity::IlType>::il_type()];
489 ::unity::lookup::method_info_on_class_with_signature(
490 <AsyncOperationHandle as ::unity::ClassIdentity>::class(),
491 "add_Destroyed",
492 1,
493 param_types,
494 false,
495 )
496 });
497 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
498 match &*METHOD {
499 ::core::result::Result::Ok(mi) => *mi,
500 ::core::result::Result::Err(e) => {
501 panic!(
502 "method lookup failed: {}
503::{}
504: {}
505",
506 <AsyncOperationHandle as ::unity::ClassIdentity>::NAME,
507 "add_Destroyed",
508 e
509 )
510 },
511 }
512 }
513 }
514 #[doc(hidden)]
515 #[allow(non_snake_case)]
516 pub mod __lookup_remove_destroyed {
517 use super::*;
518 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
519 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[<crate::system::action_1::Action_1<
520 crate::unity_engine::resource_management::async_operations::asyncoperationhandle::AsyncOperationHandle,
521 > as ::unity::IlType>::il_type()];
522 ::unity::lookup::method_info_on_class_with_signature(
523 <AsyncOperationHandle as ::unity::ClassIdentity>::class(),
524 "remove_Destroyed",
525 1,
526 param_types,
527 false,
528 )
529 });
530 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
531 match &*METHOD {
532 ::core::result::Result::Ok(mi) => *mi,
533 ::core::result::Result::Err(e) => {
534 panic!(
535 "method lookup failed: {}
536::{}
537: {}
538",
539 <AsyncOperationHandle as ::unity::ClassIdentity>::NAME,
540 "remove_Destroyed",
541 e
542 )
543 },
544 }
545 }
546 }
547 #[doc(hidden)]
548 #[allow(non_snake_case)]
549 pub mod __lookup_get_dependencies {
550 use super::*;
551 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
552 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[<crate::system::collections::generic::list_1::List_1<
553 crate::unity_engine::resource_management::async_operations::asyncoperationhandle::AsyncOperationHandle,
554 > as ::unity::IlType>::il_type()];
555 ::unity::lookup::method_info_on_class_with_signature(
556 <AsyncOperationHandle as ::unity::ClassIdentity>::class(),
557 "GetDependencies",
558 1,
559 param_types,
560 false,
561 )
562 });
563 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
564 match &*METHOD {
565 ::core::result::Result::Ok(mi) => *mi,
566 ::core::result::Result::Err(e) => {
567 panic!(
568 "method lookup failed: {}
569::{}
570: {}
571",
572 <AsyncOperationHandle as ::unity::ClassIdentity>::NAME,
573 "GetDependencies",
574 e
575 )
576 },
577 }
578 }
579 }
580 #[doc(hidden)]
581 #[allow(non_snake_case)]
582 pub mod __lookup_get_hash_code {
583 use super::*;
584 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
585 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
586 ::unity::lookup::method_info_on_class_with_signature(
587 <AsyncOperationHandle as ::unity::ClassIdentity>::class(),
588 "GetHashCode",
589 0,
590 param_types,
591 false,
592 )
593 });
594 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
595 match &*METHOD {
596 ::core::result::Result::Ok(mi) => *mi,
597 ::core::result::Result::Err(e) => {
598 panic!(
599 "method lookup failed: {}
600::{}
601: {}
602",
603 <AsyncOperationHandle as ::unity::ClassIdentity>::NAME,
604 "GetHashCode",
605 e
606 )
607 },
608 }
609 }
610 }
611 #[doc(hidden)]
612 #[allow(non_snake_case)]
613 pub mod __lookup_get_internal_op {
614 use super::*;
615 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
616 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
617 ::unity::lookup::method_info_on_class_with_signature(
618 <AsyncOperationHandle as ::unity::ClassIdentity>::class(),
619 "get_InternalOp",
620 0,
621 param_types,
622 false,
623 )
624 });
625 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
626 match &*METHOD {
627 ::core::result::Result::Ok(mi) => *mi,
628 ::core::result::Result::Err(e) => {
629 panic!(
630 "method lookup failed: {}
631::{}
632: {}
633",
634 <AsyncOperationHandle as ::unity::ClassIdentity>::NAME,
635 "get_InternalOp",
636 e
637 )
638 },
639 }
640 }
641 }
642 #[doc(hidden)]
643 #[allow(non_snake_case)]
644 pub mod __lookup_get_is_done {
645 use super::*;
646 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
647 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
648 ::unity::lookup::method_info_on_class_with_signature(
649 <AsyncOperationHandle as ::unity::ClassIdentity>::class(),
650 "get_IsDone",
651 0,
652 param_types,
653 false,
654 )
655 });
656 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
657 match &*METHOD {
658 ::core::result::Result::Ok(mi) => *mi,
659 ::core::result::Result::Err(e) => {
660 panic!(
661 "method lookup failed: {}
662::{}
663: {}
664",
665 <AsyncOperationHandle as ::unity::ClassIdentity>::NAME,
666 "get_IsDone",
667 e
668 )
669 },
670 }
671 }
672 }
673 #[doc(hidden)]
674 #[allow(non_snake_case)]
675 pub mod __lookup_is_valid {
676 use super::*;
677 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
678 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
679 ::unity::lookup::method_info_on_class_with_signature(
680 <AsyncOperationHandle as ::unity::ClassIdentity>::class(),
681 "IsValid",
682 0,
683 param_types,
684 false,
685 )
686 });
687 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
688 match &*METHOD {
689 ::core::result::Result::Ok(mi) => *mi,
690 ::core::result::Result::Err(e) => {
691 panic!(
692 "method lookup failed: {}
693::{}
694: {}
695",
696 <AsyncOperationHandle as ::unity::ClassIdentity>::NAME,
697 "IsValid",
698 e
699 )
700 },
701 }
702 }
703 }
704 #[doc(hidden)]
705 #[allow(non_snake_case)]
706 pub mod __lookup_get_percent_complete {
707 use super::*;
708 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
709 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
710 ::unity::lookup::method_info_on_class_with_signature(
711 <AsyncOperationHandle as ::unity::ClassIdentity>::class(),
712 "get_PercentComplete",
713 0,
714 param_types,
715 false,
716 )
717 });
718 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
719 match &*METHOD {
720 ::core::result::Result::Ok(mi) => *mi,
721 ::core::result::Result::Err(e) => {
722 panic!(
723 "method lookup failed: {}
724::{}
725: {}
726",
727 <AsyncOperationHandle as ::unity::ClassIdentity>::NAME,
728 "get_PercentComplete",
729 e
730 )
731 },
732 }
733 }
734 }
735 #[doc(hidden)]
736 #[allow(non_snake_case)]
737 pub mod __lookup_get_download_status {
738 use super::*;
739 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
740 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
741 ::unity::lookup::method_info_on_class_with_signature(
742 <AsyncOperationHandle as ::unity::ClassIdentity>::class(),
743 "GetDownloadStatus",
744 0,
745 param_types,
746 false,
747 )
748 });
749 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
750 match &*METHOD {
751 ::core::result::Result::Ok(mi) => *mi,
752 ::core::result::Result::Err(e) => {
753 panic!(
754 "method lookup failed: {}
755::{}
756: {}
757",
758 <AsyncOperationHandle as ::unity::ClassIdentity>::NAME,
759 "GetDownloadStatus",
760 e
761 )
762 },
763 }
764 }
765 }
766 #[doc(hidden)]
767 #[allow(non_snake_case)]
768 pub mod __lookup_internal_get_download_status {
769 use super::*;
770 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
771 let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
772 &[<crate::system::collections::generic::hashset_1::HashSet_1<crate::system::object::Object> as ::unity::IlType>::il_type()];
773 ::unity::lookup::method_info_on_class_with_signature(
774 <AsyncOperationHandle as ::unity::ClassIdentity>::class(),
775 "InternalGetDownloadStatus",
776 1,
777 param_types,
778 false,
779 )
780 });
781 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
782 match &*METHOD {
783 ::core::result::Result::Ok(mi) => *mi,
784 ::core::result::Result::Err(e) => {
785 panic!(
786 "method lookup failed: {}
787::{}
788: {}
789",
790 <AsyncOperationHandle as ::unity::ClassIdentity>::NAME,
791 "InternalGetDownloadStatus",
792 e
793 )
794 },
795 }
796 }
797 }
798 #[doc(hidden)]
799 #[allow(non_snake_case)]
800 pub mod __lookup_get_reference_count {
801 use super::*;
802 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
803 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
804 ::unity::lookup::method_info_on_class_with_signature(
805 <AsyncOperationHandle as ::unity::ClassIdentity>::class(),
806 "get_ReferenceCount",
807 0,
808 param_types,
809 false,
810 )
811 });
812 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
813 match &*METHOD {
814 ::core::result::Result::Ok(mi) => *mi,
815 ::core::result::Result::Err(e) => {
816 panic!(
817 "method lookup failed: {}
818::{}
819: {}
820",
821 <AsyncOperationHandle as ::unity::ClassIdentity>::NAME,
822 "get_ReferenceCount",
823 e
824 )
825 },
826 }
827 }
828 }
829 #[doc(hidden)]
830 #[allow(non_snake_case)]
831 pub mod __lookup_release {
832 use super::*;
833 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
834 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
835 ::unity::lookup::method_info_on_class_with_signature(
836 <AsyncOperationHandle as ::unity::ClassIdentity>::class(),
837 "Release",
838 0,
839 param_types,
840 false,
841 )
842 });
843 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
844 match &*METHOD {
845 ::core::result::Result::Ok(mi) => *mi,
846 ::core::result::Result::Err(e) => {
847 panic!(
848 "method lookup failed: {}
849::{}
850: {}
851",
852 <AsyncOperationHandle as ::unity::ClassIdentity>::NAME,
853 "Release",
854 e
855 )
856 },
857 }
858 }
859 }
860 #[doc(hidden)]
861 #[allow(non_snake_case)]
862 pub mod __lookup_get_result {
863 use super::*;
864 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
865 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
866 ::unity::lookup::method_info_on_class_with_signature(
867 <AsyncOperationHandle as ::unity::ClassIdentity>::class(),
868 "get_Result",
869 0,
870 param_types,
871 false,
872 )
873 });
874 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
875 match &*METHOD {
876 ::core::result::Result::Ok(mi) => *mi,
877 ::core::result::Result::Err(e) => {
878 panic!(
879 "method lookup failed: {}
880::{}
881: {}
882",
883 <AsyncOperationHandle as ::unity::ClassIdentity>::NAME,
884 "get_Result",
885 e
886 )
887 },
888 }
889 }
890 }
891 #[doc(hidden)]
892 #[allow(non_snake_case)]
893 pub mod __lookup_get_status {
894 use super::*;
895 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
896 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
897 ::unity::lookup::method_info_on_class_with_signature(
898 <AsyncOperationHandle as ::unity::ClassIdentity>::class(),
899 "get_Status",
900 0,
901 param_types,
902 false,
903 )
904 });
905 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
906 match &*METHOD {
907 ::core::result::Result::Ok(mi) => *mi,
908 ::core::result::Result::Err(e) => {
909 panic!(
910 "method lookup failed: {}
911::{}
912: {}
913",
914 <AsyncOperationHandle as ::unity::ClassIdentity>::NAME,
915 "get_Status",
916 e
917 )
918 },
919 }
920 }
921 }
922 #[doc(hidden)]
923 #[allow(non_snake_case)]
924 pub mod __lookup_system_collections_i_enumerator_get_current {
925 use super::*;
926 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
927 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
928 ::unity::lookup::method_info_on_class_with_signature(
929 <AsyncOperationHandle as ::unity::ClassIdentity>::class(),
930 "System.Collections.IEnumerator.get_Current",
931 0,
932 param_types,
933 false,
934 )
935 });
936 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
937 match &*METHOD {
938 ::core::result::Result::Ok(mi) => *mi,
939 ::core::result::Result::Err(e) => {
940 panic!(
941 "method lookup failed: {}
942::{}
943: {}
944",
945 <AsyncOperationHandle as ::unity::ClassIdentity>::NAME,
946 "System.Collections.IEnumerator.get_Current",
947 e
948 )
949 },
950 }
951 }
952 }
953 #[doc(hidden)]
954 #[allow(non_snake_case)]
955 pub mod __lookup_system_collections_i_enumerator_move_next {
956 use super::*;
957 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
958 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
959 ::unity::lookup::method_info_on_class_with_signature(
960 <AsyncOperationHandle as ::unity::ClassIdentity>::class(),
961 "System.Collections.IEnumerator.MoveNext",
962 0,
963 param_types,
964 false,
965 )
966 });
967 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
968 match &*METHOD {
969 ::core::result::Result::Ok(mi) => *mi,
970 ::core::result::Result::Err(e) => {
971 panic!(
972 "method lookup failed: {}
973::{}
974: {}
975",
976 <AsyncOperationHandle as ::unity::ClassIdentity>::NAME,
977 "System.Collections.IEnumerator.MoveNext",
978 e
979 )
980 },
981 }
982 }
983 }
984 #[doc(hidden)]
985 #[allow(non_snake_case)]
986 pub mod __lookup_system_collections_i_enumerator_reset {
987 use super::*;
988 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
989 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
990 ::unity::lookup::method_info_on_class_with_signature(
991 <AsyncOperationHandle as ::unity::ClassIdentity>::class(),
992 "System.Collections.IEnumerator.Reset",
993 0,
994 param_types,
995 false,
996 )
997 });
998 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
999 match &*METHOD {
1000 ::core::result::Result::Ok(mi) => *mi,
1001 ::core::result::Result::Err(e) => {
1002 panic!(
1003 "method lookup failed: {}
1004::{}
1005: {}
1006",
1007 <AsyncOperationHandle as ::unity::ClassIdentity>::NAME,
1008 "System.Collections.IEnumerator.Reset",
1009 e
1010 )
1011 },
1012 }
1013 }
1014 }
1015 #[doc(hidden)]
1016 #[allow(non_snake_case)]
1017 pub mod __lookup_wait_for_completion {
1018 use super::*;
1019 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1020 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
1021 ::unity::lookup::method_info_on_class_with_signature(
1022 <AsyncOperationHandle as ::unity::ClassIdentity>::class(),
1023 "WaitForCompletion",
1024 0,
1025 param_types,
1026 false,
1027 )
1028 });
1029 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1030 match &*METHOD {
1031 ::core::result::Result::Ok(mi) => *mi,
1032 ::core::result::Result::Err(e) => {
1033 panic!(
1034 "method lookup failed: {}
1035::{}
1036: {}
1037",
1038 <AsyncOperationHandle as ::unity::ClassIdentity>::NAME,
1039 "WaitForCompletion",
1040 e
1041 )
1042 },
1043 }
1044 }
1045 }
1046 #[doc(hidden)]
1047 #[allow(non_snake_case)]
1048 pub mod __lookup_cctor {
1049 use super::*;
1050 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1051 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
1052 ::unity::lookup::method_info_on_class_with_signature(
1053 <AsyncOperationHandle as ::unity::ClassIdentity>::class(),
1054 ".cctor",
1055 0,
1056 param_types,
1057 true,
1058 )
1059 });
1060 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1061 match &*METHOD {
1062 ::core::result::Result::Ok(mi) => *mi,
1063 ::core::result::Result::Err(e) => {
1064 panic!(
1065 "method lookup failed: {}
1066::{}
1067: {}
1068",
1069 <AsyncOperationHandle as ::unity::ClassIdentity>::NAME,
1070 ".cctor",
1071 e
1072 )
1073 },
1074 }
1075 }
1076 }
1077}
1078
1079#[cfg(feature = "unity_engine-resource_management-async_operations-asyncoperationhandle")]
1080impl AsyncOperationHandle {
1081 #[doc = "`get_IsWaitingForCompletion()` overload"]
1082 pub fn get_is_waiting_for_completion() -> bool {
1083 unsafe {
1084 ::unity::il2cpp_call!(__AsyncOperationHandle_unity_raw::__lookup_get_is_waiting_for_completion::get_method_info().method_ptr,bool;
1085 )
1086 }
1087 }
1088
1089 #[doc = "`set_IsWaitingForCompletion(bool)` overload"]
1090 pub fn set_is_waiting_for_completion(value: impl ::core::convert::Into<bool>) -> () {
1091 unsafe {
1092 ::unity::il2cpp_call!(__AsyncOperationHandle_unity_raw::__lookup_set_is_waiting_for_completion::get_method_info().method_ptr,();
1093(bool)::core::convert::Into::into(value))
1094 }
1095 }
1096
1097 #[doc = "`.cctor()` overload"]
1098 pub fn cctor() -> () {
1099 unsafe {
1100 ::unity::il2cpp_call!(__AsyncOperationHandle_unity_raw::__lookup_cctor::get_method_info().method_ptr,();
1101 )
1102 }
1103 }
1104}
1105
1106#[cfg(feature = "unity_engine-resource_management-async_operations-asyncoperationhandle")]
1107impl AsyncOperationHandle {
1108 #[doc = "`get_LocationName()` overload"]
1109 pub fn get_location_name(&mut self) -> ::unity::Il2CppString {
1110 unsafe {
1111 ::unity::il2cpp_call!(::unity::callable_ptr(__AsyncOperationHandle_unity_raw::__lookup_get_location_name::get_method_info().method_ptr), ::unity::Il2CppString;
1112(*mut AsyncOperationHandle)self as*mut AsyncOperationHandle)
1113 }
1114 }
1115
1116 #[doc = "`set_LocationName(::unity::Il2CppString)` overload"]
1117 pub fn set_location_name(&mut self, value: impl ::core::convert::Into<::unity::Il2CppString>) -> () {
1118 unsafe {
1119 ::unity::il2cpp_call!(::unity::callable_ptr(__AsyncOperationHandle_unity_raw::__lookup_set_location_name::get_method_info().method_ptr),();
1120(*mut AsyncOperationHandle)self as*mut AsyncOperationHandle,(::unity::Il2CppString)::core::convert::Into::into(value))
1121 }
1122 }
1123
1124 #[doc = "`.ctor(crate::unity_engine::resource_management::async_operations::iasyncoperation::IAsyncOperation)` overload"]
1125 pub fn ctor(
1126 &mut self,
1127 op: impl ::core::convert::Into<crate::unity_engine::resource_management::async_operations::iasyncoperation::IAsyncOperation>,
1128 ) -> () {
1129 unsafe {
1130 ::unity::il2cpp_call!(::unity::callable_ptr(__AsyncOperationHandle_unity_raw::__lookup_ctor::get_method_info().method_ptr),();
1131(*mut AsyncOperationHandle)self as*mut AsyncOperationHandle,(crate::unity_engine::resource_management::async_operations::iasyncoperation::IAsyncOperation)::core::convert::Into::into(op))
1132 }
1133 }
1134
1135 #[doc = "`.ctor(crate::unity_engine::resource_management::async_operations::iasyncoperation::IAsyncOperation, i32)` overload"]
1136 pub fn ctor_2(
1137 &mut self,
1138 op: impl ::core::convert::Into<crate::unity_engine::resource_management::async_operations::iasyncoperation::IAsyncOperation>,
1139 version: impl ::core::convert::Into<i32>,
1140 ) -> () {
1141 unsafe {
1142 ::unity::il2cpp_call!(::unity::callable_ptr(__AsyncOperationHandle_unity_raw::__lookup_ctor_2::get_method_info().method_ptr),();
1143(*mut AsyncOperationHandle)self as*mut AsyncOperationHandle,(crate::unity_engine::resource_management::async_operations::iasyncoperation::IAsyncOperation)::core::convert::Into::into(op),(i32)::core::convert::Into::into(version))
1144 }
1145 }
1146
1147 #[doc = "`.ctor(crate::unity_engine::resource_management::async_operations::iasyncoperation::IAsyncOperation, ::unity::Il2CppString)` overload"]
1148 pub fn ctor_3(
1149 &mut self,
1150 op: impl ::core::convert::Into<crate::unity_engine::resource_management::async_operations::iasyncoperation::IAsyncOperation>,
1151 location_name: impl ::core::convert::Into<::unity::Il2CppString>,
1152 ) -> () {
1153 unsafe {
1154 ::unity::il2cpp_call!(::unity::callable_ptr(__AsyncOperationHandle_unity_raw::__lookup_ctor_3::get_method_info().method_ptr),();
1155(*mut AsyncOperationHandle)self as*mut AsyncOperationHandle,(crate::unity_engine::resource_management::async_operations::iasyncoperation::IAsyncOperation)::core::convert::Into::into(op),(::unity::Il2CppString)::core::convert::Into::into(location_name))
1156 }
1157 }
1158
1159 #[doc = "`.ctor(crate::unity_engine::resource_management::async_operations::iasyncoperation::IAsyncOperation, i32, ::unity::Il2CppString)` overload"]
1160 pub fn ctor_4(
1161 &mut self,
1162 op: impl ::core::convert::Into<crate::unity_engine::resource_management::async_operations::iasyncoperation::IAsyncOperation>,
1163 version: impl ::core::convert::Into<i32>,
1164 location_name: impl ::core::convert::Into<::unity::Il2CppString>,
1165 ) -> () {
1166 unsafe {
1167 ::unity::il2cpp_call!(::unity::callable_ptr(__AsyncOperationHandle_unity_raw::__lookup_ctor_4::get_method_info().method_ptr),();
1168(*mut AsyncOperationHandle)self as*mut AsyncOperationHandle,(crate::unity_engine::resource_management::async_operations::iasyncoperation::IAsyncOperation)::core::convert::Into::into(op),(i32)::core::convert::Into::into(version),(::unity::Il2CppString)::core::convert::Into::into(location_name))
1169 }
1170 }
1171
1172 #[doc = "`Acquire()` overload"]
1173 pub fn acquire(&mut self) -> crate::unity_engine::resource_management::async_operations::asyncoperationhandle::AsyncOperationHandle {
1174 unsafe {
1175 ::unity::il2cpp_call!(::unity::callable_ptr(__AsyncOperationHandle_unity_raw::__lookup_acquire::get_method_info().method_ptr),crate::unity_engine::resource_management::async_operations::asyncoperationhandle::AsyncOperationHandle;
1176(*mut AsyncOperationHandle)self as*mut AsyncOperationHandle)
1177 }
1178 }
1179
1180 #[doc = "`add_Completed(crate::system::action_1::Action_1<crate::unity_engine::resource_management::async_operations::asyncoperationhandle::AsyncOperationHandle>)` overload"]
1181 pub fn add_completed(
1182 &mut self,
1183 value: impl ::core::convert::Into<
1184 crate::system::action_1::Action_1<crate::unity_engine::resource_management::async_operations::asyncoperationhandle::AsyncOperationHandle>,
1185 >,
1186 ) -> () {
1187 unsafe {
1188 ::unity::il2cpp_call!(::unity::callable_ptr(__AsyncOperationHandle_unity_raw::__lookup_add_completed::get_method_info().method_ptr),();
1189(*mut AsyncOperationHandle)self as*mut AsyncOperationHandle,(crate::system::action_1::Action_1<crate::unity_engine::resource_management::async_operations::asyncoperationhandle::AsyncOperationHandle>)::core::convert::Into::into(value))
1190 }
1191 }
1192
1193 #[doc = "`remove_Completed(crate::system::action_1::Action_1<crate::unity_engine::resource_management::async_operations::asyncoperationhandle::AsyncOperationHandle>)` overload"]
1194 pub fn remove_completed(
1195 &mut self,
1196 value: impl ::core::convert::Into<
1197 crate::system::action_1::Action_1<crate::unity_engine::resource_management::async_operations::asyncoperationhandle::AsyncOperationHandle>,
1198 >,
1199 ) -> () {
1200 unsafe {
1201 ::unity::il2cpp_call!(::unity::callable_ptr(__AsyncOperationHandle_unity_raw::__lookup_remove_completed::get_method_info().method_ptr),();
1202(*mut AsyncOperationHandle)self as*mut AsyncOperationHandle,(crate::system::action_1::Action_1<crate::unity_engine::resource_management::async_operations::asyncoperationhandle::AsyncOperationHandle>)::core::convert::Into::into(value))
1203 }
1204 }
1205
1206 pub fn convert<M0: ::unity::IlType + ::core::marker::Copy + ::unity::ClassIdentity>(
1207 &mut self,
1208 ) -> crate::unity_engine::resource_management::async_operations::asyncoperationhandle_1::AsyncOperationHandle_1<M0> {
1209 static OPEN: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1210 ::unity::lookup::method_info_on_class(<AsyncOperationHandle as ::unity::ClassIdentity>::class(), "Convert", 0)
1211 });
1212 #[allow(clippy::type_complexity)]
1213 static CACHE: ::std::sync::OnceLock<::std::sync::Mutex<::std::collections::HashMap<usize, &'static ::unity::il2cpp::MethodInfo>>> =
1214 ::std::sync::OnceLock::new();
1215 let _ = false;
1216 let __open: &'static ::unity::il2cpp::MethodInfo = match &*OPEN {
1217 ::core::result::Result::Ok(mi) => *mi,
1218 ::core::result::Result::Err(e) => {
1219 panic!(
1220 "method lookup failed: {}
1221::{}
1222: {}
1223",
1224 <AsyncOperationHandle as ::unity::ClassIdentity>::NAME,
1225 "Convert",
1226 e
1227 )
1228 },
1229 };
1230 let __cache = CACHE.get_or_init(|| ::std::sync::Mutex::new(::std::collections::HashMap::new()));
1231 let __key: usize = <M0 as ::unity::IlType>::il_type() as *const _ as usize;
1232 let __inflated: &'static ::unity::il2cpp::MethodInfo = {
1233 let mut __guard = __cache.lock().unwrap();
1234 *__guard
1235 .entry(__key)
1236 .or_insert_with(|| ::unity::il2cpp::generic::create_generic_method_info(__open, &[<M0 as ::unity::IlType>::il_type()]))
1237 };
1238 unsafe {
1239 let __f: extern "C" fn(
1240 *mut AsyncOperationHandle,
1241 ::unity::OptionalMethod,
1242 )
1243 -> crate::unity_engine::resource_management::async_operations::asyncoperationhandle_1::AsyncOperationHandle_1<M0> =
1244 ::core::mem::transmute(__inflated.method_ptr);
1245 let __mi_opaque: &'static () = &*(__inflated as *const _ as *const ());
1246 __f(self as *mut AsyncOperationHandle, ::core::option::Option::Some(__mi_opaque))
1247 }
1248 }
1249
1250 #[doc = "`Equals(crate::unity_engine::resource_management::async_operations::asyncoperationhandle::AsyncOperationHandle)` overload"]
1251 pub fn equals(
1252 &mut self,
1253 other: impl ::core::convert::Into<crate::unity_engine::resource_management::async_operations::asyncoperationhandle::AsyncOperationHandle>,
1254 ) -> bool {
1255 unsafe {
1256 ::unity::il2cpp_call!(::unity::callable_ptr(__AsyncOperationHandle_unity_raw::__lookup_equals::get_method_info().method_ptr),bool;
1257(*mut AsyncOperationHandle)self as*mut AsyncOperationHandle,(crate::unity_engine::resource_management::async_operations::asyncoperationhandle::AsyncOperationHandle)::core::convert::Into::into(other))
1258 }
1259 }
1260
1261 #[doc = "`get_DebugName()` overload"]
1262 pub fn get_debug_name(&mut self) -> ::unity::Il2CppString {
1263 unsafe {
1264 ::unity::il2cpp_call!(::unity::callable_ptr(__AsyncOperationHandle_unity_raw::__lookup_get_debug_name::get_method_info().method_ptr), ::unity::Il2CppString;
1265(*mut AsyncOperationHandle)self as*mut AsyncOperationHandle)
1266 }
1267 }
1268
1269 #[doc = "`add_Destroyed(crate::system::action_1::Action_1<crate::unity_engine::resource_management::async_operations::asyncoperationhandle::AsyncOperationHandle>)` overload"]
1270 pub fn add_destroyed(
1271 &mut self,
1272 value: impl ::core::convert::Into<
1273 crate::system::action_1::Action_1<crate::unity_engine::resource_management::async_operations::asyncoperationhandle::AsyncOperationHandle>,
1274 >,
1275 ) -> () {
1276 unsafe {
1277 ::unity::il2cpp_call!(::unity::callable_ptr(__AsyncOperationHandle_unity_raw::__lookup_add_destroyed::get_method_info().method_ptr),();
1278(*mut AsyncOperationHandle)self as*mut AsyncOperationHandle,(crate::system::action_1::Action_1<crate::unity_engine::resource_management::async_operations::asyncoperationhandle::AsyncOperationHandle>)::core::convert::Into::into(value))
1279 }
1280 }
1281
1282 #[doc = "`remove_Destroyed(crate::system::action_1::Action_1<crate::unity_engine::resource_management::async_operations::asyncoperationhandle::AsyncOperationHandle>)` overload"]
1283 pub fn remove_destroyed(
1284 &mut self,
1285 value: impl ::core::convert::Into<
1286 crate::system::action_1::Action_1<crate::unity_engine::resource_management::async_operations::asyncoperationhandle::AsyncOperationHandle>,
1287 >,
1288 ) -> () {
1289 unsafe {
1290 ::unity::il2cpp_call!(::unity::callable_ptr(__AsyncOperationHandle_unity_raw::__lookup_remove_destroyed::get_method_info().method_ptr),();
1291(*mut AsyncOperationHandle)self as*mut AsyncOperationHandle,(crate::system::action_1::Action_1<crate::unity_engine::resource_management::async_operations::asyncoperationhandle::AsyncOperationHandle>)::core::convert::Into::into(value))
1292 }
1293 }
1294
1295 #[doc = "`GetDependencies(crate::system::collections::generic::list_1::List_1<crate::unity_engine::resource_management::async_operations::asyncoperationhandle::AsyncOperationHandle>)` overload"]
1296 pub fn get_dependencies(
1297 &mut self,
1298 deps: impl ::core::convert::Into<
1299 crate::system::collections::generic::list_1::List_1<
1300 crate::unity_engine::resource_management::async_operations::asyncoperationhandle::AsyncOperationHandle,
1301 >,
1302 >,
1303 ) -> () {
1304 unsafe {
1305 ::unity::il2cpp_call!(::unity::callable_ptr(__AsyncOperationHandle_unity_raw::__lookup_get_dependencies::get_method_info().method_ptr),();
1306(*mut AsyncOperationHandle)self as*mut AsyncOperationHandle,(crate::system::collections::generic::list_1::List_1<crate::unity_engine::resource_management::async_operations::asyncoperationhandle::AsyncOperationHandle>)::core::convert::Into::into(deps))
1307 }
1308 }
1309
1310 #[doc = "`GetHashCode()` overload"]
1311 pub fn get_hash_code(&mut self) -> i32 {
1312 unsafe {
1313 ::unity::il2cpp_call!(::unity::callable_ptr(__AsyncOperationHandle_unity_raw::__lookup_get_hash_code::get_method_info().method_ptr),i32;
1314(*mut AsyncOperationHandle)self as*mut AsyncOperationHandle)
1315 }
1316 }
1317
1318 #[doc = "`get_InternalOp()` overload"]
1319 pub fn get_internal_op(&mut self) -> crate::unity_engine::resource_management::async_operations::iasyncoperation::IAsyncOperation {
1320 unsafe {
1321 ::unity::il2cpp_call!(::unity::callable_ptr(__AsyncOperationHandle_unity_raw::__lookup_get_internal_op::get_method_info().method_ptr),crate::unity_engine::resource_management::async_operations::iasyncoperation::IAsyncOperation;
1322(*mut AsyncOperationHandle)self as*mut AsyncOperationHandle)
1323 }
1324 }
1325
1326 #[doc = "`get_IsDone()` overload"]
1327 pub fn get_is_done(&mut self) -> bool {
1328 unsafe {
1329 ::unity::il2cpp_call!(::unity::callable_ptr(__AsyncOperationHandle_unity_raw::__lookup_get_is_done::get_method_info().method_ptr),bool;
1330(*mut AsyncOperationHandle)self as*mut AsyncOperationHandle)
1331 }
1332 }
1333
1334 #[doc = "`IsValid()` overload"]
1335 pub fn is_valid(&mut self) -> bool {
1336 unsafe {
1337 ::unity::il2cpp_call!(::unity::callable_ptr(__AsyncOperationHandle_unity_raw::__lookup_is_valid::get_method_info().method_ptr),bool;
1338(*mut AsyncOperationHandle)self as*mut AsyncOperationHandle)
1339 }
1340 }
1341
1342 #[doc = "`get_PercentComplete()` overload"]
1343 pub fn get_percent_complete(&mut self) -> f32 {
1344 unsafe {
1345 ::unity::il2cpp_call!(::unity::callable_ptr(__AsyncOperationHandle_unity_raw::__lookup_get_percent_complete::get_method_info().method_ptr),f32;
1346(*mut AsyncOperationHandle)self as*mut AsyncOperationHandle)
1347 }
1348 }
1349
1350 #[doc = "`GetDownloadStatus()` overload"]
1351 pub fn get_download_status(&mut self) -> crate::unity_engine::resource_management::async_operations::downloadstatus::DownloadStatus {
1352 unsafe {
1353 ::unity::il2cpp_call!(::unity::callable_ptr(__AsyncOperationHandle_unity_raw::__lookup_get_download_status::get_method_info().method_ptr),crate::unity_engine::resource_management::async_operations::downloadstatus::DownloadStatus;
1354(*mut AsyncOperationHandle)self as*mut AsyncOperationHandle)
1355 }
1356 }
1357
1358 #[doc = "`InternalGetDownloadStatus(crate::system::collections::generic::hashset_1::HashSet_1<crate::system::object::Object>)` overload"]
1359 pub fn internal_get_download_status(
1360 &mut self,
1361 visited: impl ::core::convert::Into<crate::system::collections::generic::hashset_1::HashSet_1<crate::system::object::Object>>,
1362 ) -> crate::unity_engine::resource_management::async_operations::downloadstatus::DownloadStatus {
1363 unsafe {
1364 ::unity::il2cpp_call!(::unity::callable_ptr(__AsyncOperationHandle_unity_raw::__lookup_internal_get_download_status::get_method_info().method_ptr),crate::unity_engine::resource_management::async_operations::downloadstatus::DownloadStatus;
1365(*mut AsyncOperationHandle)self as*mut AsyncOperationHandle,(crate::system::collections::generic::hashset_1::HashSet_1<crate::system::object::Object>)::core::convert::Into::into(visited))
1366 }
1367 }
1368
1369 #[doc = "`get_ReferenceCount()` overload"]
1370 pub fn get_reference_count(&mut self) -> i32 {
1371 unsafe {
1372 ::unity::il2cpp_call!(::unity::callable_ptr(__AsyncOperationHandle_unity_raw::__lookup_get_reference_count::get_method_info().method_ptr),i32;
1373(*mut AsyncOperationHandle)self as*mut AsyncOperationHandle)
1374 }
1375 }
1376
1377 #[doc = "`Release()` overload"]
1378 pub fn release(&mut self) -> () {
1379 unsafe {
1380 ::unity::il2cpp_call!(::unity::callable_ptr(__AsyncOperationHandle_unity_raw::__lookup_release::get_method_info().method_ptr),();
1381(*mut AsyncOperationHandle)self as*mut AsyncOperationHandle)
1382 }
1383 }
1384
1385 #[doc = "`get_Result()` overload"]
1386 pub fn get_result(&mut self) -> crate::system::object::Object {
1387 unsafe {
1388 ::unity::il2cpp_call!(::unity::callable_ptr(__AsyncOperationHandle_unity_raw::__lookup_get_result::get_method_info().method_ptr),crate::system::object::Object;
1389(*mut AsyncOperationHandle)self as*mut AsyncOperationHandle)
1390 }
1391 }
1392
1393 #[doc = "`get_Status()` overload"]
1394 pub fn get_status(&mut self) -> crate::unity_engine::resource_management::async_operations::asyncoperationstatus::AsyncOperationStatus {
1395 unsafe {
1396 ::unity::il2cpp_call!(::unity::callable_ptr(__AsyncOperationHandle_unity_raw::__lookup_get_status::get_method_info().method_ptr),crate::unity_engine::resource_management::async_operations::asyncoperationstatus::AsyncOperationStatus;
1397(*mut AsyncOperationHandle)self as*mut AsyncOperationHandle)
1398 }
1399 }
1400
1401 #[doc = "`System.Collections.IEnumerator.get_Current()` overload"]
1402 pub fn system_collections_i_enumerator_get_current(&mut self) -> crate::system::object::Object {
1403 unsafe {
1404 ::unity::il2cpp_call!(::unity::callable_ptr(__AsyncOperationHandle_unity_raw::__lookup_system_collections_i_enumerator_get_current::get_method_info().method_ptr),crate::system::object::Object;
1405(*mut AsyncOperationHandle)self as*mut AsyncOperationHandle)
1406 }
1407 }
1408
1409 #[doc = "`System.Collections.IEnumerator.MoveNext()` overload"]
1410 pub fn system_collections_i_enumerator_move_next(&mut self) -> bool {
1411 unsafe {
1412 ::unity::il2cpp_call!(::unity::callable_ptr(__AsyncOperationHandle_unity_raw::__lookup_system_collections_i_enumerator_move_next::get_method_info().method_ptr),bool;
1413(*mut AsyncOperationHandle)self as*mut AsyncOperationHandle)
1414 }
1415 }
1416
1417 #[doc = "`System.Collections.IEnumerator.Reset()` overload"]
1418 pub fn system_collections_i_enumerator_reset(&mut self) -> () {
1419 unsafe {
1420 ::unity::il2cpp_call!(::unity::callable_ptr(__AsyncOperationHandle_unity_raw::__lookup_system_collections_i_enumerator_reset::get_method_info().method_ptr),();
1421(*mut AsyncOperationHandle)self as*mut AsyncOperationHandle)
1422 }
1423 }
1424
1425 #[doc = "`WaitForCompletion()` overload"]
1426 pub fn wait_for_completion(&mut self) -> crate::system::object::Object {
1427 unsafe {
1428 ::unity::il2cpp_call!(::unity::callable_ptr(__AsyncOperationHandle_unity_raw::__lookup_wait_for_completion::get_method_info().method_ptr),crate::system::object::Object;
1429(*mut AsyncOperationHandle)self as*mut AsyncOperationHandle)
1430 }
1431 }
1432}
1433
1434#[cfg(feature = "unity_engine-resource_management-async_operations-asyncoperationhandle")]
1435impl AsyncOperationHandle {
1436 pub fn get_is_waiting_for_completion_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1437 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
1438 }
1439
1440 pub fn set_is_waiting_for_completion_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1441 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
1442 }
1443
1444 pub fn get_location_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1445 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
1446 }
1447
1448 pub fn set_location_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1449 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
1450 }
1451
1452 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1453 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
1454 }
1455
1456 pub fn ctor_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1457 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
1458 }
1459
1460 pub fn ctor_3_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1461 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
1462 }
1463
1464 pub fn ctor_4_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1465 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
1466 }
1467
1468 pub fn acquire_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1469 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[8]
1470 }
1471
1472 pub fn add_completed_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1473 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[9]
1474 }
1475
1476 pub fn remove_completed_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1477 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[10]
1478 }
1479
1480 pub fn equals_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1481 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[12]
1482 }
1483
1484 pub fn get_debug_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1485 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[13]
1486 }
1487
1488 pub fn add_destroyed_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1489 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[14]
1490 }
1491
1492 pub fn remove_destroyed_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1493 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[15]
1494 }
1495
1496 pub fn get_dependencies_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1497 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[16]
1498 }
1499
1500 pub fn get_hash_code_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1501 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[17]
1502 }
1503
1504 pub fn get_internal_op_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1505 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[18]
1506 }
1507
1508 pub fn get_is_done_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1509 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[19]
1510 }
1511
1512 pub fn is_valid_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1513 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[20]
1514 }
1515
1516 pub fn get_percent_complete_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1517 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[22]
1518 }
1519
1520 pub fn get_download_status_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1521 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[23]
1522 }
1523
1524 pub fn internal_get_download_status_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1525 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[24]
1526 }
1527
1528 pub fn get_reference_count_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1529 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[25]
1530 }
1531
1532 pub fn release_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1533 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[26]
1534 }
1535
1536 pub fn get_result_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1537 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[27]
1538 }
1539
1540 pub fn get_status_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1541 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[28]
1542 }
1543
1544 pub fn system_collections_i_enumerator_get_current_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1545 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[30]
1546 }
1547
1548 pub fn system_collections_i_enumerator_move_next_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1549 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[31]
1550 }
1551
1552 pub fn system_collections_i_enumerator_reset_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1553 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[32]
1554 }
1555
1556 pub fn wait_for_completion_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1557 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[33]
1558 }
1559
1560 pub fn cctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1561 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[34]
1562 }
1563}
1564
1565#[cfg(feature = "unity_engine-resource_management-async_operations-asyncoperationhandle")]
1566#[doc(hidden)]
1567pub mod prelude {
1568 pub use super::AsyncOperationHandle;
1569 #[cfg(feature = "system-object")]
1570 pub use crate::system::object::IObjectMethods;
1571 #[cfg(feature = "system-valuetype")]
1572 pub use crate::system::valuetype::IValueTypeMethods;
1573 pub use crate::system::{object::IObject, valuetype::IValueType};
1574}