1#[cfg(feature = "system-io-stream-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/system/io/stream/Stream_SynchronousAsyncResult.md"))]
14 #[::unity::class(namespace = "System.IO", name = "Stream.SynchronousAsyncResult")]
15 #[parent(crate::system::object::Object)]
16 pub struct Stream_SynchronousAsyncResult {
17 #[offset(16)]
18 #[rename(name = "_stateObject")]
19 pub state_object: ::unity::IlInstance,
20 #[offset(24)]
21 #[rename(name = "_isWrite")]
22 pub is_write: bool,
23 #[offset(48)]
24 #[rename(name = "_endXxxCalled")]
25 pub end_xxx_called: bool,
26 #[offset(52)]
27 #[rename(name = "_bytesRead")]
28 pub bytes_read: i32,
29 }
30
31 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/system/io/stream/Stream_ReadWriteParameters.md"))]
32 #[repr(C)]
33 #[derive(::core::clone::Clone, ::core::marker::Copy)]
34 pub struct Stream_ReadWriteParameters {
35 pub buffer: ::unity::Array<u8>,
36 pub offset: i32,
37 pub count: i32,
38 }
39 impl ::unity::ClassIdentity for Stream_ReadWriteParameters {
40 const NAME: &'static str = "Stream.ReadWriteParameters";
41 const NAMESPACE: &'static str = "System.IO";
42
43 fn class() -> ::unity::Class {
44 static CACHE: ::std::sync::OnceLock<::unity::Class> = ::std::sync::OnceLock::new();
45 *CACHE.get_or_init(|| ::unity::Class::lookup(Self::NAMESPACE, Self::NAME))
46 }
47 }
48 impl ::unity::IlType for Stream_ReadWriteParameters {
49 fn il_type() -> &'static ::unity::il2cpp::Il2CppType {
50 &<Self as ::unity::ClassIdentity>::class().raw()._1.byval_arg
51 }
52 }
53
54 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/system/io/stream/Stream_ReadWriteTask.md"))]
55 #[::unity::class(namespace = "System.IO", name = "Stream.ReadWriteTask")]
56 pub struct Stream_ReadWriteTask {
57 #[offset(84)]
58 #[rename(name = "_isRead")]
59 pub is_read: bool,
60 #[offset(88)]
61 #[rename(name = "_stream")]
62 pub stream: crate::system::io::stream::Stream,
63 #[offset(96)]
64 #[rename(name = "_buffer")]
65 pub buffer: ::unity::Array<u8>,
66 #[offset(104)]
67 #[rename(name = "_offset")]
68 pub offset: i32,
69 #[offset(108)]
70 #[rename(name = "_count")]
71 pub count: i32,
72 #[static_field]
73 #[rename(name = "s_invokeAsyncCallback")]
74 pub s_invoke_async_callback: ::unity::IlInstance,
75 }
76
77 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/system/io/stream/Stream.md"))]
78 #[::unity::class(namespace = "System.IO", name = "Stream")]
79 pub struct Stream {
80 #[static_field]
81 #[rename(name = "Null")]
82 pub null: crate::system::io::stream::Stream,
83 #[offset(24)]
84 #[rename(name = "_activeReadWriteTask")]
85 pub active_read_write_task: crate::system::io::stream::Stream_ReadWriteTask,
86 }
87
88 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/system/io/stream/Stream_NullStream.md"))]
89 #[::unity::class(namespace = "System.IO", name = "Stream.NullStream")]
90 #[parent(crate::system::io::stream::Stream)]
91 pub struct Stream_NullStream {
92 #[static_field]
93 #[rename(name = "s_nullReadTask")]
94 pub s_null_read_task: ::unity::IlInstance,
95 }
96}
97
98#[cfg(feature = "system-io-stream-types")]
99pub use __types::*;
100
101#[cfg(feature = "system-io-stream")]
102pub trait IStream_SynchronousAsyncResultMethods: IStream_SynchronousAsyncResult {
103 #[doc = "`.ctor(i32, crate::system::object::Object)` overload"]
104 fn ctor(self, bytes_read: impl ::core::convert::Into<i32>, async_state_object: impl ::core::convert::Into<crate::system::object::Object>) -> () {
105 unsafe {
106 let __receiver =
107 <Stream_SynchronousAsyncResult as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
108 ::unity::il2cpp_call!((::unity::module_base()+0x3c58d60usize)as*mut u8,();
109(Stream_SynchronousAsyncResult)__receiver,(i32)::core::convert::Into::into(bytes_read),(crate::system::object::Object)::core::convert::Into::into(async_state_object))
110 }
111 }
112 #[doc = "`.ctor(crate::system::object::Object)` overload"]
113 fn ctor_2(self, async_state_object: impl ::core::convert::Into<crate::system::object::Object>) -> () {
114 unsafe {
115 let __receiver =
116 <Stream_SynchronousAsyncResult as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
117 ::unity::il2cpp_call!((::unity::module_base()+0x3c58db0usize)as*mut u8,();
118(Stream_SynchronousAsyncResult)__receiver,(crate::system::object::Object)::core::convert::Into::into(async_state_object))
119 }
120 }
121 #[doc = "`get_IsCompleted()` overload"]
122 fn get_is_completed(self) -> bool {
123 unsafe {
124 let __receiver =
125 <Stream_SynchronousAsyncResult as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
126 {
127 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
128 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
129 panic!(
130 "unity: virtual slot {}
131 out of range (vtable len {}
132) on the runtime class behind {}
133 (method `{}
134`)",
135 4usize,
136 __vt.len(),
137 <Stream_SynchronousAsyncResult as ::unity::ClassIdentity>::NAME,
138 "get_IsCompleted",
139 )
140 });
141 let __inner: extern "C" fn(Stream_SynchronousAsyncResult, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
142 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
143 __inner(__receiver, __mi)
144 }
145 }
146 }
147 #[doc = "`get_AsyncState()` overload"]
148 fn get_async_state(self) -> crate::system::object::Object {
149 unsafe {
150 let __receiver =
151 <Stream_SynchronousAsyncResult as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
152 {
153 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
154 let __vi = *__vt.get(6usize).unwrap_or_else(|| {
155 panic!(
156 "unity: virtual slot {}
157 out of range (vtable len {}
158) on the runtime class behind {}
159 (method `{}
160`)",
161 6usize,
162 __vt.len(),
163 <Stream_SynchronousAsyncResult as ::unity::ClassIdentity>::NAME,
164 "get_AsyncState",
165 )
166 });
167 let __inner: extern "C" fn(Stream_SynchronousAsyncResult, ::unity::OptionalMethod) -> crate::system::object::Object =
168 ::core::mem::transmute(__vi.method_ptr);
169 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
170 __inner(__receiver, __mi)
171 }
172 }
173 }
174 #[doc = "`get_CompletedSynchronously()` overload"]
175 fn get_completed_synchronously(self) -> bool {
176 unsafe {
177 let __receiver =
178 <Stream_SynchronousAsyncResult as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
179 {
180 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
181 let __vi = *__vt.get(7usize).unwrap_or_else(|| {
182 panic!(
183 "unity: virtual slot {}
184 out of range (vtable len {}
185) on the runtime class behind {}
186 (method `{}
187`)",
188 7usize,
189 __vt.len(),
190 <Stream_SynchronousAsyncResult as ::unity::ClassIdentity>::NAME,
191 "get_CompletedSynchronously",
192 )
193 });
194 let __inner: extern "C" fn(Stream_SynchronousAsyncResult, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
195 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
196 __inner(__receiver, __mi)
197 }
198 }
199 }
200 #[doc = "`ThrowIfError()` overload"]
201 fn throw_if_error(self) -> () {
202 unsafe {
203 let __receiver =
204 <Stream_SynchronousAsyncResult as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
205 ::unity::il2cpp_call!((::unity::module_base()+0x3c58fc0usize)as*mut u8,();
206(Stream_SynchronousAsyncResult)__receiver)
207 }
208 }
209}
210
211#[cfg(feature = "system-io-stream")]
212impl<__T: IStream_SynchronousAsyncResult> IStream_SynchronousAsyncResultMethods for __T {}
213
214#[cfg(feature = "system-io-stream")]
215impl Stream_SynchronousAsyncResult {
216 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
217 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
218 }
219
220 pub fn ctor_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
221 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
222 }
223
224 pub fn get_is_completed_method_info() -> &'static ::unity::il2cpp::MethodInfo {
225 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
226 }
227
228 pub fn get_async_state_method_info() -> &'static ::unity::il2cpp::MethodInfo {
229 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
230 }
231
232 pub fn get_completed_synchronously_method_info() -> &'static ::unity::il2cpp::MethodInfo {
233 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
234 }
235
236 pub fn throw_if_error_method_info() -> &'static ::unity::il2cpp::MethodInfo {
237 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
238 }
239}
240
241#[cfg(feature = "system-io-stream")]
242impl Stream_SynchronousAsyncResult {
243 #[doc = "Direct (non-virtual) call to `Stream_SynchronousAsyncResult`'s own `get_IsCompleted`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
244 pub unsafe fn get_is_completed(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
245 let __mi = Self::get_is_completed_method_info();
246 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
247 __inner(this.into(), ::core::option::Option::None)
248 }
249
250 #[doc = "Direct (non-virtual) call to `Stream_SynchronousAsyncResult`'s own `get_AsyncState`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
251 pub unsafe fn get_async_state(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::system::object::Object {
252 let __mi = Self::get_async_state_method_info();
253 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::system::object::Object =
254 ::core::mem::transmute(__mi.method_ptr);
255 __inner(this.into(), ::core::option::Option::None)
256 }
257
258 #[doc = "Direct (non-virtual) call to `Stream_SynchronousAsyncResult`'s own `get_CompletedSynchronously`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
259 pub unsafe fn get_completed_synchronously(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
260 let __mi = Self::get_completed_synchronously_method_info();
261 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
262 __inner(this.into(), ::core::option::Option::None)
263 }
264}
265
266#[cfg(feature = "system-io-stream")]
267impl Stream_SynchronousAsyncResult {
268 #[doc = "`.ctor(i32, crate::system::object::Object)` — overload selector"]
269 pub fn new(bytes_read: i32, async_state_object: crate::system::object::Object) -> Self {
270 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
271 panic!(
272 "{}
273::{}
274 failed to instantiate",
275 ::core::stringify!(Stream_SynchronousAsyncResult),
276 ::core::stringify!(new),
277 )
278 });
279 <Self as IStream_SynchronousAsyncResultMethods>::ctor(this, bytes_read, async_state_object);
280 this
281 }
282
283 #[doc = "`.ctor(crate::system::object::Object)` — overload selector"]
284 pub fn new_2(async_state_object: crate::system::object::Object) -> Self {
285 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
286 panic!(
287 "{}
288::{}
289 failed to instantiate",
290 ::core::stringify!(Stream_SynchronousAsyncResult),
291 ::core::stringify!(new_2),
292 )
293 });
294 <Self as IStream_SynchronousAsyncResultMethods>::ctor_2(this, async_state_object);
295 this
296 }
297}
298
299#[cfg(feature = "system-io-stream")]
300impl Stream_ReadWriteTask {
301 #[doc = "`InvokeAsyncCallback(crate::system::object::Object)` overload"]
302 pub fn invoke_async_callback(completed_task: impl ::core::convert::Into<crate::system::object::Object>) -> () {
303 unsafe {
304 ::unity::il2cpp_call!((::unity::module_base()+0x3c58ab0usize)as*mut u8,();
305(crate::system::object::Object)::core::convert::Into::into(completed_task))
306 }
307 }
308}
309
310#[cfg(feature = "system-io-stream")]
311pub trait IStream_ReadWriteTaskMethods: IStream_ReadWriteTask {
312 #[doc = "`ClearBeginState()` overload"]
313 fn clear_begin_state(self) -> () {
314 unsafe {
315 let __receiver = <Stream_ReadWriteTask as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
316 ::unity::il2cpp_call!((::unity::module_base()+0x3c580e0usize)as*mut u8,();
317(Stream_ReadWriteTask)__receiver)
318 }
319 }
320}
321
322#[cfg(feature = "system-io-stream")]
323impl<__T: IStream_ReadWriteTask> IStream_ReadWriteTaskMethods for __T {}
324
325#[cfg(feature = "system-io-stream")]
326impl Stream_ReadWriteTask {
327 pub fn clear_begin_state_method_info() -> &'static ::unity::il2cpp::MethodInfo {
328 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
329 }
330
331 pub fn invoke_async_callback_method_info() -> &'static ::unity::il2cpp::MethodInfo {
332 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
333 }
334}
335
336#[cfg(feature = "system-io-stream")]
337impl Stream {
338 #[doc = "`.cctor()` overload"]
339 pub fn cctor() -> () {
340 unsafe {
341 ::unity::il2cpp_call!((::unity::module_base()+0x377bfe0usize)as*mut u8,();
342 )
343 }
344 }
345}
346
347#[cfg(feature = "system-io-stream")]
348pub trait IStreamMethods: IStream {
349 #[doc = "`get_CanRead()` overload"]
350 fn get_can_read(self) -> bool {
351 unsafe {
352 let __receiver = <Stream as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
353 {
354 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
355 let __vi = *__vt.get(7usize).unwrap_or_else(|| {
356 panic!(
357 "unity: virtual slot {}
358 out of range (vtable len {}
359) on the runtime class behind {}
360 (method `{}
361`)",
362 7usize,
363 __vt.len(),
364 <Stream as ::unity::ClassIdentity>::NAME,
365 "get_CanRead",
366 )
367 });
368 let __inner: extern "C" fn(Stream, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
369 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
370 __inner(__receiver, __mi)
371 }
372 }
373 }
374 #[doc = "`get_CanSeek()` overload"]
375 fn get_can_seek(self) -> bool {
376 unsafe {
377 let __receiver = <Stream 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(8usize).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 8usize,
388 __vt.len(),
389 <Stream as ::unity::ClassIdentity>::NAME,
390 "get_CanSeek",
391 )
392 });
393 let __inner: extern "C" fn(Stream, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
394 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
395 __inner(__receiver, __mi)
396 }
397 }
398 }
399 #[doc = "`get_CanTimeout()` overload"]
400 fn get_can_timeout(self) -> bool {
401 unsafe {
402 let __receiver = <Stream as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
403 {
404 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
405 let __vi = *__vt.get(9usize).unwrap_or_else(|| {
406 panic!(
407 "unity: virtual slot {}
408 out of range (vtable len {}
409) on the runtime class behind {}
410 (method `{}
411`)",
412 9usize,
413 __vt.len(),
414 <Stream as ::unity::ClassIdentity>::NAME,
415 "get_CanTimeout",
416 )
417 });
418 let __inner: extern "C" fn(Stream, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
419 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
420 __inner(__receiver, __mi)
421 }
422 }
423 }
424 #[doc = "`get_CanWrite()` overload"]
425 fn get_can_write(self) -> bool {
426 unsafe {
427 let __receiver = <Stream as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
428 {
429 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
430 let __vi = *__vt.get(10usize).unwrap_or_else(|| {
431 panic!(
432 "unity: virtual slot {}
433 out of range (vtable len {}
434) on the runtime class behind {}
435 (method `{}
436`)",
437 10usize,
438 __vt.len(),
439 <Stream as ::unity::ClassIdentity>::NAME,
440 "get_CanWrite",
441 )
442 });
443 let __inner: extern "C" fn(Stream, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
444 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
445 __inner(__receiver, __mi)
446 }
447 }
448 }
449 #[doc = "`get_Length()` overload"]
450 fn get_length(self) -> i64 {
451 unsafe {
452 let __receiver = <Stream as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
453 {
454 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
455 let __vi = *__vt.get(11usize).unwrap_or_else(|| {
456 panic!(
457 "unity: virtual slot {}
458 out of range (vtable len {}
459) on the runtime class behind {}
460 (method `{}
461`)",
462 11usize,
463 __vt.len(),
464 <Stream as ::unity::ClassIdentity>::NAME,
465 "get_Length",
466 )
467 });
468 let __inner: extern "C" fn(Stream, ::unity::OptionalMethod) -> i64 = ::core::mem::transmute(__vi.method_ptr);
469 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
470 __inner(__receiver, __mi)
471 }
472 }
473 }
474 #[doc = "`get_Position()` overload"]
475 fn get_position(self) -> i64 {
476 unsafe {
477 let __receiver = <Stream as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
478 {
479 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
480 let __vi = *__vt.get(12usize).unwrap_or_else(|| {
481 panic!(
482 "unity: virtual slot {}
483 out of range (vtable len {}
484) on the runtime class behind {}
485 (method `{}
486`)",
487 12usize,
488 __vt.len(),
489 <Stream as ::unity::ClassIdentity>::NAME,
490 "get_Position",
491 )
492 });
493 let __inner: extern "C" fn(Stream, ::unity::OptionalMethod) -> i64 = ::core::mem::transmute(__vi.method_ptr);
494 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
495 __inner(__receiver, __mi)
496 }
497 }
498 }
499 #[doc = "`set_Position(i64)` overload"]
500 fn set_position(self, value: impl ::core::convert::Into<i64>) -> () {
501 unsafe {
502 let __receiver = <Stream as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
503 {
504 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
505 let __vi = *__vt.get(13usize).unwrap_or_else(|| {
506 panic!(
507 "unity: virtual slot {}
508 out of range (vtable len {}
509) on the runtime class behind {}
510 (method `{}
511`)",
512 13usize,
513 __vt.len(),
514 <Stream as ::unity::ClassIdentity>::NAME,
515 "set_Position",
516 )
517 });
518 let __inner: extern "C" fn(Stream, i64, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
519 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
520 __inner(__receiver, ::core::convert::Into::into(value), __mi)
521 }
522 }
523 }
524 #[doc = "`get_ReadTimeout()` overload"]
525 fn get_read_timeout(self) -> i32 {
526 unsafe {
527 let __receiver = <Stream as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
528 {
529 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
530 let __vi = *__vt.get(14usize).unwrap_or_else(|| {
531 panic!(
532 "unity: virtual slot {}
533 out of range (vtable len {}
534) on the runtime class behind {}
535 (method `{}
536`)",
537 14usize,
538 __vt.len(),
539 <Stream as ::unity::ClassIdentity>::NAME,
540 "get_ReadTimeout",
541 )
542 });
543 let __inner: extern "C" fn(Stream, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__vi.method_ptr);
544 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
545 __inner(__receiver, __mi)
546 }
547 }
548 }
549 #[doc = "`set_ReadTimeout(i32)` overload"]
550 fn set_read_timeout(self, value: impl ::core::convert::Into<i32>) -> () {
551 unsafe {
552 let __receiver = <Stream as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
553 {
554 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
555 let __vi = *__vt.get(15usize).unwrap_or_else(|| {
556 panic!(
557 "unity: virtual slot {}
558 out of range (vtable len {}
559) on the runtime class behind {}
560 (method `{}
561`)",
562 15usize,
563 __vt.len(),
564 <Stream as ::unity::ClassIdentity>::NAME,
565 "set_ReadTimeout",
566 )
567 });
568 let __inner: extern "C" fn(Stream, i32, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
569 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
570 __inner(__receiver, ::core::convert::Into::into(value), __mi)
571 }
572 }
573 }
574 #[doc = "`get_WriteTimeout()` overload"]
575 fn get_write_timeout(self) -> i32 {
576 unsafe {
577 let __receiver = <Stream as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
578 {
579 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
580 let __vi = *__vt.get(16usize).unwrap_or_else(|| {
581 panic!(
582 "unity: virtual slot {}
583 out of range (vtable len {}
584) on the runtime class behind {}
585 (method `{}
586`)",
587 16usize,
588 __vt.len(),
589 <Stream as ::unity::ClassIdentity>::NAME,
590 "get_WriteTimeout",
591 )
592 });
593 let __inner: extern "C" fn(Stream, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__vi.method_ptr);
594 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
595 __inner(__receiver, __mi)
596 }
597 }
598 }
599 #[doc = "`set_WriteTimeout(i32)` overload"]
600 fn set_write_timeout(self, value: impl ::core::convert::Into<i32>) -> () {
601 unsafe {
602 let __receiver = <Stream as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
603 {
604 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
605 let __vi = *__vt.get(17usize).unwrap_or_else(|| {
606 panic!(
607 "unity: virtual slot {}
608 out of range (vtable len {}
609) on the runtime class behind {}
610 (method `{}
611`)",
612 17usize,
613 __vt.len(),
614 <Stream as ::unity::ClassIdentity>::NAME,
615 "set_WriteTimeout",
616 )
617 });
618 let __inner: extern "C" fn(Stream, i32, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
619 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
620 __inner(__receiver, ::core::convert::Into::into(value), __mi)
621 }
622 }
623 }
624 #[doc = "`Close()` overload"]
625 fn close(self) -> () {
626 unsafe {
627 let __receiver = <Stream as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
628 {
629 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
630 let __vi = *__vt.get(18usize).unwrap_or_else(|| {
631 panic!(
632 "unity: virtual slot {}
633 out of range (vtable len {}
634) on the runtime class behind {}
635 (method `{}
636`)",
637 18usize,
638 __vt.len(),
639 <Stream as ::unity::ClassIdentity>::NAME,
640 "Close",
641 )
642 });
643 let __inner: extern "C" fn(Stream, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
644 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
645 __inner(__receiver, __mi)
646 }
647 }
648 }
649 #[doc = "`Dispose()` overload"]
650 fn dispose(self) -> () {
651 unsafe {
652 let __receiver = <Stream as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
653 {
654 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
655 let __vi = *__vt.get(6usize).unwrap_or_else(|| {
656 panic!(
657 "unity: virtual slot {}
658 out of range (vtable len {}
659) on the runtime class behind {}
660 (method `{}
661`)",
662 6usize,
663 __vt.len(),
664 <Stream as ::unity::ClassIdentity>::NAME,
665 "Dispose",
666 )
667 });
668 let __inner: extern "C" fn(Stream, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
669 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
670 __inner(__receiver, __mi)
671 }
672 }
673 }
674 #[doc = "`Dispose(bool)` overload"]
675 fn dispose_2(self, disposing: impl ::core::convert::Into<bool>) -> () {
676 unsafe {
677 let __receiver = <Stream as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
678 {
679 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
680 let __vi = *__vt.get(19usize).unwrap_or_else(|| {
681 panic!(
682 "unity: virtual slot {}
683 out of range (vtable len {}
684) on the runtime class behind {}
685 (method `{}
686`)",
687 19usize,
688 __vt.len(),
689 <Stream as ::unity::ClassIdentity>::NAME,
690 "Dispose",
691 )
692 });
693 let __inner: extern "C" fn(Stream, bool, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
694 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
695 __inner(__receiver, ::core::convert::Into::into(disposing), __mi)
696 }
697 }
698 }
699 #[doc = "`Flush()` overload"]
700 fn flush(self) -> () {
701 unsafe {
702 let __receiver = <Stream as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
703 {
704 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
705 let __vi = *__vt.get(20usize).unwrap_or_else(|| {
706 panic!(
707 "unity: virtual slot {}
708 out of range (vtable len {}
709) on the runtime class behind {}
710 (method `{}
711`)",
712 20usize,
713 __vt.len(),
714 <Stream as ::unity::ClassIdentity>::NAME,
715 "Flush",
716 )
717 });
718 let __inner: extern "C" fn(Stream, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
719 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
720 __inner(__receiver, __mi)
721 }
722 }
723 }
724 #[doc = "`RunReadWriteTask(crate::system::io::stream::Stream_ReadWriteTask)` overload"]
725 fn run_read_write_task(self, read_write_task: impl ::core::convert::Into<crate::system::io::stream::Stream_ReadWriteTask>) -> () {
726 unsafe {
727 let __receiver = <Stream as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
728 ::unity::il2cpp_call!((::unity::module_base()+0x377ae20usize)as*mut u8,();
729(Stream)__receiver,(crate::system::io::stream::Stream_ReadWriteTask)::core::convert::Into::into(read_write_task))
730 }
731 }
732 #[doc = "`Seek(i64, crate::system::io::seekorigin::SeekOrigin)` overload"]
733 fn seek(self, offset: impl ::core::convert::Into<i64>, origin: impl ::core::convert::Into<crate::system::io::seekorigin::SeekOrigin>) -> i64 {
734 unsafe {
735 let __receiver = <Stream as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
736 {
737 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
738 let __vi = *__vt.get(27usize).unwrap_or_else(|| {
739 panic!(
740 "unity: virtual slot {}
741 out of range (vtable len {}
742) on the runtime class behind {}
743 (method `{}
744`)",
745 27usize,
746 __vt.len(),
747 <Stream as ::unity::ClassIdentity>::NAME,
748 "Seek",
749 )
750 });
751 let __inner: extern "C" fn(Stream, i64, crate::system::io::seekorigin::SeekOrigin, ::unity::OptionalMethod) -> i64 =
752 ::core::mem::transmute(__vi.method_ptr);
753 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
754 __inner(__receiver, ::core::convert::Into::into(offset), ::core::convert::Into::into(origin), __mi)
755 }
756 }
757 }
758 #[doc = "`SetLength(i64)` overload"]
759 fn set_length(self, value: impl ::core::convert::Into<i64>) -> () {
760 unsafe {
761 let __receiver = <Stream as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
762 {
763 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
764 let __vi = *__vt.get(28usize).unwrap_or_else(|| {
765 panic!(
766 "unity: virtual slot {}
767 out of range (vtable len {}
768) on the runtime class behind {}
769 (method `{}
770`)",
771 28usize,
772 __vt.len(),
773 <Stream as ::unity::ClassIdentity>::NAME,
774 "SetLength",
775 )
776 });
777 let __inner: extern "C" fn(Stream, i64, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
778 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
779 __inner(__receiver, ::core::convert::Into::into(value), __mi)
780 }
781 }
782 }
783 #[doc = "`Read(::unity::Array<u8>, i32, i32)` overload"]
784 fn read(
785 self,
786 buffer: impl ::core::convert::Into<::unity::Array<u8>>,
787 offset: impl ::core::convert::Into<i32>,
788 count: impl ::core::convert::Into<i32>,
789 ) -> i32 {
790 unsafe {
791 let __receiver = <Stream as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
792 {
793 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
794 let __vi = *__vt.get(29usize).unwrap_or_else(|| {
795 panic!(
796 "unity: virtual slot {}
797 out of range (vtable len {}
798) on the runtime class behind {}
799 (method `{}
800`)",
801 29usize,
802 __vt.len(),
803 <Stream as ::unity::ClassIdentity>::NAME,
804 "Read",
805 )
806 });
807 let __inner: extern "C" fn(Stream, ::unity::Array<u8>, i32, i32, ::unity::OptionalMethod) -> i32 =
808 ::core::mem::transmute(__vi.method_ptr);
809 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
810 __inner(
811 __receiver,
812 ::core::convert::Into::into(buffer),
813 ::core::convert::Into::into(offset),
814 ::core::convert::Into::into(count),
815 __mi,
816 )
817 }
818 }
819 }
820 #[doc = "`ReadByte()` overload"]
821 fn read_byte(self) -> i32 {
822 unsafe {
823 let __receiver = <Stream as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
824 {
825 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
826 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
827 panic!(
828 "unity: virtual slot {}
829 out of range (vtable len {}
830) on the runtime class behind {}
831 (method `{}
832`)",
833 30usize,
834 __vt.len(),
835 <Stream as ::unity::ClassIdentity>::NAME,
836 "ReadByte",
837 )
838 });
839 let __inner: extern "C" fn(Stream, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__vi.method_ptr);
840 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
841 __inner(__receiver, __mi)
842 }
843 }
844 }
845 #[doc = "`Write(::unity::Array<u8>, i32, i32)` overload"]
846 fn write(
847 self,
848 buffer: impl ::core::convert::Into<::unity::Array<u8>>,
849 offset: impl ::core::convert::Into<i32>,
850 count: impl ::core::convert::Into<i32>,
851 ) -> () {
852 unsafe {
853 let __receiver = <Stream as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
854 {
855 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
856 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
857 panic!(
858 "unity: virtual slot {}
859 out of range (vtable len {}
860) on the runtime class behind {}
861 (method `{}
862`)",
863 31usize,
864 __vt.len(),
865 <Stream as ::unity::ClassIdentity>::NAME,
866 "Write",
867 )
868 });
869 let __inner: extern "C" fn(Stream, ::unity::Array<u8>, i32, i32, ::unity::OptionalMethod) -> () =
870 ::core::mem::transmute(__vi.method_ptr);
871 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
872 __inner(
873 __receiver,
874 ::core::convert::Into::into(buffer),
875 ::core::convert::Into::into(offset),
876 ::core::convert::Into::into(count),
877 __mi,
878 )
879 }
880 }
881 }
882 #[doc = "`WriteByte(u8)` overload"]
883 fn write_byte(self, value: impl ::core::convert::Into<u8>) -> () {
884 unsafe {
885 let __receiver = <Stream as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
886 {
887 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
888 let __vi = *__vt.get(32usize).unwrap_or_else(|| {
889 panic!(
890 "unity: virtual slot {}
891 out of range (vtable len {}
892) on the runtime class behind {}
893 (method `{}
894`)",
895 32usize,
896 __vt.len(),
897 <Stream as ::unity::ClassIdentity>::NAME,
898 "WriteByte",
899 )
900 });
901 let __inner: extern "C" fn(Stream, u8, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
902 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
903 __inner(__receiver, ::core::convert::Into::into(value), __mi)
904 }
905 }
906 }
907 #[doc = "`.ctor()` overload"]
908 fn ctor(self) -> () {
909 unsafe {
910 let __receiver = <Stream as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
911 ::unity::il2cpp_call!((::unity::module_base()+0x377bfd0usize)as*mut u8,();
912(Stream)__receiver)
913 }
914 }
915}
916
917#[cfg(feature = "system-io-stream")]
918impl<__T: IStream> IStreamMethods for __T {}
919
920#[cfg(feature = "system-io-stream")]
921impl Stream {
922 pub fn get_can_read_method_info() -> &'static ::unity::il2cpp::MethodInfo {
923 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
924 }
925
926 pub fn get_can_seek_method_info() -> &'static ::unity::il2cpp::MethodInfo {
927 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
928 }
929
930 pub fn get_can_timeout_method_info() -> &'static ::unity::il2cpp::MethodInfo {
931 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
932 }
933
934 pub fn get_can_write_method_info() -> &'static ::unity::il2cpp::MethodInfo {
935 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
936 }
937
938 pub fn get_length_method_info() -> &'static ::unity::il2cpp::MethodInfo {
939 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
940 }
941
942 pub fn get_position_method_info() -> &'static ::unity::il2cpp::MethodInfo {
943 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
944 }
945
946 pub fn set_position_method_info() -> &'static ::unity::il2cpp::MethodInfo {
947 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
948 }
949
950 pub fn get_read_timeout_method_info() -> &'static ::unity::il2cpp::MethodInfo {
951 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[8]
952 }
953
954 pub fn set_read_timeout_method_info() -> &'static ::unity::il2cpp::MethodInfo {
955 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[9]
956 }
957
958 pub fn get_write_timeout_method_info() -> &'static ::unity::il2cpp::MethodInfo {
959 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[10]
960 }
961
962 pub fn set_write_timeout_method_info() -> &'static ::unity::il2cpp::MethodInfo {
963 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[11]
964 }
965
966 pub fn close_method_info() -> &'static ::unity::il2cpp::MethodInfo {
967 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[12]
968 }
969
970 pub fn dispose_method_info() -> &'static ::unity::il2cpp::MethodInfo {
971 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[13]
972 }
973
974 pub fn dispose_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
975 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[14]
976 }
977
978 pub fn flush_method_info() -> &'static ::unity::il2cpp::MethodInfo {
979 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[15]
980 }
981
982 pub fn run_read_write_task_method_info() -> &'static ::unity::il2cpp::MethodInfo {
983 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[24]
984 }
985
986 pub fn seek_method_info() -> &'static ::unity::il2cpp::MethodInfo {
987 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[29]
988 }
989
990 pub fn set_length_method_info() -> &'static ::unity::il2cpp::MethodInfo {
991 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[30]
992 }
993
994 pub fn read_method_info() -> &'static ::unity::il2cpp::MethodInfo {
995 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[31]
996 }
997
998 pub fn read_byte_method_info() -> &'static ::unity::il2cpp::MethodInfo {
999 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[32]
1000 }
1001
1002 pub fn write_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1003 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[33]
1004 }
1005
1006 pub fn write_byte_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1007 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[34]
1008 }
1009
1010 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1011 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[39]
1012 }
1013
1014 pub fn cctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1015 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[40]
1016 }
1017}
1018
1019#[cfg(feature = "system-io-stream")]
1020impl Stream {
1021 #[doc = "Direct (non-virtual) call to `Stream`'s own `get_CanRead`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1022 pub unsafe fn get_can_read(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
1023 let __mi = Self::get_can_read_method_info();
1024 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
1025 __inner(this.into(), ::core::option::Option::None)
1026 }
1027
1028 #[doc = "Direct (non-virtual) call to `Stream`'s own `get_CanSeek`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1029 pub unsafe fn get_can_seek(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
1030 let __mi = Self::get_can_seek_method_info();
1031 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
1032 __inner(this.into(), ::core::option::Option::None)
1033 }
1034
1035 #[doc = "Direct (non-virtual) call to `Stream`'s own `get_CanTimeout`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1036 pub unsafe fn get_can_timeout(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
1037 let __mi = Self::get_can_timeout_method_info();
1038 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
1039 __inner(this.into(), ::core::option::Option::None)
1040 }
1041
1042 #[doc = "Direct (non-virtual) call to `Stream`'s own `get_CanWrite`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1043 pub unsafe fn get_can_write(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
1044 let __mi = Self::get_can_write_method_info();
1045 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
1046 __inner(this.into(), ::core::option::Option::None)
1047 }
1048
1049 #[doc = "Direct (non-virtual) call to `Stream`'s own `get_Length`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1050 pub unsafe fn get_length(this: impl ::core::convert::Into<::unity::IlInstance>) -> i64 {
1051 let __mi = Self::get_length_method_info();
1052 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> i64 = ::core::mem::transmute(__mi.method_ptr);
1053 __inner(this.into(), ::core::option::Option::None)
1054 }
1055
1056 #[doc = "Direct (non-virtual) call to `Stream`'s own `get_Position`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1057 pub unsafe fn get_position(this: impl ::core::convert::Into<::unity::IlInstance>) -> i64 {
1058 let __mi = Self::get_position_method_info();
1059 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> i64 = ::core::mem::transmute(__mi.method_ptr);
1060 __inner(this.into(), ::core::option::Option::None)
1061 }
1062
1063 #[doc = "Direct (non-virtual) call to `Stream`'s own `set_Position`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1064 pub unsafe fn set_position(this: impl ::core::convert::Into<::unity::IlInstance>, value: i64) -> () {
1065 let __mi = Self::set_position_method_info();
1066 let __inner: extern "C" fn(::unity::IlInstance, i64, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
1067 __inner(this.into(), value, ::core::option::Option::None)
1068 }
1069
1070 #[doc = "Direct (non-virtual) call to `Stream`'s own `get_ReadTimeout`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1071 pub unsafe fn get_read_timeout(this: impl ::core::convert::Into<::unity::IlInstance>) -> i32 {
1072 let __mi = Self::get_read_timeout_method_info();
1073 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__mi.method_ptr);
1074 __inner(this.into(), ::core::option::Option::None)
1075 }
1076
1077 #[doc = "Direct (non-virtual) call to `Stream`'s own `set_ReadTimeout`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1078 pub unsafe fn set_read_timeout(this: impl ::core::convert::Into<::unity::IlInstance>, value: i32) -> () {
1079 let __mi = Self::set_read_timeout_method_info();
1080 let __inner: extern "C" fn(::unity::IlInstance, i32, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
1081 __inner(this.into(), value, ::core::option::Option::None)
1082 }
1083
1084 #[doc = "Direct (non-virtual) call to `Stream`'s own `get_WriteTimeout`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1085 pub unsafe fn get_write_timeout(this: impl ::core::convert::Into<::unity::IlInstance>) -> i32 {
1086 let __mi = Self::get_write_timeout_method_info();
1087 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__mi.method_ptr);
1088 __inner(this.into(), ::core::option::Option::None)
1089 }
1090
1091 #[doc = "Direct (non-virtual) call to `Stream`'s own `set_WriteTimeout`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1092 pub unsafe fn set_write_timeout(this: impl ::core::convert::Into<::unity::IlInstance>, value: i32) -> () {
1093 let __mi = Self::set_write_timeout_method_info();
1094 let __inner: extern "C" fn(::unity::IlInstance, i32, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
1095 __inner(this.into(), value, ::core::option::Option::None)
1096 }
1097
1098 #[doc = "Direct (non-virtual) call to `Stream`'s own `Close`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1099 pub unsafe fn close(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
1100 let __mi = Self::close_method_info();
1101 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
1102 __inner(this.into(), ::core::option::Option::None)
1103 }
1104
1105 #[doc = "Direct (non-virtual) call to `Stream`'s own `Dispose`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1106 pub unsafe fn dispose(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
1107 let __mi = Self::dispose_method_info();
1108 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
1109 __inner(this.into(), ::core::option::Option::None)
1110 }
1111
1112 #[doc = "Direct (non-virtual) call to `Stream`'s own `Dispose`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1113 pub unsafe fn dispose_2(this: impl ::core::convert::Into<::unity::IlInstance>, disposing: bool) -> () {
1114 let __mi = Self::dispose_2_method_info();
1115 let __inner: extern "C" fn(::unity::IlInstance, bool, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
1116 __inner(this.into(), disposing, ::core::option::Option::None)
1117 }
1118
1119 #[doc = "Direct (non-virtual) call to `Stream`'s own `Flush`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1120 pub unsafe fn flush(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
1121 let __mi = Self::flush_method_info();
1122 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
1123 __inner(this.into(), ::core::option::Option::None)
1124 }
1125
1126 #[doc = "Direct (non-virtual) call to `Stream`'s own `Seek`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1127 pub unsafe fn seek(this: impl ::core::convert::Into<::unity::IlInstance>, offset: i64, origin: crate::system::io::seekorigin::SeekOrigin) -> i64 {
1128 let __mi = Self::seek_method_info();
1129 let __inner: extern "C" fn(::unity::IlInstance, i64, crate::system::io::seekorigin::SeekOrigin, ::unity::OptionalMethod) -> i64 =
1130 ::core::mem::transmute(__mi.method_ptr);
1131 __inner(this.into(), offset, origin, ::core::option::Option::None)
1132 }
1133
1134 #[doc = "Direct (non-virtual) call to `Stream`'s own `SetLength`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1135 pub unsafe fn set_length(this: impl ::core::convert::Into<::unity::IlInstance>, value: i64) -> () {
1136 let __mi = Self::set_length_method_info();
1137 let __inner: extern "C" fn(::unity::IlInstance, i64, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
1138 __inner(this.into(), value, ::core::option::Option::None)
1139 }
1140
1141 #[doc = "Direct (non-virtual) call to `Stream`'s own `Read`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1142 pub unsafe fn read(this: impl ::core::convert::Into<::unity::IlInstance>, buffer: ::unity::Array<u8>, offset: i32, count: i32) -> i32 {
1143 let __mi = Self::read_method_info();
1144 let __inner: extern "C" fn(::unity::IlInstance, ::unity::Array<u8>, i32, i32, ::unity::OptionalMethod) -> i32 =
1145 ::core::mem::transmute(__mi.method_ptr);
1146 __inner(this.into(), buffer, offset, count, ::core::option::Option::None)
1147 }
1148
1149 #[doc = "Direct (non-virtual) call to `Stream`'s own `ReadByte`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1150 pub unsafe fn read_byte(this: impl ::core::convert::Into<::unity::IlInstance>) -> i32 {
1151 let __mi = Self::read_byte_method_info();
1152 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__mi.method_ptr);
1153 __inner(this.into(), ::core::option::Option::None)
1154 }
1155
1156 #[doc = "Direct (non-virtual) call to `Stream`'s own `Write`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1157 pub unsafe fn write(this: impl ::core::convert::Into<::unity::IlInstance>, buffer: ::unity::Array<u8>, offset: i32, count: i32) -> () {
1158 let __mi = Self::write_method_info();
1159 let __inner: extern "C" fn(::unity::IlInstance, ::unity::Array<u8>, i32, i32, ::unity::OptionalMethod) -> () =
1160 ::core::mem::transmute(__mi.method_ptr);
1161 __inner(this.into(), buffer, offset, count, ::core::option::Option::None)
1162 }
1163
1164 #[doc = "Direct (non-virtual) call to `Stream`'s own `WriteByte`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1165 pub unsafe fn write_byte(this: impl ::core::convert::Into<::unity::IlInstance>, value: u8) -> () {
1166 let __mi = Self::write_byte_method_info();
1167 let __inner: extern "C" fn(::unity::IlInstance, u8, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
1168 __inner(this.into(), value, ::core::option::Option::None)
1169 }
1170}
1171
1172#[cfg(feature = "system-io-stream")]
1173impl Stream {
1174 #[doc = "`.ctor()` — no args"]
1175 pub fn new() -> Self {
1176 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1177 panic!(
1178 "{}
1179::{}
1180 failed to instantiate",
1181 ::core::stringify!(Stream),
1182 ::core::stringify!(new),
1183 )
1184 });
1185 <Self as IStreamMethods>::ctor(this);
1186 this
1187 }
1188}
1189
1190#[cfg(feature = "system-io-stream")]
1191pub trait IStream_NullStreamMethods: IStream_NullStream {
1192 #[doc = "`.ctor()` overload"]
1193 fn ctor(self) -> () {
1194 unsafe {
1195 let __receiver = <Stream_NullStream as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1196 ::unity::il2cpp_call!((::unity::module_base()+0x3c58390usize)as*mut u8,();
1197(Stream_NullStream)__receiver)
1198 }
1199 }
1200 #[doc = "`get_CanRead()` overload"]
1201 fn get_can_read(self) -> bool {
1202 unsafe {
1203 let __receiver = <Stream_NullStream as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1204 {
1205 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1206 let __vi = *__vt.get(7usize).unwrap_or_else(|| {
1207 panic!(
1208 "unity: virtual slot {}
1209 out of range (vtable len {}
1210) on the runtime class behind {}
1211 (method `{}
1212`)",
1213 7usize,
1214 __vt.len(),
1215 <Stream_NullStream as ::unity::ClassIdentity>::NAME,
1216 "get_CanRead",
1217 )
1218 });
1219 let __inner: extern "C" fn(Stream_NullStream, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
1220 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1221 __inner(__receiver, __mi)
1222 }
1223 }
1224 }
1225 #[doc = "`get_CanWrite()` overload"]
1226 fn get_can_write(self) -> bool {
1227 unsafe {
1228 let __receiver = <Stream_NullStream as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1229 {
1230 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1231 let __vi = *__vt.get(10usize).unwrap_or_else(|| {
1232 panic!(
1233 "unity: virtual slot {}
1234 out of range (vtable len {}
1235) on the runtime class behind {}
1236 (method `{}
1237`)",
1238 10usize,
1239 __vt.len(),
1240 <Stream_NullStream as ::unity::ClassIdentity>::NAME,
1241 "get_CanWrite",
1242 )
1243 });
1244 let __inner: extern "C" fn(Stream_NullStream, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
1245 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1246 __inner(__receiver, __mi)
1247 }
1248 }
1249 }
1250 #[doc = "`get_CanSeek()` overload"]
1251 fn get_can_seek(self) -> bool {
1252 unsafe {
1253 let __receiver = <Stream_NullStream as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1254 {
1255 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1256 let __vi = *__vt.get(8usize).unwrap_or_else(|| {
1257 panic!(
1258 "unity: virtual slot {}
1259 out of range (vtable len {}
1260) on the runtime class behind {}
1261 (method `{}
1262`)",
1263 8usize,
1264 __vt.len(),
1265 <Stream_NullStream as ::unity::ClassIdentity>::NAME,
1266 "get_CanSeek",
1267 )
1268 });
1269 let __inner: extern "C" fn(Stream_NullStream, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
1270 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1271 __inner(__receiver, __mi)
1272 }
1273 }
1274 }
1275 #[doc = "`get_Length()` overload"]
1276 fn get_length(self) -> i64 {
1277 unsafe {
1278 let __receiver = <Stream_NullStream as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1279 {
1280 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1281 let __vi = *__vt.get(11usize).unwrap_or_else(|| {
1282 panic!(
1283 "unity: virtual slot {}
1284 out of range (vtable len {}
1285) on the runtime class behind {}
1286 (method `{}
1287`)",
1288 11usize,
1289 __vt.len(),
1290 <Stream_NullStream as ::unity::ClassIdentity>::NAME,
1291 "get_Length",
1292 )
1293 });
1294 let __inner: extern "C" fn(Stream_NullStream, ::unity::OptionalMethod) -> i64 = ::core::mem::transmute(__vi.method_ptr);
1295 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1296 __inner(__receiver, __mi)
1297 }
1298 }
1299 }
1300 #[doc = "`get_Position()` overload"]
1301 fn get_position(self) -> i64 {
1302 unsafe {
1303 let __receiver = <Stream_NullStream as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1304 {
1305 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1306 let __vi = *__vt.get(12usize).unwrap_or_else(|| {
1307 panic!(
1308 "unity: virtual slot {}
1309 out of range (vtable len {}
1310) on the runtime class behind {}
1311 (method `{}
1312`)",
1313 12usize,
1314 __vt.len(),
1315 <Stream_NullStream as ::unity::ClassIdentity>::NAME,
1316 "get_Position",
1317 )
1318 });
1319 let __inner: extern "C" fn(Stream_NullStream, ::unity::OptionalMethod) -> i64 = ::core::mem::transmute(__vi.method_ptr);
1320 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1321 __inner(__receiver, __mi)
1322 }
1323 }
1324 }
1325 #[doc = "`set_Position(i64)` overload"]
1326 fn set_position(self, value: impl ::core::convert::Into<i64>) -> () {
1327 unsafe {
1328 let __receiver = <Stream_NullStream as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1329 {
1330 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1331 let __vi = *__vt.get(13usize).unwrap_or_else(|| {
1332 panic!(
1333 "unity: virtual slot {}
1334 out of range (vtable len {}
1335) on the runtime class behind {}
1336 (method `{}
1337`)",
1338 13usize,
1339 __vt.len(),
1340 <Stream_NullStream as ::unity::ClassIdentity>::NAME,
1341 "set_Position",
1342 )
1343 });
1344 let __inner: extern "C" fn(Stream_NullStream, i64, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
1345 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1346 __inner(__receiver, ::core::convert::Into::into(value), __mi)
1347 }
1348 }
1349 }
1350 #[doc = "`Dispose(bool)` overload"]
1351 fn dispose(self, disposing: impl ::core::convert::Into<bool>) -> () {
1352 unsafe {
1353 let __receiver = <Stream_NullStream as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1354 {
1355 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1356 let __vi = *__vt.get(19usize).unwrap_or_else(|| {
1357 panic!(
1358 "unity: virtual slot {}
1359 out of range (vtable len {}
1360) on the runtime class behind {}
1361 (method `{}
1362`)",
1363 19usize,
1364 __vt.len(),
1365 <Stream_NullStream as ::unity::ClassIdentity>::NAME,
1366 "Dispose",
1367 )
1368 });
1369 let __inner: extern "C" fn(Stream_NullStream, bool, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
1370 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1371 __inner(__receiver, ::core::convert::Into::into(disposing), __mi)
1372 }
1373 }
1374 }
1375 #[doc = "`Flush()` overload"]
1376 fn flush(self) -> () {
1377 unsafe {
1378 let __receiver = <Stream_NullStream as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1379 {
1380 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1381 let __vi = *__vt.get(20usize).unwrap_or_else(|| {
1382 panic!(
1383 "unity: virtual slot {}
1384 out of range (vtable len {}
1385) on the runtime class behind {}
1386 (method `{}
1387`)",
1388 20usize,
1389 __vt.len(),
1390 <Stream_NullStream as ::unity::ClassIdentity>::NAME,
1391 "Flush",
1392 )
1393 });
1394 let __inner: extern "C" fn(Stream_NullStream, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
1395 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1396 __inner(__receiver, __mi)
1397 }
1398 }
1399 }
1400 #[doc = "`Read(::unity::Array<u8>, i32, i32)` overload"]
1401 fn read(
1402 self,
1403 buffer: impl ::core::convert::Into<::unity::Array<u8>>,
1404 offset: impl ::core::convert::Into<i32>,
1405 count: impl ::core::convert::Into<i32>,
1406 ) -> i32 {
1407 unsafe {
1408 let __receiver = <Stream_NullStream as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1409 {
1410 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1411 let __vi = *__vt.get(29usize).unwrap_or_else(|| {
1412 panic!(
1413 "unity: virtual slot {}
1414 out of range (vtable len {}
1415) on the runtime class behind {}
1416 (method `{}
1417`)",
1418 29usize,
1419 __vt.len(),
1420 <Stream_NullStream as ::unity::ClassIdentity>::NAME,
1421 "Read",
1422 )
1423 });
1424 let __inner: extern "C" fn(Stream_NullStream, ::unity::Array<u8>, i32, i32, ::unity::OptionalMethod) -> i32 =
1425 ::core::mem::transmute(__vi.method_ptr);
1426 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1427 __inner(
1428 __receiver,
1429 ::core::convert::Into::into(buffer),
1430 ::core::convert::Into::into(offset),
1431 ::core::convert::Into::into(count),
1432 __mi,
1433 )
1434 }
1435 }
1436 }
1437 #[doc = "`ReadByte()` overload"]
1438 fn read_byte(self) -> i32 {
1439 unsafe {
1440 let __receiver = <Stream_NullStream as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1441 {
1442 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1443 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
1444 panic!(
1445 "unity: virtual slot {}
1446 out of range (vtable len {}
1447) on the runtime class behind {}
1448 (method `{}
1449`)",
1450 30usize,
1451 __vt.len(),
1452 <Stream_NullStream as ::unity::ClassIdentity>::NAME,
1453 "ReadByte",
1454 )
1455 });
1456 let __inner: extern "C" fn(Stream_NullStream, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__vi.method_ptr);
1457 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1458 __inner(__receiver, __mi)
1459 }
1460 }
1461 }
1462 #[doc = "`Write(::unity::Array<u8>, i32, i32)` overload"]
1463 fn write(
1464 self,
1465 buffer: impl ::core::convert::Into<::unity::Array<u8>>,
1466 offset: impl ::core::convert::Into<i32>,
1467 count: impl ::core::convert::Into<i32>,
1468 ) -> () {
1469 unsafe {
1470 let __receiver = <Stream_NullStream as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1471 {
1472 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1473 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
1474 panic!(
1475 "unity: virtual slot {}
1476 out of range (vtable len {}
1477) on the runtime class behind {}
1478 (method `{}
1479`)",
1480 31usize,
1481 __vt.len(),
1482 <Stream_NullStream as ::unity::ClassIdentity>::NAME,
1483 "Write",
1484 )
1485 });
1486 let __inner: extern "C" fn(Stream_NullStream, ::unity::Array<u8>, i32, i32, ::unity::OptionalMethod) -> () =
1487 ::core::mem::transmute(__vi.method_ptr);
1488 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1489 __inner(
1490 __receiver,
1491 ::core::convert::Into::into(buffer),
1492 ::core::convert::Into::into(offset),
1493 ::core::convert::Into::into(count),
1494 __mi,
1495 )
1496 }
1497 }
1498 }
1499 #[doc = "`WriteByte(u8)` overload"]
1500 fn write_byte(self, value: impl ::core::convert::Into<u8>) -> () {
1501 unsafe {
1502 let __receiver = <Stream_NullStream as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1503 {
1504 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1505 let __vi = *__vt.get(32usize).unwrap_or_else(|| {
1506 panic!(
1507 "unity: virtual slot {}
1508 out of range (vtable len {}
1509) on the runtime class behind {}
1510 (method `{}
1511`)",
1512 32usize,
1513 __vt.len(),
1514 <Stream_NullStream as ::unity::ClassIdentity>::NAME,
1515 "WriteByte",
1516 )
1517 });
1518 let __inner: extern "C" fn(Stream_NullStream, u8, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
1519 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1520 __inner(__receiver, ::core::convert::Into::into(value), __mi)
1521 }
1522 }
1523 }
1524 #[doc = "`Seek(i64, crate::system::io::seekorigin::SeekOrigin)` overload"]
1525 fn seek(self, offset: impl ::core::convert::Into<i64>, origin: impl ::core::convert::Into<crate::system::io::seekorigin::SeekOrigin>) -> i64 {
1526 unsafe {
1527 let __receiver = <Stream_NullStream as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1528 {
1529 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1530 let __vi = *__vt.get(27usize).unwrap_or_else(|| {
1531 panic!(
1532 "unity: virtual slot {}
1533 out of range (vtable len {}
1534) on the runtime class behind {}
1535 (method `{}
1536`)",
1537 27usize,
1538 __vt.len(),
1539 <Stream_NullStream as ::unity::ClassIdentity>::NAME,
1540 "Seek",
1541 )
1542 });
1543 let __inner: extern "C" fn(Stream_NullStream, i64, crate::system::io::seekorigin::SeekOrigin, ::unity::OptionalMethod) -> i64 =
1544 ::core::mem::transmute(__vi.method_ptr);
1545 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1546 __inner(__receiver, ::core::convert::Into::into(offset), ::core::convert::Into::into(origin), __mi)
1547 }
1548 }
1549 }
1550 #[doc = "`SetLength(i64)` overload"]
1551 fn set_length(self, length: impl ::core::convert::Into<i64>) -> () {
1552 unsafe {
1553 let __receiver = <Stream_NullStream as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1554 {
1555 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1556 let __vi = *__vt.get(28usize).unwrap_or_else(|| {
1557 panic!(
1558 "unity: virtual slot {}
1559 out of range (vtable len {}
1560) on the runtime class behind {}
1561 (method `{}
1562`)",
1563 28usize,
1564 __vt.len(),
1565 <Stream_NullStream as ::unity::ClassIdentity>::NAME,
1566 "SetLength",
1567 )
1568 });
1569 let __inner: extern "C" fn(Stream_NullStream, i64, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
1570 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1571 __inner(__receiver, ::core::convert::Into::into(length), __mi)
1572 }
1573 }
1574 }
1575}
1576
1577#[cfg(feature = "system-io-stream")]
1578impl<__T: IStream_NullStream> IStream_NullStreamMethods for __T {}
1579
1580#[cfg(feature = "system-io-stream")]
1581impl Stream_NullStream {
1582 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1583 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
1584 }
1585
1586 pub fn get_can_read_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1587 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
1588 }
1589
1590 pub fn get_can_write_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1591 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
1592 }
1593
1594 pub fn get_can_seek_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1595 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
1596 }
1597
1598 pub fn get_length_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1599 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
1600 }
1601
1602 pub fn get_position_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1603 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
1604 }
1605
1606 pub fn set_position_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1607 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
1608 }
1609
1610 pub fn dispose_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1611 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
1612 }
1613
1614 pub fn flush_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1615 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[8]
1616 }
1617
1618 pub fn read_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1619 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[13]
1620 }
1621
1622 pub fn read_byte_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1623 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[15]
1624 }
1625
1626 pub fn write_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1627 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[16]
1628 }
1629
1630 pub fn write_byte_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1631 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[18]
1632 }
1633
1634 pub fn seek_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1635 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[19]
1636 }
1637
1638 pub fn set_length_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1639 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[20]
1640 }
1641}
1642
1643#[cfg(feature = "system-io-stream")]
1644impl Stream_NullStream {
1645 #[doc = "Direct (non-virtual) call to `Stream_NullStream`'s own `get_CanRead`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1646 pub unsafe fn get_can_read(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
1647 let __mi = Self::get_can_read_method_info();
1648 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
1649 __inner(this.into(), ::core::option::Option::None)
1650 }
1651
1652 #[doc = "Direct (non-virtual) call to `Stream_NullStream`'s own `get_CanWrite`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1653 pub unsafe fn get_can_write(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
1654 let __mi = Self::get_can_write_method_info();
1655 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
1656 __inner(this.into(), ::core::option::Option::None)
1657 }
1658
1659 #[doc = "Direct (non-virtual) call to `Stream_NullStream`'s own `get_CanSeek`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1660 pub unsafe fn get_can_seek(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
1661 let __mi = Self::get_can_seek_method_info();
1662 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
1663 __inner(this.into(), ::core::option::Option::None)
1664 }
1665
1666 #[doc = "Direct (non-virtual) call to `Stream_NullStream`'s own `get_Length`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1667 pub unsafe fn get_length(this: impl ::core::convert::Into<::unity::IlInstance>) -> i64 {
1668 let __mi = Self::get_length_method_info();
1669 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> i64 = ::core::mem::transmute(__mi.method_ptr);
1670 __inner(this.into(), ::core::option::Option::None)
1671 }
1672
1673 #[doc = "Direct (non-virtual) call to `Stream_NullStream`'s own `get_Position`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1674 pub unsafe fn get_position(this: impl ::core::convert::Into<::unity::IlInstance>) -> i64 {
1675 let __mi = Self::get_position_method_info();
1676 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> i64 = ::core::mem::transmute(__mi.method_ptr);
1677 __inner(this.into(), ::core::option::Option::None)
1678 }
1679
1680 #[doc = "Direct (non-virtual) call to `Stream_NullStream`'s own `set_Position`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1681 pub unsafe fn set_position(this: impl ::core::convert::Into<::unity::IlInstance>, value: i64) -> () {
1682 let __mi = Self::set_position_method_info();
1683 let __inner: extern "C" fn(::unity::IlInstance, i64, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
1684 __inner(this.into(), value, ::core::option::Option::None)
1685 }
1686
1687 #[doc = "Direct (non-virtual) call to `Stream_NullStream`'s own `Dispose`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1688 pub unsafe fn dispose(this: impl ::core::convert::Into<::unity::IlInstance>, disposing: bool) -> () {
1689 let __mi = Self::dispose_method_info();
1690 let __inner: extern "C" fn(::unity::IlInstance, bool, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
1691 __inner(this.into(), disposing, ::core::option::Option::None)
1692 }
1693
1694 #[doc = "Direct (non-virtual) call to `Stream_NullStream`'s own `Flush`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1695 pub unsafe fn flush(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
1696 let __mi = Self::flush_method_info();
1697 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
1698 __inner(this.into(), ::core::option::Option::None)
1699 }
1700
1701 #[doc = "Direct (non-virtual) call to `Stream_NullStream`'s own `Read`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1702 pub unsafe fn read(this: impl ::core::convert::Into<::unity::IlInstance>, buffer: ::unity::Array<u8>, offset: i32, count: i32) -> i32 {
1703 let __mi = Self::read_method_info();
1704 let __inner: extern "C" fn(::unity::IlInstance, ::unity::Array<u8>, i32, i32, ::unity::OptionalMethod) -> i32 =
1705 ::core::mem::transmute(__mi.method_ptr);
1706 __inner(this.into(), buffer, offset, count, ::core::option::Option::None)
1707 }
1708
1709 #[doc = "Direct (non-virtual) call to `Stream_NullStream`'s own `ReadByte`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1710 pub unsafe fn read_byte(this: impl ::core::convert::Into<::unity::IlInstance>) -> i32 {
1711 let __mi = Self::read_byte_method_info();
1712 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__mi.method_ptr);
1713 __inner(this.into(), ::core::option::Option::None)
1714 }
1715
1716 #[doc = "Direct (non-virtual) call to `Stream_NullStream`'s own `Write`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1717 pub unsafe fn write(this: impl ::core::convert::Into<::unity::IlInstance>, buffer: ::unity::Array<u8>, offset: i32, count: i32) -> () {
1718 let __mi = Self::write_method_info();
1719 let __inner: extern "C" fn(::unity::IlInstance, ::unity::Array<u8>, i32, i32, ::unity::OptionalMethod) -> () =
1720 ::core::mem::transmute(__mi.method_ptr);
1721 __inner(this.into(), buffer, offset, count, ::core::option::Option::None)
1722 }
1723
1724 #[doc = "Direct (non-virtual) call to `Stream_NullStream`'s own `WriteByte`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1725 pub unsafe fn write_byte(this: impl ::core::convert::Into<::unity::IlInstance>, value: u8) -> () {
1726 let __mi = Self::write_byte_method_info();
1727 let __inner: extern "C" fn(::unity::IlInstance, u8, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
1728 __inner(this.into(), value, ::core::option::Option::None)
1729 }
1730
1731 #[doc = "Direct (non-virtual) call to `Stream_NullStream`'s own `Seek`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1732 pub unsafe fn seek(this: impl ::core::convert::Into<::unity::IlInstance>, offset: i64, origin: crate::system::io::seekorigin::SeekOrigin) -> i64 {
1733 let __mi = Self::seek_method_info();
1734 let __inner: extern "C" fn(::unity::IlInstance, i64, crate::system::io::seekorigin::SeekOrigin, ::unity::OptionalMethod) -> i64 =
1735 ::core::mem::transmute(__mi.method_ptr);
1736 __inner(this.into(), offset, origin, ::core::option::Option::None)
1737 }
1738
1739 #[doc = "Direct (non-virtual) call to `Stream_NullStream`'s own `SetLength`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1740 pub unsafe fn set_length(this: impl ::core::convert::Into<::unity::IlInstance>, length: i64) -> () {
1741 let __mi = Self::set_length_method_info();
1742 let __inner: extern "C" fn(::unity::IlInstance, i64, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
1743 __inner(this.into(), length, ::core::option::Option::None)
1744 }
1745}
1746
1747#[cfg(feature = "system-io-stream")]
1748impl Stream_NullStream {
1749 #[doc = "`.ctor()` — no args"]
1750 pub fn new() -> Self {
1751 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1752 panic!(
1753 "{}
1754::{}
1755 failed to instantiate",
1756 ::core::stringify!(Stream_NullStream),
1757 ::core::stringify!(new),
1758 )
1759 });
1760 <Self as IStream_NullStreamMethods>::ctor(this);
1761 this
1762 }
1763}
1764
1765#[cfg(feature = "system-io-stream")]
1766#[doc(hidden)]
1767pub mod prelude {
1768 pub use super::{
1769 IStream, IStreamMethods, IStream_NullStream, IStream_NullStreamMethods, IStream_ReadWriteTask, IStream_ReadWriteTaskMethods,
1770 IStream_SynchronousAsyncResult, IStream_SynchronousAsyncResultMethods, Stream, Stream_NullStream, Stream_ReadWriteParameters,
1771 Stream_ReadWriteTask, Stream_SynchronousAsyncResult,
1772 };
1773 #[cfg(feature = "system-object")]
1774 pub use crate::system::object::IObjectMethods;
1775 #[cfg(feature = "system-valuetype")]
1776 pub use crate::system::valuetype::IValueTypeMethods;
1777 pub use crate::system::{object::IObject, valuetype::IValueType};
1778}