1#[cfg(feature = "app-sortgeneric-types")]
4mod __types {
5 #[allow(unused_imports)] use ::unity::prelude::*;
6
7 use super::*;
8 use crate::{
9 app::sortconstant::{ISortConstant, SortConstant},
10 system::object::{IObject, Object},
11 };
12
13 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/sortgeneric/SortGeneric.md"))]
14 #[::unity::class(namespace = "App", name = "SortGeneric")]
15 #[parent(crate::app::sortconstant::SortConstant)]
16 pub struct SortGeneric {}
17
18 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/sortgeneric/SortGeneric_DelegateComparer_1.md"))]
19 #[::unity::class(namespace = "App", name = "SortGeneric.DelegateComparer`1")]
20 #[parent(crate::system::object::Object)]
21 pub struct SortGeneric_DelegateComparer_1<T0: ::unity::ClassIdentity> {
22 #[rename(name = "m_Comparison")]
23 pub m_comparison: crate::system::comparison_1::Comparison_1<T0>,
24 }
25
26 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/sortgeneric/SortGeneric_ElementComparer_1.md"))]
27 #[::unity::class(namespace = "App", name = "SortGeneric.ElementComparer`1")]
28 #[parent(crate::system::object::Object)]
29 pub struct SortGeneric_ElementComparer_1<T0: ::unity::ClassIdentity> {}
30}
31
32#[cfg(feature = "app-sortgeneric-types")]
33pub use __types::*;
34
35#[cfg(feature = "app-sortgeneric")]
36impl SortGeneric {
37 pub fn insertion_sort<M0: ::unity::IlType + ::core::marker::Copy + ::unity::ClassIdentity>(
38 list: impl ::core::convert::Into<crate::system::collections::generic::ilist_1_interface::IList_1_Interface<M0>>,
39 comparison: impl ::core::convert::Into<crate::system::comparison_1::Comparison_1<M0>>,
40 ) -> () {
41 static OPEN: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
42 ::unity::lookup::method_info_on_class(<SortGeneric as ::unity::ClassIdentity>::class(), "InsertionSort", 2)
43 });
44 #[allow(clippy::type_complexity)]
45 static CACHE: ::std::sync::OnceLock<::std::sync::Mutex<::std::collections::HashMap<usize, &'static ::unity::il2cpp::MethodInfo>>> =
46 ::std::sync::OnceLock::new();
47 let _ = true;
48 let __open: &'static ::unity::il2cpp::MethodInfo = match &*OPEN {
49 ::core::result::Result::Ok(mi) => *mi,
50 ::core::result::Result::Err(e) => {
51 panic!(
52 "method lookup failed: {}
53::{}
54: {}
55",
56 <SortGeneric as ::unity::ClassIdentity>::NAME,
57 "InsertionSort",
58 e
59 )
60 },
61 };
62 let __cache = CACHE.get_or_init(|| ::std::sync::Mutex::new(::std::collections::HashMap::new()));
63 let __key: usize = <M0 as ::unity::IlType>::il_type() as *const _ as usize;
64 let __inflated: &'static ::unity::il2cpp::MethodInfo = {
65 let mut __guard = __cache.lock().unwrap();
66 *__guard
67 .entry(__key)
68 .or_insert_with(|| ::unity::il2cpp::generic::create_generic_method_info(__open, &[<M0 as ::unity::IlType>::il_type()]))
69 };
70 unsafe {
71 let __f: extern "C" fn(
72 crate::system::collections::generic::ilist_1_interface::IList_1_Interface<M0>,
73 crate::system::comparison_1::Comparison_1<M0>,
74 ::unity::OptionalMethod,
75 ) -> () = ::core::mem::transmute(__inflated.method_ptr);
76 let __mi_opaque: &'static () = &*(__inflated as *const _ as *const ());
77 __f(
78 ::core::convert::Into::into(list),
79 ::core::convert::Into::into(comparison),
80 ::core::option::Option::Some(__mi_opaque),
81 )
82 }
83 }
84
85 pub fn insertion_sort_2<M0: ::unity::IlType + ::core::marker::Copy + ::unity::ClassIdentity>(
86 list: impl ::core::convert::Into<crate::system::collections::generic::ilist_1_interface::IList_1_Interface<M0>>,
87 ) -> () {
88 static OPEN: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
89 ::unity::lookup::method_info_on_class(<SortGeneric as ::unity::ClassIdentity>::class(), "InsertionSort", 1)
90 });
91 #[allow(clippy::type_complexity)]
92 static CACHE: ::std::sync::OnceLock<::std::sync::Mutex<::std::collections::HashMap<usize, &'static ::unity::il2cpp::MethodInfo>>> =
93 ::std::sync::OnceLock::new();
94 let _ = true;
95 let __open: &'static ::unity::il2cpp::MethodInfo = match &*OPEN {
96 ::core::result::Result::Ok(mi) => *mi,
97 ::core::result::Result::Err(e) => {
98 panic!(
99 "method lookup failed: {}
100::{}
101: {}
102",
103 <SortGeneric as ::unity::ClassIdentity>::NAME,
104 "InsertionSort",
105 e
106 )
107 },
108 };
109 let __cache = CACHE.get_or_init(|| ::std::sync::Mutex::new(::std::collections::HashMap::new()));
110 let __key: usize = <M0 as ::unity::IlType>::il_type() as *const _ as usize;
111 let __inflated: &'static ::unity::il2cpp::MethodInfo = {
112 let mut __guard = __cache.lock().unwrap();
113 *__guard
114 .entry(__key)
115 .or_insert_with(|| ::unity::il2cpp::generic::create_generic_method_info(__open, &[<M0 as ::unity::IlType>::il_type()]))
116 };
117 unsafe {
118 let __f: extern "C" fn(crate::system::collections::generic::ilist_1_interface::IList_1_Interface<M0>, ::unity::OptionalMethod) -> () =
119 ::core::mem::transmute(__inflated.method_ptr);
120 let __mi_opaque: &'static () = &*(__inflated as *const _ as *const ());
121 __f(::core::convert::Into::into(list), ::core::option::Option::Some(__mi_opaque))
122 }
123 }
124
125 pub fn insertion_sort_3<M0: ::unity::IlType + ::core::marker::Copy + ::unity::ClassIdentity>(
126 list: impl ::core::convert::Into<crate::system::collections::generic::ilist_1_interface::IList_1_Interface<M0>>,
127 comparer: impl ::core::convert::Into<crate::system::collections::generic::icomparer_1_interface::IComparer_1_Interface<M0>>,
128 ) -> () {
129 static OPEN: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
130 ::unity::lookup::method_info_on_class(<SortGeneric as ::unity::ClassIdentity>::class(), "InsertionSort", 2)
131 });
132 #[allow(clippy::type_complexity)]
133 static CACHE: ::std::sync::OnceLock<::std::sync::Mutex<::std::collections::HashMap<usize, &'static ::unity::il2cpp::MethodInfo>>> =
134 ::std::sync::OnceLock::new();
135 let _ = true;
136 let __open: &'static ::unity::il2cpp::MethodInfo = match &*OPEN {
137 ::core::result::Result::Ok(mi) => *mi,
138 ::core::result::Result::Err(e) => {
139 panic!(
140 "method lookup failed: {}
141::{}
142: {}
143",
144 <SortGeneric as ::unity::ClassIdentity>::NAME,
145 "InsertionSort",
146 e
147 )
148 },
149 };
150 let __cache = CACHE.get_or_init(|| ::std::sync::Mutex::new(::std::collections::HashMap::new()));
151 let __key: usize = <M0 as ::unity::IlType>::il_type() as *const _ as usize;
152 let __inflated: &'static ::unity::il2cpp::MethodInfo = {
153 let mut __guard = __cache.lock().unwrap();
154 *__guard
155 .entry(__key)
156 .or_insert_with(|| ::unity::il2cpp::generic::create_generic_method_info(__open, &[<M0 as ::unity::IlType>::il_type()]))
157 };
158 unsafe {
159 let __f: extern "C" fn(
160 crate::system::collections::generic::ilist_1_interface::IList_1_Interface<M0>,
161 crate::system::collections::generic::icomparer_1_interface::IComparer_1_Interface<M0>,
162 ::unity::OptionalMethod,
163 ) -> () = ::core::mem::transmute(__inflated.method_ptr);
164 let __mi_opaque: &'static () = &*(__inflated as *const _ as *const ());
165 __f(
166 ::core::convert::Into::into(list),
167 ::core::convert::Into::into(comparer),
168 ::core::option::Option::Some(__mi_opaque),
169 )
170 }
171 }
172
173 pub fn insertion_sort_partly<M0: ::unity::IlType + ::core::marker::Copy + ::unity::ClassIdentity>(
174 list: impl ::core::convert::Into<crate::system::collections::generic::ilist_1_interface::IList_1_Interface<M0>>,
175 first: impl ::core::convert::Into<i32>,
176 last: impl ::core::convert::Into<i32>,
177 comparer: impl ::core::convert::Into<crate::system::collections::generic::icomparer_1_interface::IComparer_1_Interface<M0>>,
178 ) -> () {
179 static OPEN: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
180 ::unity::lookup::method_info_on_class(<SortGeneric as ::unity::ClassIdentity>::class(), "InsertionSortPartly", 4)
181 });
182 #[allow(clippy::type_complexity)]
183 static CACHE: ::std::sync::OnceLock<::std::sync::Mutex<::std::collections::HashMap<usize, &'static ::unity::il2cpp::MethodInfo>>> =
184 ::std::sync::OnceLock::new();
185 let _ = true;
186 let __open: &'static ::unity::il2cpp::MethodInfo = match &*OPEN {
187 ::core::result::Result::Ok(mi) => *mi,
188 ::core::result::Result::Err(e) => {
189 panic!(
190 "method lookup failed: {}
191::{}
192: {}
193",
194 <SortGeneric as ::unity::ClassIdentity>::NAME,
195 "InsertionSortPartly",
196 e
197 )
198 },
199 };
200 let __cache = CACHE.get_or_init(|| ::std::sync::Mutex::new(::std::collections::HashMap::new()));
201 let __key: usize = <M0 as ::unity::IlType>::il_type() as *const _ as usize;
202 let __inflated: &'static ::unity::il2cpp::MethodInfo = {
203 let mut __guard = __cache.lock().unwrap();
204 *__guard
205 .entry(__key)
206 .or_insert_with(|| ::unity::il2cpp::generic::create_generic_method_info(__open, &[<M0 as ::unity::IlType>::il_type()]))
207 };
208 unsafe {
209 let __f: extern "C" fn(
210 crate::system::collections::generic::ilist_1_interface::IList_1_Interface<M0>,
211 i32,
212 i32,
213 crate::system::collections::generic::icomparer_1_interface::IComparer_1_Interface<M0>,
214 ::unity::OptionalMethod,
215 ) -> () = ::core::mem::transmute(__inflated.method_ptr);
216 let __mi_opaque: &'static () = &*(__inflated as *const _ as *const ());
217 __f(
218 ::core::convert::Into::into(list),
219 ::core::convert::Into::into(first),
220 ::core::convert::Into::into(last),
221 ::core::convert::Into::into(comparer),
222 ::core::option::Option::Some(__mi_opaque),
223 )
224 }
225 }
226
227 pub fn merge_sort<M0: ::unity::IlType + ::core::marker::Copy + ::unity::ClassIdentity>(
228 list: impl ::core::convert::Into<crate::system::collections::generic::ilist_1_interface::IList_1_Interface<M0>>,
229 comparison: impl ::core::convert::Into<crate::system::comparison_1::Comparison_1<M0>>,
230 ) -> () {
231 static OPEN: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> =
232 ::std::sync::LazyLock::new(|| ::unity::lookup::method_info_on_class(<SortGeneric as ::unity::ClassIdentity>::class(), "MergeSort", 2));
233 #[allow(clippy::type_complexity)]
234 static CACHE: ::std::sync::OnceLock<::std::sync::Mutex<::std::collections::HashMap<usize, &'static ::unity::il2cpp::MethodInfo>>> =
235 ::std::sync::OnceLock::new();
236 let _ = true;
237 let __open: &'static ::unity::il2cpp::MethodInfo = match &*OPEN {
238 ::core::result::Result::Ok(mi) => *mi,
239 ::core::result::Result::Err(e) => {
240 panic!(
241 "method lookup failed: {}
242::{}
243: {}
244",
245 <SortGeneric as ::unity::ClassIdentity>::NAME,
246 "MergeSort",
247 e
248 )
249 },
250 };
251 let __cache = CACHE.get_or_init(|| ::std::sync::Mutex::new(::std::collections::HashMap::new()));
252 let __key: usize = <M0 as ::unity::IlType>::il_type() as *const _ as usize;
253 let __inflated: &'static ::unity::il2cpp::MethodInfo = {
254 let mut __guard = __cache.lock().unwrap();
255 *__guard
256 .entry(__key)
257 .or_insert_with(|| ::unity::il2cpp::generic::create_generic_method_info(__open, &[<M0 as ::unity::IlType>::il_type()]))
258 };
259 unsafe {
260 let __f: extern "C" fn(
261 crate::system::collections::generic::ilist_1_interface::IList_1_Interface<M0>,
262 crate::system::comparison_1::Comparison_1<M0>,
263 ::unity::OptionalMethod,
264 ) -> () = ::core::mem::transmute(__inflated.method_ptr);
265 let __mi_opaque: &'static () = &*(__inflated as *const _ as *const ());
266 __f(
267 ::core::convert::Into::into(list),
268 ::core::convert::Into::into(comparison),
269 ::core::option::Option::Some(__mi_opaque),
270 )
271 }
272 }
273
274 pub fn merge_sort_2<M0: ::unity::IlType + ::core::marker::Copy + ::unity::ClassIdentity>(
275 list: impl ::core::convert::Into<crate::system::collections::generic::ilist_1_interface::IList_1_Interface<M0>>,
276 ) -> () {
277 static OPEN: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> =
278 ::std::sync::LazyLock::new(|| ::unity::lookup::method_info_on_class(<SortGeneric as ::unity::ClassIdentity>::class(), "MergeSort", 1));
279 #[allow(clippy::type_complexity)]
280 static CACHE: ::std::sync::OnceLock<::std::sync::Mutex<::std::collections::HashMap<usize, &'static ::unity::il2cpp::MethodInfo>>> =
281 ::std::sync::OnceLock::new();
282 let _ = true;
283 let __open: &'static ::unity::il2cpp::MethodInfo = match &*OPEN {
284 ::core::result::Result::Ok(mi) => *mi,
285 ::core::result::Result::Err(e) => {
286 panic!(
287 "method lookup failed: {}
288::{}
289: {}
290",
291 <SortGeneric as ::unity::ClassIdentity>::NAME,
292 "MergeSort",
293 e
294 )
295 },
296 };
297 let __cache = CACHE.get_or_init(|| ::std::sync::Mutex::new(::std::collections::HashMap::new()));
298 let __key: usize = <M0 as ::unity::IlType>::il_type() as *const _ as usize;
299 let __inflated: &'static ::unity::il2cpp::MethodInfo = {
300 let mut __guard = __cache.lock().unwrap();
301 *__guard
302 .entry(__key)
303 .or_insert_with(|| ::unity::il2cpp::generic::create_generic_method_info(__open, &[<M0 as ::unity::IlType>::il_type()]))
304 };
305 unsafe {
306 let __f: extern "C" fn(crate::system::collections::generic::ilist_1_interface::IList_1_Interface<M0>, ::unity::OptionalMethod) -> () =
307 ::core::mem::transmute(__inflated.method_ptr);
308 let __mi_opaque: &'static () = &*(__inflated as *const _ as *const ());
309 __f(::core::convert::Into::into(list), ::core::option::Option::Some(__mi_opaque))
310 }
311 }
312
313 pub fn merge_sort_3<M0: ::unity::IlType + ::core::marker::Copy + ::unity::ClassIdentity>(
314 list: impl ::core::convert::Into<crate::system::collections::generic::ilist_1_interface::IList_1_Interface<M0>>,
315 comparer: impl ::core::convert::Into<crate::system::collections::generic::icomparer_1_interface::IComparer_1_Interface<M0>>,
316 ) -> () {
317 static OPEN: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> =
318 ::std::sync::LazyLock::new(|| ::unity::lookup::method_info_on_class(<SortGeneric as ::unity::ClassIdentity>::class(), "MergeSort", 2));
319 #[allow(clippy::type_complexity)]
320 static CACHE: ::std::sync::OnceLock<::std::sync::Mutex<::std::collections::HashMap<usize, &'static ::unity::il2cpp::MethodInfo>>> =
321 ::std::sync::OnceLock::new();
322 let _ = true;
323 let __open: &'static ::unity::il2cpp::MethodInfo = match &*OPEN {
324 ::core::result::Result::Ok(mi) => *mi,
325 ::core::result::Result::Err(e) => {
326 panic!(
327 "method lookup failed: {}
328::{}
329: {}
330",
331 <SortGeneric as ::unity::ClassIdentity>::NAME,
332 "MergeSort",
333 e
334 )
335 },
336 };
337 let __cache = CACHE.get_or_init(|| ::std::sync::Mutex::new(::std::collections::HashMap::new()));
338 let __key: usize = <M0 as ::unity::IlType>::il_type() as *const _ as usize;
339 let __inflated: &'static ::unity::il2cpp::MethodInfo = {
340 let mut __guard = __cache.lock().unwrap();
341 *__guard
342 .entry(__key)
343 .or_insert_with(|| ::unity::il2cpp::generic::create_generic_method_info(__open, &[<M0 as ::unity::IlType>::il_type()]))
344 };
345 unsafe {
346 let __f: extern "C" fn(
347 crate::system::collections::generic::ilist_1_interface::IList_1_Interface<M0>,
348 crate::system::collections::generic::icomparer_1_interface::IComparer_1_Interface<M0>,
349 ::unity::OptionalMethod,
350 ) -> () = ::core::mem::transmute(__inflated.method_ptr);
351 let __mi_opaque: &'static () = &*(__inflated as *const _ as *const ());
352 __f(
353 ::core::convert::Into::into(list),
354 ::core::convert::Into::into(comparer),
355 ::core::option::Option::Some(__mi_opaque),
356 )
357 }
358 }
359
360 pub fn merge_sort_partly<M0: ::unity::IlType + ::core::marker::Copy + ::unity::ClassIdentity>(
361 list: impl ::core::convert::Into<crate::system::collections::generic::ilist_1_interface::IList_1_Interface<M0>>,
362 begin: impl ::core::convert::Into<i32>,
363 end: impl ::core::convert::Into<i32>,
364 work: impl ::core::convert::Into<::unity::Array<M0>>,
365 comparer: impl ::core::convert::Into<crate::system::collections::generic::icomparer_1_interface::IComparer_1_Interface<M0>>,
366 ) -> () {
367 static OPEN: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
368 ::unity::lookup::method_info_on_class(<SortGeneric as ::unity::ClassIdentity>::class(), "MergeSortPartly", 5)
369 });
370 #[allow(clippy::type_complexity)]
371 static CACHE: ::std::sync::OnceLock<::std::sync::Mutex<::std::collections::HashMap<usize, &'static ::unity::il2cpp::MethodInfo>>> =
372 ::std::sync::OnceLock::new();
373 let _ = true;
374 let __open: &'static ::unity::il2cpp::MethodInfo = match &*OPEN {
375 ::core::result::Result::Ok(mi) => *mi,
376 ::core::result::Result::Err(e) => {
377 panic!(
378 "method lookup failed: {}
379::{}
380: {}
381",
382 <SortGeneric as ::unity::ClassIdentity>::NAME,
383 "MergeSortPartly",
384 e
385 )
386 },
387 };
388 let __cache = CACHE.get_or_init(|| ::std::sync::Mutex::new(::std::collections::HashMap::new()));
389 let __key: usize = <M0 as ::unity::IlType>::il_type() as *const _ as usize;
390 let __inflated: &'static ::unity::il2cpp::MethodInfo = {
391 let mut __guard = __cache.lock().unwrap();
392 *__guard
393 .entry(__key)
394 .or_insert_with(|| ::unity::il2cpp::generic::create_generic_method_info(__open, &[<M0 as ::unity::IlType>::il_type()]))
395 };
396 unsafe {
397 let __f: extern "C" fn(
398 crate::system::collections::generic::ilist_1_interface::IList_1_Interface<M0>,
399 i32,
400 i32,
401 ::unity::Array<M0>,
402 crate::system::collections::generic::icomparer_1_interface::IComparer_1_Interface<M0>,
403 ::unity::OptionalMethod,
404 ) -> () = ::core::mem::transmute(__inflated.method_ptr);
405 let __mi_opaque: &'static () = &*(__inflated as *const _ as *const ());
406 __f(
407 ::core::convert::Into::into(list),
408 ::core::convert::Into::into(begin),
409 ::core::convert::Into::into(end),
410 ::core::convert::Into::into(work),
411 ::core::convert::Into::into(comparer),
412 ::core::option::Option::Some(__mi_opaque),
413 )
414 }
415 }
416
417 pub fn merge_sort_merge<M0: ::unity::IlType + ::core::marker::Copy + ::unity::ClassIdentity>(
418 list: impl ::core::convert::Into<crate::system::collections::generic::ilist_1_interface::IList_1_Interface<M0>>,
419 begin: impl ::core::convert::Into<i32>,
420 middle: impl ::core::convert::Into<i32>,
421 end: impl ::core::convert::Into<i32>,
422 work: impl ::core::convert::Into<::unity::Array<M0>>,
423 comparer: impl ::core::convert::Into<crate::system::collections::generic::icomparer_1_interface::IComparer_1_Interface<M0>>,
424 ) -> () {
425 static OPEN: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
426 ::unity::lookup::method_info_on_class(<SortGeneric as ::unity::ClassIdentity>::class(), "MergeSortMerge", 6)
427 });
428 #[allow(clippy::type_complexity)]
429 static CACHE: ::std::sync::OnceLock<::std::sync::Mutex<::std::collections::HashMap<usize, &'static ::unity::il2cpp::MethodInfo>>> =
430 ::std::sync::OnceLock::new();
431 let _ = true;
432 let __open: &'static ::unity::il2cpp::MethodInfo = match &*OPEN {
433 ::core::result::Result::Ok(mi) => *mi,
434 ::core::result::Result::Err(e) => {
435 panic!(
436 "method lookup failed: {}
437::{}
438: {}
439",
440 <SortGeneric as ::unity::ClassIdentity>::NAME,
441 "MergeSortMerge",
442 e
443 )
444 },
445 };
446 let __cache = CACHE.get_or_init(|| ::std::sync::Mutex::new(::std::collections::HashMap::new()));
447 let __key: usize = <M0 as ::unity::IlType>::il_type() as *const _ as usize;
448 let __inflated: &'static ::unity::il2cpp::MethodInfo = {
449 let mut __guard = __cache.lock().unwrap();
450 *__guard
451 .entry(__key)
452 .or_insert_with(|| ::unity::il2cpp::generic::create_generic_method_info(__open, &[<M0 as ::unity::IlType>::il_type()]))
453 };
454 unsafe {
455 let __f: extern "C" fn(
456 crate::system::collections::generic::ilist_1_interface::IList_1_Interface<M0>,
457 i32,
458 i32,
459 i32,
460 ::unity::Array<M0>,
461 crate::system::collections::generic::icomparer_1_interface::IComparer_1_Interface<M0>,
462 ::unity::OptionalMethod,
463 ) -> () = ::core::mem::transmute(__inflated.method_ptr);
464 let __mi_opaque: &'static () = &*(__inflated as *const _ as *const ());
465 __f(
466 ::core::convert::Into::into(list),
467 ::core::convert::Into::into(begin),
468 ::core::convert::Into::into(middle),
469 ::core::convert::Into::into(end),
470 ::core::convert::Into::into(work),
471 ::core::convert::Into::into(comparer),
472 ::core::option::Option::Some(__mi_opaque),
473 )
474 }
475 }
476}
477
478#[cfg(feature = "app-sortgeneric")]
479pub trait ISortGenericMethods: ISortGeneric {
480 #[doc = "`.ctor()` overload"]
481 fn ctor(self) -> () {
482 unsafe {
483 let __receiver = <SortGeneric as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
484 ::unity::il2cpp_call!((::unity::module_base()+0x1fe4900usize)as*mut u8,();
485(SortGeneric)__receiver)
486 }
487 }
488}
489
490#[cfg(feature = "app-sortgeneric")]
491impl<__T: ISortGeneric> ISortGenericMethods for __T {}
492
493#[cfg(feature = "app-sortgeneric")]
494impl SortGeneric {
495 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
496 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[9]
497 }
498}
499
500#[cfg(feature = "app-sortgeneric")]
501impl SortGeneric {
502 #[doc = "`.ctor()` — no args"]
503 pub fn new() -> Self {
504 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
505 panic!(
506 "{}
507::{}
508 failed to instantiate",
509 ::core::stringify!(SortGeneric),
510 ::core::stringify!(new),
511 )
512 });
513 <Self as ISortGenericMethods>::ctor(this);
514 this
515 }
516}
517
518#[cfg(feature = "app-sortgeneric")]
519#[::unity::methods]
520impl<T0: ::unity::ClassIdentity> SortGeneric_DelegateComparer_1<T0> {
521 #[doc = "`.ctor(crate::system::comparison_1::Comparison_1<T0>)` overload"]
522 #[method(name = ".ctor", args = 1)]
523 pub fn ctor(self, comparison: crate::system::comparison_1::Comparison_1<T0>) -> ();
524
525 #[doc = "`Compare(T0, T0)` overload"]
526 #[method(name = "Compare", args = 2)]
527 pub fn compare(self, a: T0, b: T0) -> i32;
528}
529
530#[cfg(feature = "app-sortgeneric")]
531impl<T0: ::unity::ClassIdentity> SortGeneric_DelegateComparer_1<T0> {
532 #[doc = "`.ctor(crate::system::comparison_1::Comparison_1<T0>)` — overload selector"]
533 pub fn new(comparison: crate::system::comparison_1::Comparison_1<T0>) -> Self {
534 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
535 panic!(
536 "{}
537::{}
538 failed to instantiate",
539 ::core::stringify!(SortGeneric_DelegateComparer_1),
540 ::core::stringify!(new),
541 )
542 });
543 <Self as ISortGeneric_DelegateComparer_1Methods<T0>>::ctor(this, comparison);
544 this
545 }
546}
547
548#[cfg(feature = "app-sortgeneric")]
549#[::unity::methods]
550impl<T0: ::unity::ClassIdentity> SortGeneric_ElementComparer_1<T0> {
551 #[doc = "`Compare(T0, T0)` overload"]
552 #[method(name = "Compare", args = 2)]
553 pub fn compare(self, a: T0, b: T0) -> i32;
554
555 #[doc = "`.ctor()` overload"]
556 #[method(name = ".ctor", args = 0)]
557 pub fn ctor(self) -> ();
558}
559
560#[cfg(feature = "app-sortgeneric")]
561impl<T0: ::unity::ClassIdentity> SortGeneric_ElementComparer_1<T0> {
562 #[doc = "`.ctor()` — no args"]
563 pub fn new() -> Self {
564 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
565 panic!(
566 "{}
567::{}
568 failed to instantiate",
569 ::core::stringify!(SortGeneric_ElementComparer_1),
570 ::core::stringify!(new),
571 )
572 });
573 <Self as ISortGeneric_ElementComparer_1Methods<T0>>::ctor(this);
574 this
575 }
576}
577
578#[cfg(feature = "app-sortgeneric")]
579#[doc(hidden)]
580pub mod prelude {
581 pub use super::{
582 ISortGeneric, ISortGenericMethods, ISortGeneric_DelegateComparer_1, ISortGeneric_DelegateComparer_1Methods, ISortGeneric_ElementComparer_1,
583 ISortGeneric_ElementComparer_1Methods, SortGeneric, SortGeneric_DelegateComparer_1, SortGeneric_ElementComparer_1,
584 };
585 #[cfg(feature = "app-sortconstant")]
586 pub use crate::app::sortconstant::ISortConstantMethods;
587 #[cfg(feature = "system-object")]
588 pub use crate::system::object::IObjectMethods;
589 pub use crate::{app::sortconstant::ISortConstant, system::object::IObject};
590}