1#[cfg(feature = "moon_sharp-interpreter-io-undisposablestream-types")]
4mod __types {
5 #[allow(unused_imports)] use ::unity::prelude::*;
6
7 use super::*;
8 use crate::system::{
9 io::stream::{IStream, Stream},
10 object::{IObject, Object},
11 };
12
13 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/moon_sharp/interpreter/io/undisposablestream/UndisposableStream.md"))]
14 #[::unity::class(namespace = "MoonSharp.Interpreter.IO", name = "UndisposableStream")]
15 #[parent(crate::system::io::stream::Stream)]
16 pub struct UndisposableStream {
17 #[offset(40)]
18 #[rename(name = "m_Stream")]
19 pub m_stream: crate::system::io::stream::Stream,
20 }
21}
22
23#[cfg(feature = "moon_sharp-interpreter-io-undisposablestream-types")]
24pub use __types::*;
25
26#[cfg(feature = "moon_sharp-interpreter-io-undisposablestream")]
27#[doc(hidden)]
28#[allow(non_snake_case, non_camel_case_types, clippy::too_many_arguments)]
29mod __UndisposableStream_unity_raw {
30 use super::*;
31 #[doc(hidden)]
32 #[allow(non_snake_case)]
33 pub mod __lookup_ctor {
34 use super::*;
35 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
36 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[<crate::system::io::stream::Stream as ::unity::IlType>::il_type()];
37 ::unity::lookup::method_info_on_class_with_signature(
38 <UndisposableStream as ::unity::ClassIdentity>::class(),
39 ".ctor",
40 1,
41 param_types,
42 false,
43 )
44 });
45 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
46 match &*METHOD {
47 ::core::result::Result::Ok(mi) => *mi,
48 ::core::result::Result::Err(e) => {
49 panic!(
50 "method lookup failed: {}
51::{}
52: {}
53",
54 <UndisposableStream as ::unity::ClassIdentity>::NAME,
55 ".ctor",
56 e
57 )
58 },
59 }
60 }
61 }
62}
63
64#[cfg(feature = "moon_sharp-interpreter-io-undisposablestream")]
65pub trait IUndisposableStreamMethods: IUndisposableStream {
66 #[doc = "`.ctor(crate::system::io::stream::Stream)` overload"]
67 fn ctor(self, stream: impl ::core::convert::Into<crate::system::io::stream::Stream>) -> () {
68 unsafe {
69 let __receiver = <UndisposableStream as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
70 ::unity::il2cpp_call!(__UndisposableStream_unity_raw::__lookup_ctor::get_method_info().method_ptr,();
71(UndisposableStream)__receiver,(crate::system::io::stream::Stream)::core::convert::Into::into(stream))
72 }
73 }
74 #[doc = "`Dispose(bool)` overload"]
75 fn dispose(self, disposing: impl ::core::convert::Into<bool>) -> () {
76 unsafe {
77 let __receiver = <UndisposableStream as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
78 {
79 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
80 let __vi = *__vt.get(19usize).unwrap_or_else(|| {
81 panic!(
82 "unity: virtual slot {}
83 out of range (vtable len {}
84) on the runtime class behind {}
85 (method `{}
86`)",
87 19usize,
88 __vt.len(),
89 <UndisposableStream as ::unity::ClassIdentity>::NAME,
90 "Dispose",
91 )
92 });
93 let __inner: extern "C" fn(UndisposableStream, bool, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
94 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
95 __inner(__receiver, ::core::convert::Into::into(disposing), __mi)
96 }
97 }
98 }
99 #[doc = "`Close()` overload"]
100 fn close(self) -> () {
101 unsafe {
102 let __receiver = <UndisposableStream as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
103 {
104 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
105 let __vi = *__vt.get(18usize).unwrap_or_else(|| {
106 panic!(
107 "unity: virtual slot {}
108 out of range (vtable len {}
109) on the runtime class behind {}
110 (method `{}
111`)",
112 18usize,
113 __vt.len(),
114 <UndisposableStream as ::unity::ClassIdentity>::NAME,
115 "Close",
116 )
117 });
118 let __inner: extern "C" fn(UndisposableStream, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
119 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
120 __inner(__receiver, __mi)
121 }
122 }
123 }
124 #[doc = "`get_CanRead()` overload"]
125 fn get_can_read(self) -> bool {
126 unsafe {
127 let __receiver = <UndisposableStream as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
128 {
129 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
130 let __vi = *__vt.get(7usize).unwrap_or_else(|| {
131 panic!(
132 "unity: virtual slot {}
133 out of range (vtable len {}
134) on the runtime class behind {}
135 (method `{}
136`)",
137 7usize,
138 __vt.len(),
139 <UndisposableStream as ::unity::ClassIdentity>::NAME,
140 "get_CanRead",
141 )
142 });
143 let __inner: extern "C" fn(UndisposableStream, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
144 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
145 __inner(__receiver, __mi)
146 }
147 }
148 }
149 #[doc = "`get_CanSeek()` overload"]
150 fn get_can_seek(self) -> bool {
151 unsafe {
152 let __receiver = <UndisposableStream as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
153 {
154 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
155 let __vi = *__vt.get(8usize).unwrap_or_else(|| {
156 panic!(
157 "unity: virtual slot {}
158 out of range (vtable len {}
159) on the runtime class behind {}
160 (method `{}
161`)",
162 8usize,
163 __vt.len(),
164 <UndisposableStream as ::unity::ClassIdentity>::NAME,
165 "get_CanSeek",
166 )
167 });
168 let __inner: extern "C" fn(UndisposableStream, ::unity::OptionalMethod) -> bool = ::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_CanWrite()` overload"]
175 fn get_can_write(self) -> bool {
176 unsafe {
177 let __receiver = <UndisposableStream as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
178 {
179 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
180 let __vi = *__vt.get(10usize).unwrap_or_else(|| {
181 panic!(
182 "unity: virtual slot {}
183 out of range (vtable len {}
184) on the runtime class behind {}
185 (method `{}
186`)",
187 10usize,
188 __vt.len(),
189 <UndisposableStream as ::unity::ClassIdentity>::NAME,
190 "get_CanWrite",
191 )
192 });
193 let __inner: extern "C" fn(UndisposableStream, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
194 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
195 __inner(__receiver, __mi)
196 }
197 }
198 }
199 #[doc = "`Flush()` overload"]
200 fn flush(self) -> () {
201 unsafe {
202 let __receiver = <UndisposableStream as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
203 {
204 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
205 let __vi = *__vt.get(20usize).unwrap_or_else(|| {
206 panic!(
207 "unity: virtual slot {}
208 out of range (vtable len {}
209) on the runtime class behind {}
210 (method `{}
211`)",
212 20usize,
213 __vt.len(),
214 <UndisposableStream as ::unity::ClassIdentity>::NAME,
215 "Flush",
216 )
217 });
218 let __inner: extern "C" fn(UndisposableStream, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
219 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
220 __inner(__receiver, __mi)
221 }
222 }
223 }
224 #[doc = "`get_Length()` overload"]
225 fn get_length(self) -> i64 {
226 unsafe {
227 let __receiver = <UndisposableStream as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
228 {
229 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
230 let __vi = *__vt.get(11usize).unwrap_or_else(|| {
231 panic!(
232 "unity: virtual slot {}
233 out of range (vtable len {}
234) on the runtime class behind {}
235 (method `{}
236`)",
237 11usize,
238 __vt.len(),
239 <UndisposableStream as ::unity::ClassIdentity>::NAME,
240 "get_Length",
241 )
242 });
243 let __inner: extern "C" fn(UndisposableStream, ::unity::OptionalMethod) -> i64 = ::core::mem::transmute(__vi.method_ptr);
244 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
245 __inner(__receiver, __mi)
246 }
247 }
248 }
249 #[doc = "`get_Position()` overload"]
250 fn get_position(self) -> i64 {
251 unsafe {
252 let __receiver = <UndisposableStream as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
253 {
254 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
255 let __vi = *__vt.get(12usize).unwrap_or_else(|| {
256 panic!(
257 "unity: virtual slot {}
258 out of range (vtable len {}
259) on the runtime class behind {}
260 (method `{}
261`)",
262 12usize,
263 __vt.len(),
264 <UndisposableStream as ::unity::ClassIdentity>::NAME,
265 "get_Position",
266 )
267 });
268 let __inner: extern "C" fn(UndisposableStream, ::unity::OptionalMethod) -> i64 = ::core::mem::transmute(__vi.method_ptr);
269 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
270 __inner(__receiver, __mi)
271 }
272 }
273 }
274 #[doc = "`set_Position(i64)` overload"]
275 fn set_position(self, value: impl ::core::convert::Into<i64>) -> () {
276 unsafe {
277 let __receiver = <UndisposableStream as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
278 {
279 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
280 let __vi = *__vt.get(13usize).unwrap_or_else(|| {
281 panic!(
282 "unity: virtual slot {}
283 out of range (vtable len {}
284) on the runtime class behind {}
285 (method `{}
286`)",
287 13usize,
288 __vt.len(),
289 <UndisposableStream as ::unity::ClassIdentity>::NAME,
290 "set_Position",
291 )
292 });
293 let __inner: extern "C" fn(UndisposableStream, i64, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
294 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
295 __inner(__receiver, ::core::convert::Into::into(value), __mi)
296 }
297 }
298 }
299 #[doc = "`Read(::unity::Array<u8>, i32, i32)` overload"]
300 fn read(
301 self,
302 buffer: impl ::core::convert::Into<::unity::Array<u8>>,
303 offset: impl ::core::convert::Into<i32>,
304 count: impl ::core::convert::Into<i32>,
305 ) -> i32 {
306 unsafe {
307 let __receiver = <UndisposableStream as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
308 {
309 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
310 let __vi = *__vt.get(29usize).unwrap_or_else(|| {
311 panic!(
312 "unity: virtual slot {}
313 out of range (vtable len {}
314) on the runtime class behind {}
315 (method `{}
316`)",
317 29usize,
318 __vt.len(),
319 <UndisposableStream as ::unity::ClassIdentity>::NAME,
320 "Read",
321 )
322 });
323 let __inner: extern "C" fn(UndisposableStream, ::unity::Array<u8>, i32, i32, ::unity::OptionalMethod) -> i32 =
324 ::core::mem::transmute(__vi.method_ptr);
325 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
326 __inner(
327 __receiver,
328 ::core::convert::Into::into(buffer),
329 ::core::convert::Into::into(offset),
330 ::core::convert::Into::into(count),
331 __mi,
332 )
333 }
334 }
335 }
336 #[doc = "`Seek(i64, crate::system::io::seekorigin::SeekOrigin)` overload"]
337 fn seek(self, offset: impl ::core::convert::Into<i64>, origin: impl ::core::convert::Into<crate::system::io::seekorigin::SeekOrigin>) -> i64 {
338 unsafe {
339 let __receiver = <UndisposableStream as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
340 {
341 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
342 let __vi = *__vt.get(27usize).unwrap_or_else(|| {
343 panic!(
344 "unity: virtual slot {}
345 out of range (vtable len {}
346) on the runtime class behind {}
347 (method `{}
348`)",
349 27usize,
350 __vt.len(),
351 <UndisposableStream as ::unity::ClassIdentity>::NAME,
352 "Seek",
353 )
354 });
355 let __inner: extern "C" fn(UndisposableStream, i64, crate::system::io::seekorigin::SeekOrigin, ::unity::OptionalMethod) -> i64 =
356 ::core::mem::transmute(__vi.method_ptr);
357 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
358 __inner(__receiver, ::core::convert::Into::into(offset), ::core::convert::Into::into(origin), __mi)
359 }
360 }
361 }
362 #[doc = "`SetLength(i64)` overload"]
363 fn set_length(self, value: impl ::core::convert::Into<i64>) -> () {
364 unsafe {
365 let __receiver = <UndisposableStream as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
366 {
367 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
368 let __vi = *__vt.get(28usize).unwrap_or_else(|| {
369 panic!(
370 "unity: virtual slot {}
371 out of range (vtable len {}
372) on the runtime class behind {}
373 (method `{}
374`)",
375 28usize,
376 __vt.len(),
377 <UndisposableStream as ::unity::ClassIdentity>::NAME,
378 "SetLength",
379 )
380 });
381 let __inner: extern "C" fn(UndisposableStream, i64, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
382 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
383 __inner(__receiver, ::core::convert::Into::into(value), __mi)
384 }
385 }
386 }
387 #[doc = "`Write(::unity::Array<u8>, i32, i32)` overload"]
388 fn write(
389 self,
390 buffer: impl ::core::convert::Into<::unity::Array<u8>>,
391 offset: impl ::core::convert::Into<i32>,
392 count: impl ::core::convert::Into<i32>,
393 ) -> () {
394 unsafe {
395 let __receiver = <UndisposableStream as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
396 {
397 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
398 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
399 panic!(
400 "unity: virtual slot {}
401 out of range (vtable len {}
402) on the runtime class behind {}
403 (method `{}
404`)",
405 31usize,
406 __vt.len(),
407 <UndisposableStream as ::unity::ClassIdentity>::NAME,
408 "Write",
409 )
410 });
411 let __inner: extern "C" fn(UndisposableStream, ::unity::Array<u8>, i32, i32, ::unity::OptionalMethod) -> () =
412 ::core::mem::transmute(__vi.method_ptr);
413 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
414 __inner(
415 __receiver,
416 ::core::convert::Into::into(buffer),
417 ::core::convert::Into::into(offset),
418 ::core::convert::Into::into(count),
419 __mi,
420 )
421 }
422 }
423 }
424 #[doc = "`get_CanTimeout()` overload"]
425 fn get_can_timeout(self) -> bool {
426 unsafe {
427 let __receiver = <UndisposableStream 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(9usize).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 9usize,
438 __vt.len(),
439 <UndisposableStream as ::unity::ClassIdentity>::NAME,
440 "get_CanTimeout",
441 )
442 });
443 let __inner: extern "C" fn(UndisposableStream, ::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 = "`Equals(crate::system::object::Object)` overload"]
450 fn equals(self, obj: impl ::core::convert::Into<crate::system::object::Object>) -> bool {
451 unsafe {
452 let __receiver = <UndisposableStream 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(0usize).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 0usize,
463 __vt.len(),
464 <UndisposableStream as ::unity::ClassIdentity>::NAME,
465 "Equals",
466 )
467 });
468 let __inner: extern "C" fn(UndisposableStream, crate::system::object::Object, ::unity::OptionalMethod) -> bool =
469 ::core::mem::transmute(__vi.method_ptr);
470 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
471 __inner(__receiver, ::core::convert::Into::into(obj), __mi)
472 }
473 }
474 }
475 #[doc = "`GetHashCode()` overload"]
476 fn get_hash_code(self) -> i32 {
477 unsafe {
478 let __receiver = <UndisposableStream as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
479 {
480 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
481 let __vi = *__vt.get(2usize).unwrap_or_else(|| {
482 panic!(
483 "unity: virtual slot {}
484 out of range (vtable len {}
485) on the runtime class behind {}
486 (method `{}
487`)",
488 2usize,
489 __vt.len(),
490 <UndisposableStream as ::unity::ClassIdentity>::NAME,
491 "GetHashCode",
492 )
493 });
494 let __inner: extern "C" fn(UndisposableStream, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__vi.method_ptr);
495 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
496 __inner(__receiver, __mi)
497 }
498 }
499 }
500 #[doc = "`ReadByte()` overload"]
501 fn read_byte(self) -> i32 {
502 unsafe {
503 let __receiver = <UndisposableStream as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
504 {
505 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
506 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
507 panic!(
508 "unity: virtual slot {}
509 out of range (vtable len {}
510) on the runtime class behind {}
511 (method `{}
512`)",
513 30usize,
514 __vt.len(),
515 <UndisposableStream as ::unity::ClassIdentity>::NAME,
516 "ReadByte",
517 )
518 });
519 let __inner: extern "C" fn(UndisposableStream, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__vi.method_ptr);
520 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
521 __inner(__receiver, __mi)
522 }
523 }
524 }
525 #[doc = "`get_ReadTimeout()` overload"]
526 fn get_read_timeout(self) -> i32 {
527 unsafe {
528 let __receiver = <UndisposableStream as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
529 {
530 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
531 let __vi = *__vt.get(14usize).unwrap_or_else(|| {
532 panic!(
533 "unity: virtual slot {}
534 out of range (vtable len {}
535) on the runtime class behind {}
536 (method `{}
537`)",
538 14usize,
539 __vt.len(),
540 <UndisposableStream as ::unity::ClassIdentity>::NAME,
541 "get_ReadTimeout",
542 )
543 });
544 let __inner: extern "C" fn(UndisposableStream, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__vi.method_ptr);
545 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
546 __inner(__receiver, __mi)
547 }
548 }
549 }
550 #[doc = "`set_ReadTimeout(i32)` overload"]
551 fn set_read_timeout(self, value: impl ::core::convert::Into<i32>) -> () {
552 unsafe {
553 let __receiver = <UndisposableStream as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
554 {
555 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
556 let __vi = *__vt.get(15usize).unwrap_or_else(|| {
557 panic!(
558 "unity: virtual slot {}
559 out of range (vtable len {}
560) on the runtime class behind {}
561 (method `{}
562`)",
563 15usize,
564 __vt.len(),
565 <UndisposableStream as ::unity::ClassIdentity>::NAME,
566 "set_ReadTimeout",
567 )
568 });
569 let __inner: extern "C" fn(UndisposableStream, i32, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
570 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
571 __inner(__receiver, ::core::convert::Into::into(value), __mi)
572 }
573 }
574 }
575 #[doc = "`ToString()` overload"]
576 fn to_string(self) -> ::unity::Il2CppString {
577 unsafe {
578 let __receiver = <UndisposableStream as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
579 {
580 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
581 let __vi = *__vt.get(3usize).unwrap_or_else(|| {
582 panic!(
583 "unity: virtual slot {}
584 out of range (vtable len {}
585) on the runtime class behind {}
586 (method `{}
587`)",
588 3usize,
589 __vt.len(),
590 <UndisposableStream as ::unity::ClassIdentity>::NAME,
591 "ToString",
592 )
593 });
594 let __inner: extern "C" fn(UndisposableStream, ::unity::OptionalMethod) -> ::unity::Il2CppString =
595 ::core::mem::transmute(__vi.method_ptr);
596 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
597 __inner(__receiver, __mi)
598 }
599 }
600 }
601 #[doc = "`WriteByte(u8)` overload"]
602 fn write_byte(self, value: impl ::core::convert::Into<u8>) -> () {
603 unsafe {
604 let __receiver = <UndisposableStream as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
605 {
606 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
607 let __vi = *__vt.get(32usize).unwrap_or_else(|| {
608 panic!(
609 "unity: virtual slot {}
610 out of range (vtable len {}
611) on the runtime class behind {}
612 (method `{}
613`)",
614 32usize,
615 __vt.len(),
616 <UndisposableStream as ::unity::ClassIdentity>::NAME,
617 "WriteByte",
618 )
619 });
620 let __inner: extern "C" fn(UndisposableStream, u8, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
621 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
622 __inner(__receiver, ::core::convert::Into::into(value), __mi)
623 }
624 }
625 }
626 #[doc = "`get_WriteTimeout()` overload"]
627 fn get_write_timeout(self) -> i32 {
628 unsafe {
629 let __receiver = <UndisposableStream as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
630 {
631 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
632 let __vi = *__vt.get(16usize).unwrap_or_else(|| {
633 panic!(
634 "unity: virtual slot {}
635 out of range (vtable len {}
636) on the runtime class behind {}
637 (method `{}
638`)",
639 16usize,
640 __vt.len(),
641 <UndisposableStream as ::unity::ClassIdentity>::NAME,
642 "get_WriteTimeout",
643 )
644 });
645 let __inner: extern "C" fn(UndisposableStream, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__vi.method_ptr);
646 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
647 __inner(__receiver, __mi)
648 }
649 }
650 }
651 #[doc = "`set_WriteTimeout(i32)` overload"]
652 fn set_write_timeout(self, value: impl ::core::convert::Into<i32>) -> () {
653 unsafe {
654 let __receiver = <UndisposableStream as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
655 {
656 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
657 let __vi = *__vt.get(17usize).unwrap_or_else(|| {
658 panic!(
659 "unity: virtual slot {}
660 out of range (vtable len {}
661) on the runtime class behind {}
662 (method `{}
663`)",
664 17usize,
665 __vt.len(),
666 <UndisposableStream as ::unity::ClassIdentity>::NAME,
667 "set_WriteTimeout",
668 )
669 });
670 let __inner: extern "C" fn(UndisposableStream, i32, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
671 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
672 __inner(__receiver, ::core::convert::Into::into(value), __mi)
673 }
674 }
675 }
676}
677
678#[cfg(feature = "moon_sharp-interpreter-io-undisposablestream")]
679impl<__T: IUndisposableStream> IUndisposableStreamMethods for __T {}
680
681#[cfg(feature = "moon_sharp-interpreter-io-undisposablestream")]
682impl UndisposableStream {
683 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
684 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
685 }
686
687 pub fn dispose_method_info() -> &'static ::unity::il2cpp::MethodInfo {
688 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
689 }
690
691 pub fn close_method_info() -> &'static ::unity::il2cpp::MethodInfo {
692 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
693 }
694
695 pub fn get_can_read_method_info() -> &'static ::unity::il2cpp::MethodInfo {
696 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
697 }
698
699 pub fn get_can_seek_method_info() -> &'static ::unity::il2cpp::MethodInfo {
700 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
701 }
702
703 pub fn get_can_write_method_info() -> &'static ::unity::il2cpp::MethodInfo {
704 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
705 }
706
707 pub fn flush_method_info() -> &'static ::unity::il2cpp::MethodInfo {
708 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
709 }
710
711 pub fn get_length_method_info() -> &'static ::unity::il2cpp::MethodInfo {
712 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
713 }
714
715 pub fn get_position_method_info() -> &'static ::unity::il2cpp::MethodInfo {
716 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[8]
717 }
718
719 pub fn set_position_method_info() -> &'static ::unity::il2cpp::MethodInfo {
720 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[9]
721 }
722
723 pub fn read_method_info() -> &'static ::unity::il2cpp::MethodInfo {
724 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[10]
725 }
726
727 pub fn seek_method_info() -> &'static ::unity::il2cpp::MethodInfo {
728 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[11]
729 }
730
731 pub fn set_length_method_info() -> &'static ::unity::il2cpp::MethodInfo {
732 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[12]
733 }
734
735 pub fn write_method_info() -> &'static ::unity::il2cpp::MethodInfo {
736 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[13]
737 }
738
739 pub fn get_can_timeout_method_info() -> &'static ::unity::il2cpp::MethodInfo {
740 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[18]
741 }
742
743 pub fn equals_method_info() -> &'static ::unity::il2cpp::MethodInfo {
744 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[19]
745 }
746
747 pub fn get_hash_code_method_info() -> &'static ::unity::il2cpp::MethodInfo {
748 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[20]
749 }
750
751 pub fn read_byte_method_info() -> &'static ::unity::il2cpp::MethodInfo {
752 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[21]
753 }
754
755 pub fn get_read_timeout_method_info() -> &'static ::unity::il2cpp::MethodInfo {
756 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[22]
757 }
758
759 pub fn set_read_timeout_method_info() -> &'static ::unity::il2cpp::MethodInfo {
760 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[23]
761 }
762
763 pub fn to_string_method_info() -> &'static ::unity::il2cpp::MethodInfo {
764 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[24]
765 }
766
767 pub fn write_byte_method_info() -> &'static ::unity::il2cpp::MethodInfo {
768 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[25]
769 }
770
771 pub fn get_write_timeout_method_info() -> &'static ::unity::il2cpp::MethodInfo {
772 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[26]
773 }
774
775 pub fn set_write_timeout_method_info() -> &'static ::unity::il2cpp::MethodInfo {
776 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[27]
777 }
778}
779
780#[cfg(feature = "moon_sharp-interpreter-io-undisposablestream")]
781impl UndisposableStream {
782 #[doc = "Direct (non-virtual) call to `UndisposableStream`'s own `Dispose`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
783 pub unsafe fn dispose(this: impl ::core::convert::Into<::unity::IlInstance>, disposing: bool) -> () {
784 let __mi = Self::dispose_method_info();
785 let __inner: extern "C" fn(::unity::IlInstance, bool, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
786 __inner(this.into(), disposing, ::core::option::Option::None)
787 }
788
789 #[doc = "Direct (non-virtual) call to `UndisposableStream`'s own `Close`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
790 pub unsafe fn close(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
791 let __mi = Self::close_method_info();
792 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
793 __inner(this.into(), ::core::option::Option::None)
794 }
795
796 #[doc = "Direct (non-virtual) call to `UndisposableStream`'s own `get_CanRead`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
797 pub unsafe fn get_can_read(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
798 let __mi = Self::get_can_read_method_info();
799 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
800 __inner(this.into(), ::core::option::Option::None)
801 }
802
803 #[doc = "Direct (non-virtual) call to `UndisposableStream`'s own `get_CanSeek`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
804 pub unsafe fn get_can_seek(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
805 let __mi = Self::get_can_seek_method_info();
806 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
807 __inner(this.into(), ::core::option::Option::None)
808 }
809
810 #[doc = "Direct (non-virtual) call to `UndisposableStream`'s own `get_CanWrite`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
811 pub unsafe fn get_can_write(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
812 let __mi = Self::get_can_write_method_info();
813 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
814 __inner(this.into(), ::core::option::Option::None)
815 }
816
817 #[doc = "Direct (non-virtual) call to `UndisposableStream`'s own `Flush`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
818 pub unsafe fn flush(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
819 let __mi = Self::flush_method_info();
820 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
821 __inner(this.into(), ::core::option::Option::None)
822 }
823
824 #[doc = "Direct (non-virtual) call to `UndisposableStream`'s own `get_Length`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
825 pub unsafe fn get_length(this: impl ::core::convert::Into<::unity::IlInstance>) -> i64 {
826 let __mi = Self::get_length_method_info();
827 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> i64 = ::core::mem::transmute(__mi.method_ptr);
828 __inner(this.into(), ::core::option::Option::None)
829 }
830
831 #[doc = "Direct (non-virtual) call to `UndisposableStream`'s own `get_Position`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
832 pub unsafe fn get_position(this: impl ::core::convert::Into<::unity::IlInstance>) -> i64 {
833 let __mi = Self::get_position_method_info();
834 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> i64 = ::core::mem::transmute(__mi.method_ptr);
835 __inner(this.into(), ::core::option::Option::None)
836 }
837
838 #[doc = "Direct (non-virtual) call to `UndisposableStream`'s own `set_Position`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
839 pub unsafe fn set_position(this: impl ::core::convert::Into<::unity::IlInstance>, value: i64) -> () {
840 let __mi = Self::set_position_method_info();
841 let __inner: extern "C" fn(::unity::IlInstance, i64, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
842 __inner(this.into(), value, ::core::option::Option::None)
843 }
844
845 #[doc = "Direct (non-virtual) call to `UndisposableStream`'s own `Read`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
846 pub unsafe fn read(this: impl ::core::convert::Into<::unity::IlInstance>, buffer: ::unity::Array<u8>, offset: i32, count: i32) -> i32 {
847 let __mi = Self::read_method_info();
848 let __inner: extern "C" fn(::unity::IlInstance, ::unity::Array<u8>, i32, i32, ::unity::OptionalMethod) -> i32 =
849 ::core::mem::transmute(__mi.method_ptr);
850 __inner(this.into(), buffer, offset, count, ::core::option::Option::None)
851 }
852
853 #[doc = "Direct (non-virtual) call to `UndisposableStream`'s own `Seek`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
854 pub unsafe fn seek(this: impl ::core::convert::Into<::unity::IlInstance>, offset: i64, origin: crate::system::io::seekorigin::SeekOrigin) -> i64 {
855 let __mi = Self::seek_method_info();
856 let __inner: extern "C" fn(::unity::IlInstance, i64, crate::system::io::seekorigin::SeekOrigin, ::unity::OptionalMethod) -> i64 =
857 ::core::mem::transmute(__mi.method_ptr);
858 __inner(this.into(), offset, origin, ::core::option::Option::None)
859 }
860
861 #[doc = "Direct (non-virtual) call to `UndisposableStream`'s own `SetLength`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
862 pub unsafe fn set_length(this: impl ::core::convert::Into<::unity::IlInstance>, value: i64) -> () {
863 let __mi = Self::set_length_method_info();
864 let __inner: extern "C" fn(::unity::IlInstance, i64, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
865 __inner(this.into(), value, ::core::option::Option::None)
866 }
867
868 #[doc = "Direct (non-virtual) call to `UndisposableStream`'s own `Write`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
869 pub unsafe fn write(this: impl ::core::convert::Into<::unity::IlInstance>, buffer: ::unity::Array<u8>, offset: i32, count: i32) -> () {
870 let __mi = Self::write_method_info();
871 let __inner: extern "C" fn(::unity::IlInstance, ::unity::Array<u8>, i32, i32, ::unity::OptionalMethod) -> () =
872 ::core::mem::transmute(__mi.method_ptr);
873 __inner(this.into(), buffer, offset, count, ::core::option::Option::None)
874 }
875
876 #[doc = "Direct (non-virtual) call to `UndisposableStream`'s own `get_CanTimeout`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
877 pub unsafe fn get_can_timeout(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
878 let __mi = Self::get_can_timeout_method_info();
879 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
880 __inner(this.into(), ::core::option::Option::None)
881 }
882
883 #[doc = "Direct (non-virtual) call to `UndisposableStream`'s own `Equals`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
884 pub unsafe fn equals(this: impl ::core::convert::Into<::unity::IlInstance>, obj: crate::system::object::Object) -> bool {
885 let __mi = Self::equals_method_info();
886 let __inner: extern "C" fn(::unity::IlInstance, crate::system::object::Object, ::unity::OptionalMethod) -> bool =
887 ::core::mem::transmute(__mi.method_ptr);
888 __inner(this.into(), obj, ::core::option::Option::None)
889 }
890
891 #[doc = "Direct (non-virtual) call to `UndisposableStream`'s own `GetHashCode`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
892 pub unsafe fn get_hash_code(this: impl ::core::convert::Into<::unity::IlInstance>) -> i32 {
893 let __mi = Self::get_hash_code_method_info();
894 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__mi.method_ptr);
895 __inner(this.into(), ::core::option::Option::None)
896 }
897
898 #[doc = "Direct (non-virtual) call to `UndisposableStream`'s own `ReadByte`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
899 pub unsafe fn read_byte(this: impl ::core::convert::Into<::unity::IlInstance>) -> i32 {
900 let __mi = Self::read_byte_method_info();
901 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__mi.method_ptr);
902 __inner(this.into(), ::core::option::Option::None)
903 }
904
905 #[doc = "Direct (non-virtual) call to `UndisposableStream`'s own `get_ReadTimeout`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
906 pub unsafe fn get_read_timeout(this: impl ::core::convert::Into<::unity::IlInstance>) -> i32 {
907 let __mi = Self::get_read_timeout_method_info();
908 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__mi.method_ptr);
909 __inner(this.into(), ::core::option::Option::None)
910 }
911
912 #[doc = "Direct (non-virtual) call to `UndisposableStream`'s own `set_ReadTimeout`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
913 pub unsafe fn set_read_timeout(this: impl ::core::convert::Into<::unity::IlInstance>, value: i32) -> () {
914 let __mi = Self::set_read_timeout_method_info();
915 let __inner: extern "C" fn(::unity::IlInstance, i32, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
916 __inner(this.into(), value, ::core::option::Option::None)
917 }
918
919 #[doc = "Direct (non-virtual) call to `UndisposableStream`'s own `ToString`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
920 pub unsafe fn to_string(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
921 let __mi = Self::to_string_method_info();
922 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
923 __inner(this.into(), ::core::option::Option::None)
924 }
925
926 #[doc = "Direct (non-virtual) call to `UndisposableStream`'s own `WriteByte`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
927 pub unsafe fn write_byte(this: impl ::core::convert::Into<::unity::IlInstance>, value: u8) -> () {
928 let __mi = Self::write_byte_method_info();
929 let __inner: extern "C" fn(::unity::IlInstance, u8, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
930 __inner(this.into(), value, ::core::option::Option::None)
931 }
932
933 #[doc = "Direct (non-virtual) call to `UndisposableStream`'s own `get_WriteTimeout`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
934 pub unsafe fn get_write_timeout(this: impl ::core::convert::Into<::unity::IlInstance>) -> i32 {
935 let __mi = Self::get_write_timeout_method_info();
936 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__mi.method_ptr);
937 __inner(this.into(), ::core::option::Option::None)
938 }
939
940 #[doc = "Direct (non-virtual) call to `UndisposableStream`'s own `set_WriteTimeout`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
941 pub unsafe fn set_write_timeout(this: impl ::core::convert::Into<::unity::IlInstance>, value: i32) -> () {
942 let __mi = Self::set_write_timeout_method_info();
943 let __inner: extern "C" fn(::unity::IlInstance, i32, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
944 __inner(this.into(), value, ::core::option::Option::None)
945 }
946}
947
948#[cfg(feature = "moon_sharp-interpreter-io-undisposablestream")]
949impl UndisposableStream {
950 #[doc = "`.ctor(crate::system::io::stream::Stream)` — overload selector"]
951 pub fn new(stream: crate::system::io::stream::Stream) -> Self {
952 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
953 panic!(
954 "{}
955::{}
956 failed to instantiate",
957 ::core::stringify!(UndisposableStream),
958 ::core::stringify!(new),
959 )
960 });
961 <Self as IUndisposableStreamMethods>::ctor(this, stream);
962 this
963 }
964}
965
966#[cfg(feature = "moon_sharp-interpreter-io-undisposablestream")]
967#[doc(hidden)]
968pub mod prelude {
969 pub use super::{IUndisposableStream, IUndisposableStreamMethods, UndisposableStream};
970 #[cfg(feature = "system-io-stream")]
971 pub use crate::system::io::stream::IStreamMethods;
972 #[cfg(feature = "system-object")]
973 pub use crate::system::object::IObjectMethods;
974 pub use crate::system::{io::stream::IStream, object::IObject};
975}