1#[cfg(feature = "system-io-compression-gzipstream-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/system/io/compression/gzipstream/GZipStream.md"))]
14 #[::unity::class(namespace = "System.IO.Compression", name = "GZipStream")]
15 #[parent(crate::system::io::stream::Stream)]
16 pub struct GZipStream {
17 #[offset(40)]
18 #[rename(name = "_deflateStream")]
19 pub deflate_stream: crate::system::io::compression::deflatestream::DeflateStream,
20 }
21}
22
23#[cfg(feature = "system-io-compression-gzipstream-types")]
24pub use __types::*;
25
26#[cfg(feature = "system-io-compression-gzipstream")]
27impl GZipStream {
28 #[doc = "`ThrowStreamClosedException()` overload"]
29 pub fn throw_stream_closed_exception() -> () {
30 unsafe {
31 ::unity::il2cpp_call!((::unity::module_base()+0x34a1d90usize)as*mut u8,();
32 )
33 }
34 }
35}
36
37#[cfg(feature = "system-io-compression-gzipstream")]
38pub trait IGZipStreamMethods: IGZipStream {
39 #[doc = "`.ctor(crate::system::io::stream::Stream, crate::system::io::compression::compressionmode::CompressionMode)` overload"]
40 fn ctor(
41 self,
42 stream: impl ::core::convert::Into<crate::system::io::stream::Stream>,
43 mode: impl ::core::convert::Into<crate::system::io::compression::compressionmode::CompressionMode>,
44 ) -> () {
45 unsafe {
46 let __receiver = <GZipStream as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
47 ::unity::il2cpp_call!((::unity::module_base()+0x34a15c0usize)as*mut u8,();
48(GZipStream)__receiver,(crate::system::io::stream::Stream)::core::convert::Into::into(stream),(crate::system::io::compression::compressionmode::CompressionMode)::core::convert::Into::into(mode))
49 }
50 }
51 #[doc = "`.ctor(crate::system::io::stream::Stream, crate::system::io::compression::compressionmode::CompressionMode, bool)` overload"]
52 fn ctor_2(
53 self,
54 stream: impl ::core::convert::Into<crate::system::io::stream::Stream>,
55 mode: impl ::core::convert::Into<crate::system::io::compression::compressionmode::CompressionMode>,
56 leave_open: impl ::core::convert::Into<bool>,
57 ) -> () {
58 unsafe {
59 let __receiver = <GZipStream as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
60 ::unity::il2cpp_call!((::unity::module_base()+0x34a15d0usize)as*mut u8,();
61(GZipStream)__receiver,(crate::system::io::stream::Stream)::core::convert::Into::into(stream),(crate::system::io::compression::compressionmode::CompressionMode)::core::convert::Into::into(mode),(bool)::core::convert::Into::into(leave_open))
62 }
63 }
64 #[doc = "`.ctor(crate::system::io::stream::Stream, crate::system::io::compression::compressionlevel::CompressionLevel, bool)` overload"]
65 fn ctor_3(
66 self,
67 stream: impl ::core::convert::Into<crate::system::io::stream::Stream>,
68 compression_level: impl ::core::convert::Into<crate::system::io::compression::compressionlevel::CompressionLevel>,
69 leave_open: impl ::core::convert::Into<bool>,
70 ) -> () {
71 unsafe {
72 let __receiver = <GZipStream as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
73 ::unity::il2cpp_call!((::unity::module_base()+0x34a16a0usize)as*mut u8,();
74(GZipStream)__receiver,(crate::system::io::stream::Stream)::core::convert::Into::into(stream),(crate::system::io::compression::compressionlevel::CompressionLevel)::core::convert::Into::into(compression_level),(bool)::core::convert::Into::into(leave_open))
75 }
76 }
77 #[doc = "`get_CanRead()` overload"]
78 fn get_can_read(self) -> bool {
79 unsafe {
80 let __receiver = <GZipStream as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
81 {
82 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
83 let __vi = *__vt.get(7usize).unwrap_or_else(|| {
84 panic!(
85 "unity: virtual slot {}
86 out of range (vtable len {}
87) on the runtime class behind {}
88 (method `{}
89`)",
90 7usize,
91 __vt.len(),
92 <GZipStream as ::unity::ClassIdentity>::NAME,
93 "get_CanRead",
94 )
95 });
96 let __inner: extern "C" fn(GZipStream, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
97 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
98 __inner(__receiver, __mi)
99 }
100 }
101 }
102 #[doc = "`get_CanWrite()` overload"]
103 fn get_can_write(self) -> bool {
104 unsafe {
105 let __receiver = <GZipStream as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
106 {
107 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
108 let __vi = *__vt.get(10usize).unwrap_or_else(|| {
109 panic!(
110 "unity: virtual slot {}
111 out of range (vtable len {}
112) on the runtime class behind {}
113 (method `{}
114`)",
115 10usize,
116 __vt.len(),
117 <GZipStream as ::unity::ClassIdentity>::NAME,
118 "get_CanWrite",
119 )
120 });
121 let __inner: extern "C" fn(GZipStream, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
122 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
123 __inner(__receiver, __mi)
124 }
125 }
126 }
127 #[doc = "`get_CanSeek()` overload"]
128 fn get_can_seek(self) -> bool {
129 unsafe {
130 let __receiver = <GZipStream as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
131 {
132 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
133 let __vi = *__vt.get(8usize).unwrap_or_else(|| {
134 panic!(
135 "unity: virtual slot {}
136 out of range (vtable len {}
137) on the runtime class behind {}
138 (method `{}
139`)",
140 8usize,
141 __vt.len(),
142 <GZipStream as ::unity::ClassIdentity>::NAME,
143 "get_CanSeek",
144 )
145 });
146 let __inner: extern "C" fn(GZipStream, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
147 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
148 __inner(__receiver, __mi)
149 }
150 }
151 }
152 #[doc = "`get_Length()` overload"]
153 fn get_length(self) -> i64 {
154 unsafe {
155 let __receiver = <GZipStream as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
156 {
157 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
158 let __vi = *__vt.get(11usize).unwrap_or_else(|| {
159 panic!(
160 "unity: virtual slot {}
161 out of range (vtable len {}
162) on the runtime class behind {}
163 (method `{}
164`)",
165 11usize,
166 __vt.len(),
167 <GZipStream as ::unity::ClassIdentity>::NAME,
168 "get_Length",
169 )
170 });
171 let __inner: extern "C" fn(GZipStream, ::unity::OptionalMethod) -> i64 = ::core::mem::transmute(__vi.method_ptr);
172 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
173 __inner(__receiver, __mi)
174 }
175 }
176 }
177 #[doc = "`get_Position()` overload"]
178 fn get_position(self) -> i64 {
179 unsafe {
180 let __receiver = <GZipStream as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
181 {
182 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
183 let __vi = *__vt.get(12usize).unwrap_or_else(|| {
184 panic!(
185 "unity: virtual slot {}
186 out of range (vtable len {}
187) on the runtime class behind {}
188 (method `{}
189`)",
190 12usize,
191 __vt.len(),
192 <GZipStream as ::unity::ClassIdentity>::NAME,
193 "get_Position",
194 )
195 });
196 let __inner: extern "C" fn(GZipStream, ::unity::OptionalMethod) -> i64 = ::core::mem::transmute(__vi.method_ptr);
197 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
198 __inner(__receiver, __mi)
199 }
200 }
201 }
202 #[doc = "`set_Position(i64)` overload"]
203 fn set_position(self, value: impl ::core::convert::Into<i64>) -> () {
204 unsafe {
205 let __receiver = <GZipStream as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
206 {
207 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
208 let __vi = *__vt.get(13usize).unwrap_or_else(|| {
209 panic!(
210 "unity: virtual slot {}
211 out of range (vtable len {}
212) on the runtime class behind {}
213 (method `{}
214`)",
215 13usize,
216 __vt.len(),
217 <GZipStream as ::unity::ClassIdentity>::NAME,
218 "set_Position",
219 )
220 });
221 let __inner: extern "C" fn(GZipStream, i64, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
222 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
223 __inner(__receiver, ::core::convert::Into::into(value), __mi)
224 }
225 }
226 }
227 #[doc = "`Flush()` overload"]
228 fn flush(self) -> () {
229 unsafe {
230 let __receiver = <GZipStream as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
231 {
232 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
233 let __vi = *__vt.get(20usize).unwrap_or_else(|| {
234 panic!(
235 "unity: virtual slot {}
236 out of range (vtable len {}
237) on the runtime class behind {}
238 (method `{}
239`)",
240 20usize,
241 __vt.len(),
242 <GZipStream as ::unity::ClassIdentity>::NAME,
243 "Flush",
244 )
245 });
246 let __inner: extern "C" fn(GZipStream, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
247 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
248 __inner(__receiver, __mi)
249 }
250 }
251 }
252 #[doc = "`Seek(i64, crate::system::io::seekorigin::SeekOrigin)` overload"]
253 fn seek(self, offset: impl ::core::convert::Into<i64>, origin: impl ::core::convert::Into<crate::system::io::seekorigin::SeekOrigin>) -> i64 {
254 unsafe {
255 let __receiver = <GZipStream as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
256 {
257 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
258 let __vi = *__vt.get(27usize).unwrap_or_else(|| {
259 panic!(
260 "unity: virtual slot {}
261 out of range (vtable len {}
262) on the runtime class behind {}
263 (method `{}
264`)",
265 27usize,
266 __vt.len(),
267 <GZipStream as ::unity::ClassIdentity>::NAME,
268 "Seek",
269 )
270 });
271 let __inner: extern "C" fn(GZipStream, i64, crate::system::io::seekorigin::SeekOrigin, ::unity::OptionalMethod) -> i64 =
272 ::core::mem::transmute(__vi.method_ptr);
273 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
274 __inner(__receiver, ::core::convert::Into::into(offset), ::core::convert::Into::into(origin), __mi)
275 }
276 }
277 }
278 #[doc = "`SetLength(i64)` overload"]
279 fn set_length(self, value: impl ::core::convert::Into<i64>) -> () {
280 unsafe {
281 let __receiver = <GZipStream as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
282 {
283 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
284 let __vi = *__vt.get(28usize).unwrap_or_else(|| {
285 panic!(
286 "unity: virtual slot {}
287 out of range (vtable len {}
288) on the runtime class behind {}
289 (method `{}
290`)",
291 28usize,
292 __vt.len(),
293 <GZipStream as ::unity::ClassIdentity>::NAME,
294 "SetLength",
295 )
296 });
297 let __inner: extern "C" fn(GZipStream, i64, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
298 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
299 __inner(__receiver, ::core::convert::Into::into(value), __mi)
300 }
301 }
302 }
303 #[doc = "`ReadByte()` overload"]
304 fn read_byte(self) -> i32 {
305 unsafe {
306 let __receiver = <GZipStream as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
307 {
308 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
309 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
310 panic!(
311 "unity: virtual slot {}
312 out of range (vtable len {}
313) on the runtime class behind {}
314 (method `{}
315`)",
316 30usize,
317 __vt.len(),
318 <GZipStream as ::unity::ClassIdentity>::NAME,
319 "ReadByte",
320 )
321 });
322 let __inner: extern "C" fn(GZipStream, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__vi.method_ptr);
323 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
324 __inner(__receiver, __mi)
325 }
326 }
327 }
328 #[doc = "`Read(::unity::Array<u8>, i32, i32)` overload"]
329 fn read(
330 self,
331 array: impl ::core::convert::Into<::unity::Array<u8>>,
332 offset: impl ::core::convert::Into<i32>,
333 count: impl ::core::convert::Into<i32>,
334 ) -> i32 {
335 unsafe {
336 let __receiver = <GZipStream as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
337 {
338 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
339 let __vi = *__vt.get(29usize).unwrap_or_else(|| {
340 panic!(
341 "unity: virtual slot {}
342 out of range (vtable len {}
343) on the runtime class behind {}
344 (method `{}
345`)",
346 29usize,
347 __vt.len(),
348 <GZipStream as ::unity::ClassIdentity>::NAME,
349 "Read",
350 )
351 });
352 let __inner: extern "C" fn(GZipStream, ::unity::Array<u8>, i32, i32, ::unity::OptionalMethod) -> i32 =
353 ::core::mem::transmute(__vi.method_ptr);
354 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
355 __inner(
356 __receiver,
357 ::core::convert::Into::into(array),
358 ::core::convert::Into::into(offset),
359 ::core::convert::Into::into(count),
360 __mi,
361 )
362 }
363 }
364 }
365 #[doc = "`Write(::unity::Array<u8>, i32, i32)` overload"]
366 fn write(
367 self,
368 array: impl ::core::convert::Into<::unity::Array<u8>>,
369 offset: impl ::core::convert::Into<i32>,
370 count: impl ::core::convert::Into<i32>,
371 ) -> () {
372 unsafe {
373 let __receiver = <GZipStream as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
374 {
375 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
376 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
377 panic!(
378 "unity: virtual slot {}
379 out of range (vtable len {}
380) on the runtime class behind {}
381 (method `{}
382`)",
383 31usize,
384 __vt.len(),
385 <GZipStream as ::unity::ClassIdentity>::NAME,
386 "Write",
387 )
388 });
389 let __inner: extern "C" fn(GZipStream, ::unity::Array<u8>, i32, i32, ::unity::OptionalMethod) -> () =
390 ::core::mem::transmute(__vi.method_ptr);
391 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
392 __inner(
393 __receiver,
394 ::core::convert::Into::into(array),
395 ::core::convert::Into::into(offset),
396 ::core::convert::Into::into(count),
397 __mi,
398 )
399 }
400 }
401 }
402 #[doc = "`Dispose(bool)` overload"]
403 fn dispose(self, disposing: impl ::core::convert::Into<bool>) -> () {
404 unsafe {
405 let __receiver = <GZipStream as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
406 {
407 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
408 let __vi = *__vt.get(19usize).unwrap_or_else(|| {
409 panic!(
410 "unity: virtual slot {}
411 out of range (vtable len {}
412) on the runtime class behind {}
413 (method `{}
414`)",
415 19usize,
416 __vt.len(),
417 <GZipStream as ::unity::ClassIdentity>::NAME,
418 "Dispose",
419 )
420 });
421 let __inner: extern "C" fn(GZipStream, bool, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
422 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
423 __inner(__receiver, ::core::convert::Into::into(disposing), __mi)
424 }
425 }
426 }
427 #[doc = "`CheckDeflateStream()` overload"]
428 fn check_deflate_stream(self) -> () {
429 unsafe {
430 let __receiver = <GZipStream as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
431 ::unity::il2cpp_call!((::unity::module_base()+0x34a1920usize)as*mut u8,();
432(GZipStream)__receiver)
433 }
434 }
435}
436
437#[cfg(feature = "system-io-compression-gzipstream")]
438impl<__T: IGZipStream> IGZipStreamMethods for __T {}
439
440#[cfg(feature = "system-io-compression-gzipstream")]
441impl GZipStream {
442 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
443 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
444 }
445
446 pub fn ctor_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
447 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
448 }
449
450 pub fn ctor_3_method_info() -> &'static ::unity::il2cpp::MethodInfo {
451 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
452 }
453
454 pub fn get_can_read_method_info() -> &'static ::unity::il2cpp::MethodInfo {
455 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
456 }
457
458 pub fn get_can_write_method_info() -> &'static ::unity::il2cpp::MethodInfo {
459 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
460 }
461
462 pub fn get_can_seek_method_info() -> &'static ::unity::il2cpp::MethodInfo {
463 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
464 }
465
466 pub fn get_length_method_info() -> &'static ::unity::il2cpp::MethodInfo {
467 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
468 }
469
470 pub fn get_position_method_info() -> &'static ::unity::il2cpp::MethodInfo {
471 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
472 }
473
474 pub fn set_position_method_info() -> &'static ::unity::il2cpp::MethodInfo {
475 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[8]
476 }
477
478 pub fn flush_method_info() -> &'static ::unity::il2cpp::MethodInfo {
479 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[9]
480 }
481
482 pub fn seek_method_info() -> &'static ::unity::il2cpp::MethodInfo {
483 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[10]
484 }
485
486 pub fn set_length_method_info() -> &'static ::unity::il2cpp::MethodInfo {
487 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[11]
488 }
489
490 pub fn read_byte_method_info() -> &'static ::unity::il2cpp::MethodInfo {
491 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[12]
492 }
493
494 pub fn read_method_info() -> &'static ::unity::il2cpp::MethodInfo {
495 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[15]
496 }
497
498 pub fn write_method_info() -> &'static ::unity::il2cpp::MethodInfo {
499 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[18]
500 }
501
502 pub fn dispose_method_info() -> &'static ::unity::il2cpp::MethodInfo {
503 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[19]
504 }
505
506 pub fn check_deflate_stream_method_info() -> &'static ::unity::il2cpp::MethodInfo {
507 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[22]
508 }
509
510 pub fn throw_stream_closed_exception_method_info() -> &'static ::unity::il2cpp::MethodInfo {
511 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[23]
512 }
513}
514
515#[cfg(feature = "system-io-compression-gzipstream")]
516impl GZipStream {
517 #[doc = "Direct (non-virtual) call to `GZipStream`'s own `get_CanRead`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
518 pub unsafe fn get_can_read(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
519 let __mi = Self::get_can_read_method_info();
520 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
521 __inner(this.into(), ::core::option::Option::None)
522 }
523
524 #[doc = "Direct (non-virtual) call to `GZipStream`'s own `get_CanWrite`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
525 pub unsafe fn get_can_write(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
526 let __mi = Self::get_can_write_method_info();
527 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
528 __inner(this.into(), ::core::option::Option::None)
529 }
530
531 #[doc = "Direct (non-virtual) call to `GZipStream`'s own `get_CanSeek`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
532 pub unsafe fn get_can_seek(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
533 let __mi = Self::get_can_seek_method_info();
534 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
535 __inner(this.into(), ::core::option::Option::None)
536 }
537
538 #[doc = "Direct (non-virtual) call to `GZipStream`'s own `get_Length`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
539 pub unsafe fn get_length(this: impl ::core::convert::Into<::unity::IlInstance>) -> i64 {
540 let __mi = Self::get_length_method_info();
541 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> i64 = ::core::mem::transmute(__mi.method_ptr);
542 __inner(this.into(), ::core::option::Option::None)
543 }
544
545 #[doc = "Direct (non-virtual) call to `GZipStream`'s own `get_Position`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
546 pub unsafe fn get_position(this: impl ::core::convert::Into<::unity::IlInstance>) -> i64 {
547 let __mi = Self::get_position_method_info();
548 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> i64 = ::core::mem::transmute(__mi.method_ptr);
549 __inner(this.into(), ::core::option::Option::None)
550 }
551
552 #[doc = "Direct (non-virtual) call to `GZipStream`'s own `set_Position`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
553 pub unsafe fn set_position(this: impl ::core::convert::Into<::unity::IlInstance>, value: i64) -> () {
554 let __mi = Self::set_position_method_info();
555 let __inner: extern "C" fn(::unity::IlInstance, i64, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
556 __inner(this.into(), value, ::core::option::Option::None)
557 }
558
559 #[doc = "Direct (non-virtual) call to `GZipStream`'s own `Flush`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
560 pub unsafe fn flush(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
561 let __mi = Self::flush_method_info();
562 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
563 __inner(this.into(), ::core::option::Option::None)
564 }
565
566 #[doc = "Direct (non-virtual) call to `GZipStream`'s own `Seek`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
567 pub unsafe fn seek(this: impl ::core::convert::Into<::unity::IlInstance>, offset: i64, origin: crate::system::io::seekorigin::SeekOrigin) -> i64 {
568 let __mi = Self::seek_method_info();
569 let __inner: extern "C" fn(::unity::IlInstance, i64, crate::system::io::seekorigin::SeekOrigin, ::unity::OptionalMethod) -> i64 =
570 ::core::mem::transmute(__mi.method_ptr);
571 __inner(this.into(), offset, origin, ::core::option::Option::None)
572 }
573
574 #[doc = "Direct (non-virtual) call to `GZipStream`'s own `SetLength`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
575 pub unsafe fn set_length(this: impl ::core::convert::Into<::unity::IlInstance>, value: i64) -> () {
576 let __mi = Self::set_length_method_info();
577 let __inner: extern "C" fn(::unity::IlInstance, i64, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
578 __inner(this.into(), value, ::core::option::Option::None)
579 }
580
581 #[doc = "Direct (non-virtual) call to `GZipStream`'s own `ReadByte`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
582 pub unsafe fn read_byte(this: impl ::core::convert::Into<::unity::IlInstance>) -> i32 {
583 let __mi = Self::read_byte_method_info();
584 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__mi.method_ptr);
585 __inner(this.into(), ::core::option::Option::None)
586 }
587
588 #[doc = "Direct (non-virtual) call to `GZipStream`'s own `Read`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
589 pub unsafe fn read(this: impl ::core::convert::Into<::unity::IlInstance>, array: ::unity::Array<u8>, offset: i32, count: i32) -> i32 {
590 let __mi = Self::read_method_info();
591 let __inner: extern "C" fn(::unity::IlInstance, ::unity::Array<u8>, i32, i32, ::unity::OptionalMethod) -> i32 =
592 ::core::mem::transmute(__mi.method_ptr);
593 __inner(this.into(), array, offset, count, ::core::option::Option::None)
594 }
595
596 #[doc = "Direct (non-virtual) call to `GZipStream`'s own `Write`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
597 pub unsafe fn write(this: impl ::core::convert::Into<::unity::IlInstance>, array: ::unity::Array<u8>, offset: i32, count: i32) -> () {
598 let __mi = Self::write_method_info();
599 let __inner: extern "C" fn(::unity::IlInstance, ::unity::Array<u8>, i32, i32, ::unity::OptionalMethod) -> () =
600 ::core::mem::transmute(__mi.method_ptr);
601 __inner(this.into(), array, offset, count, ::core::option::Option::None)
602 }
603
604 #[doc = "Direct (non-virtual) call to `GZipStream`'s own `Dispose`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
605 pub unsafe fn dispose(this: impl ::core::convert::Into<::unity::IlInstance>, disposing: bool) -> () {
606 let __mi = Self::dispose_method_info();
607 let __inner: extern "C" fn(::unity::IlInstance, bool, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
608 __inner(this.into(), disposing, ::core::option::Option::None)
609 }
610}
611
612#[cfg(feature = "system-io-compression-gzipstream")]
613impl GZipStream {
614 #[doc = "`.ctor(crate::system::io::stream::Stream, crate::system::io::compression::compressionmode::CompressionMode)` — overload selector"]
615 pub fn new(stream: crate::system::io::stream::Stream, mode: crate::system::io::compression::compressionmode::CompressionMode) -> Self {
616 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
617 panic!(
618 "{}
619::{}
620 failed to instantiate",
621 ::core::stringify!(GZipStream),
622 ::core::stringify!(new),
623 )
624 });
625 <Self as IGZipStreamMethods>::ctor(this, stream, mode);
626 this
627 }
628
629 #[doc = "`.ctor(crate::system::io::stream::Stream, crate::system::io::compression::compressionmode::CompressionMode, bool)` — overload selector"]
630 pub fn new_2(
631 stream: crate::system::io::stream::Stream,
632 mode: crate::system::io::compression::compressionmode::CompressionMode,
633 leave_open: bool,
634 ) -> Self {
635 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
636 panic!(
637 "{}
638::{}
639 failed to instantiate",
640 ::core::stringify!(GZipStream),
641 ::core::stringify!(new_2),
642 )
643 });
644 <Self as IGZipStreamMethods>::ctor_2(this, stream, mode, leave_open);
645 this
646 }
647
648 #[doc = "`.ctor(crate::system::io::stream::Stream, crate::system::io::compression::compressionlevel::CompressionLevel, bool)` — overload selector"]
649 pub fn new_3(
650 stream: crate::system::io::stream::Stream,
651 compression_level: crate::system::io::compression::compressionlevel::CompressionLevel,
652 leave_open: bool,
653 ) -> Self {
654 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
655 panic!(
656 "{}
657::{}
658 failed to instantiate",
659 ::core::stringify!(GZipStream),
660 ::core::stringify!(new_3),
661 )
662 });
663 <Self as IGZipStreamMethods>::ctor_3(this, stream, compression_level, leave_open);
664 this
665 }
666}
667
668#[cfg(feature = "system-io-compression-gzipstream")]
669#[doc(hidden)]
670pub mod prelude {
671 pub use super::{GZipStream, IGZipStream, IGZipStreamMethods};
672 #[cfg(feature = "system-io-stream")]
673 pub use crate::system::io::stream::IStreamMethods;
674 #[cfg(feature = "system-object")]
675 pub use crate::system::object::IObjectMethods;
676 pub use crate::system::{io::stream::IStream, object::IObject};
677}