1#[cfg(feature = "system-io-binarywriter-types")]
4mod __types {
5 #[allow(unused_imports)] use ::unity::prelude::*;
6
7 use super::*;
8 use crate::system::object::{IObject, Object};
9
10 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/system/io/binarywriter/BinaryWriter.md"))]
11 #[::unity::class(namespace = "System.IO", name = "BinaryWriter")]
12 #[parent(crate::system::object::Object)]
13 pub struct BinaryWriter {
14 #[static_field]
15 #[rename(name = "Null")]
16 pub null: crate::system::io::binarywriter::BinaryWriter,
17 #[offset(16)]
18 #[rename(name = "OutStream")]
19 pub out_stream: crate::system::io::stream::Stream,
20 #[offset(24)]
21 #[rename(name = "_buffer")]
22 pub buffer: ::unity::Array<u8>,
23 #[offset(48)]
24 #[rename(name = "_leaveOpen")]
25 pub leave_open: bool,
26 #[offset(56)]
27 #[rename(name = "_largeByteBuffer")]
28 pub large_byte_buffer: ::unity::Array<u8>,
29 #[offset(64)]
30 #[rename(name = "_maxChars")]
31 pub max_chars: i32,
32 }
33}
34
35#[cfg(feature = "system-io-binarywriter-types")]
36pub use __types::*;
37
38#[cfg(feature = "system-io-binarywriter")]
39impl BinaryWriter {
40 #[doc = "`.cctor()` overload"]
41 pub fn cctor() -> () {
42 unsafe {
43 ::unity::il2cpp_call!((::unity::module_base()+0x3390bb0usize)as*mut u8,();
44 )
45 }
46 }
47}
48
49#[cfg(feature = "system-io-binarywriter")]
50pub trait IBinaryWriterMethods: IBinaryWriter {
51 #[doc = "`.ctor()` overload"]
52 fn ctor(self) -> () {
53 unsafe {
54 let __receiver = <BinaryWriter as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
55 ::unity::il2cpp_call!((::unity::module_base()+0x338fcb0usize)as*mut u8,();
56(BinaryWriter)__receiver)
57 }
58 }
59 #[doc = "`.ctor(crate::system::io::stream::Stream)` overload"]
60 fn ctor_2(self, output: impl ::core::convert::Into<crate::system::io::stream::Stream>) -> () {
61 unsafe {
62 let __receiver = <BinaryWriter as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
63 ::unity::il2cpp_call!((::unity::module_base()+0x338fdd0usize)as*mut u8,();
64(BinaryWriter)__receiver,(crate::system::io::stream::Stream)::core::convert::Into::into(output))
65 }
66 }
67 #[doc = "`Dispose(bool)` overload"]
68 fn dispose(self, disposing: impl ::core::convert::Into<bool>) -> () {
69 unsafe {
70 let __receiver = <BinaryWriter as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
71 {
72 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
73 let __vi = *__vt.get(5usize).unwrap_or_else(|| {
74 panic!(
75 "unity: virtual slot {}
76 out of range (vtable len {}
77) on the runtime class behind {}
78 (method `{}
79`)",
80 5usize,
81 __vt.len(),
82 <BinaryWriter as ::unity::ClassIdentity>::NAME,
83 "Dispose",
84 )
85 });
86 let __inner: extern "C" fn(BinaryWriter, bool, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
87 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
88 __inner(__receiver, ::core::convert::Into::into(disposing), __mi)
89 }
90 }
91 }
92 #[doc = "`Dispose()` overload"]
93 fn dispose_2(self) -> () {
94 unsafe {
95 let __receiver = <BinaryWriter as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
96 {
97 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
98 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
99 panic!(
100 "unity: virtual slot {}
101 out of range (vtable len {}
102) on the runtime class behind {}
103 (method `{}
104`)",
105 4usize,
106 __vt.len(),
107 <BinaryWriter as ::unity::ClassIdentity>::NAME,
108 "Dispose",
109 )
110 });
111 let __inner: extern "C" fn(BinaryWriter, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
112 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
113 __inner(__receiver, __mi)
114 }
115 }
116 }
117 #[doc = "`Flush()` overload"]
118 fn flush(self) -> () {
119 unsafe {
120 let __receiver = <BinaryWriter as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
121 {
122 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
123 let __vi = *__vt.get(6usize).unwrap_or_else(|| {
124 panic!(
125 "unity: virtual slot {}
126 out of range (vtable len {}
127) on the runtime class behind {}
128 (method `{}
129`)",
130 6usize,
131 __vt.len(),
132 <BinaryWriter as ::unity::ClassIdentity>::NAME,
133 "Flush",
134 )
135 });
136 let __inner: extern "C" fn(BinaryWriter, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
137 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
138 __inner(__receiver, __mi)
139 }
140 }
141 }
142 #[doc = "`Write(bool)` overload"]
143 fn write(self, value: impl ::core::convert::Into<bool>) -> () {
144 unsafe {
145 let __receiver = <BinaryWriter as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
146 {
147 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
148 let __vi = *__vt.get(7usize).unwrap_or_else(|| {
149 panic!(
150 "unity: virtual slot {}
151 out of range (vtable len {}
152) on the runtime class behind {}
153 (method `{}
154`)",
155 7usize,
156 __vt.len(),
157 <BinaryWriter as ::unity::ClassIdentity>::NAME,
158 "Write",
159 )
160 });
161 let __inner: extern "C" fn(BinaryWriter, bool, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
162 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
163 __inner(__receiver, ::core::convert::Into::into(value), __mi)
164 }
165 }
166 }
167 #[doc = "`Write(u8)` overload"]
168 fn write_2(self, value: impl ::core::convert::Into<u8>) -> () {
169 unsafe {
170 let __receiver = <BinaryWriter as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
171 {
172 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
173 let __vi = *__vt.get(8usize).unwrap_or_else(|| {
174 panic!(
175 "unity: virtual slot {}
176 out of range (vtable len {}
177) on the runtime class behind {}
178 (method `{}
179`)",
180 8usize,
181 __vt.len(),
182 <BinaryWriter as ::unity::ClassIdentity>::NAME,
183 "Write",
184 )
185 });
186 let __inner: extern "C" fn(BinaryWriter, u8, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
187 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
188 __inner(__receiver, ::core::convert::Into::into(value), __mi)
189 }
190 }
191 }
192 #[doc = "`Write(i8)` overload"]
193 fn write_3(self, value: impl ::core::convert::Into<i8>) -> () {
194 unsafe {
195 let __receiver = <BinaryWriter as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
196 {
197 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
198 let __vi = *__vt.get(9usize).unwrap_or_else(|| {
199 panic!(
200 "unity: virtual slot {}
201 out of range (vtable len {}
202) on the runtime class behind {}
203 (method `{}
204`)",
205 9usize,
206 __vt.len(),
207 <BinaryWriter as ::unity::ClassIdentity>::NAME,
208 "Write",
209 )
210 });
211 let __inner: extern "C" fn(BinaryWriter, i8, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
212 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
213 __inner(__receiver, ::core::convert::Into::into(value), __mi)
214 }
215 }
216 }
217 #[doc = "`Write(::unity::Array<u8>)` overload"]
218 fn write_4(self, buffer: impl ::core::convert::Into<::unity::Array<u8>>) -> () {
219 unsafe {
220 let __receiver = <BinaryWriter as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
221 {
222 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
223 let __vi = *__vt.get(10usize).unwrap_or_else(|| {
224 panic!(
225 "unity: virtual slot {}
226 out of range (vtable len {}
227) on the runtime class behind {}
228 (method `{}
229`)",
230 10usize,
231 __vt.len(),
232 <BinaryWriter as ::unity::ClassIdentity>::NAME,
233 "Write",
234 )
235 });
236 let __inner: extern "C" fn(BinaryWriter, ::unity::Array<u8>, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
237 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
238 __inner(__receiver, ::core::convert::Into::into(buffer), __mi)
239 }
240 }
241 }
242 #[doc = "`Write(::unity::Array<u8>, i32, i32)` overload"]
243 fn write_5(
244 self,
245 buffer: impl ::core::convert::Into<::unity::Array<u8>>,
246 index: impl ::core::convert::Into<i32>,
247 count: impl ::core::convert::Into<i32>,
248 ) -> () {
249 unsafe {
250 let __receiver = <BinaryWriter as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
251 {
252 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
253 let __vi = *__vt.get(11usize).unwrap_or_else(|| {
254 panic!(
255 "unity: virtual slot {}
256 out of range (vtable len {}
257) on the runtime class behind {}
258 (method `{}
259`)",
260 11usize,
261 __vt.len(),
262 <BinaryWriter as ::unity::ClassIdentity>::NAME,
263 "Write",
264 )
265 });
266 let __inner: extern "C" fn(BinaryWriter, ::unity::Array<u8>, i32, i32, ::unity::OptionalMethod) -> () =
267 ::core::mem::transmute(__vi.method_ptr);
268 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
269 __inner(
270 __receiver,
271 ::core::convert::Into::into(buffer),
272 ::core::convert::Into::into(index),
273 ::core::convert::Into::into(count),
274 __mi,
275 )
276 }
277 }
278 }
279 #[doc = "`Write(u16)` overload"]
280 fn write_6(self, ch: impl ::core::convert::Into<u16>) -> () {
281 unsafe {
282 let __receiver = <BinaryWriter as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
283 {
284 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
285 let __vi = *__vt.get(12usize).unwrap_or_else(|| {
286 panic!(
287 "unity: virtual slot {}
288 out of range (vtable len {}
289) on the runtime class behind {}
290 (method `{}
291`)",
292 12usize,
293 __vt.len(),
294 <BinaryWriter as ::unity::ClassIdentity>::NAME,
295 "Write",
296 )
297 });
298 let __inner: extern "C" fn(BinaryWriter, u16, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
299 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
300 __inner(__receiver, ::core::convert::Into::into(ch), __mi)
301 }
302 }
303 }
304 #[doc = "`Write(::unity::Array<u16>)` overload"]
305 fn write_7(self, chars: impl ::core::convert::Into<::unity::Array<u16>>) -> () {
306 unsafe {
307 let __receiver = <BinaryWriter 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(13usize).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 13usize,
318 __vt.len(),
319 <BinaryWriter as ::unity::ClassIdentity>::NAME,
320 "Write",
321 )
322 });
323 let __inner: extern "C" fn(BinaryWriter, ::unity::Array<u16>, ::unity::OptionalMethod) -> () =
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(__receiver, ::core::convert::Into::into(chars), __mi)
327 }
328 }
329 }
330 #[doc = "`Write(f64)` overload"]
331 fn write_8(self, value: impl ::core::convert::Into<f64>) -> () {
332 unsafe {
333 let __receiver = <BinaryWriter as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
334 {
335 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
336 let __vi = *__vt.get(14usize).unwrap_or_else(|| {
337 panic!(
338 "unity: virtual slot {}
339 out of range (vtable len {}
340) on the runtime class behind {}
341 (method `{}
342`)",
343 14usize,
344 __vt.len(),
345 <BinaryWriter as ::unity::ClassIdentity>::NAME,
346 "Write",
347 )
348 });
349 let __inner: extern "C" fn(BinaryWriter, f64, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
350 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
351 __inner(__receiver, ::core::convert::Into::into(value), __mi)
352 }
353 }
354 }
355 #[doc = "`Write(i16)` overload"]
356 fn write_9(self, value: impl ::core::convert::Into<i16>) -> () {
357 unsafe {
358 let __receiver = <BinaryWriter as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
359 {
360 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
361 let __vi = *__vt.get(15usize).unwrap_or_else(|| {
362 panic!(
363 "unity: virtual slot {}
364 out of range (vtable len {}
365) on the runtime class behind {}
366 (method `{}
367`)",
368 15usize,
369 __vt.len(),
370 <BinaryWriter as ::unity::ClassIdentity>::NAME,
371 "Write",
372 )
373 });
374 let __inner: extern "C" fn(BinaryWriter, i16, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
375 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
376 __inner(__receiver, ::core::convert::Into::into(value), __mi)
377 }
378 }
379 }
380 #[doc = "`Write(i32)` overload"]
381 fn write_10(self, value: impl ::core::convert::Into<i32>) -> () {
382 unsafe {
383 let __receiver = <BinaryWriter as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
384 {
385 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
386 let __vi = *__vt.get(17usize).unwrap_or_else(|| {
387 panic!(
388 "unity: virtual slot {}
389 out of range (vtable len {}
390) on the runtime class behind {}
391 (method `{}
392`)",
393 17usize,
394 __vt.len(),
395 <BinaryWriter as ::unity::ClassIdentity>::NAME,
396 "Write",
397 )
398 });
399 let __inner: extern "C" fn(BinaryWriter, i32, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
400 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
401 __inner(__receiver, ::core::convert::Into::into(value), __mi)
402 }
403 }
404 }
405 #[doc = "`Write(u32)` overload"]
406 fn write_11(self, value: impl ::core::convert::Into<u32>) -> () {
407 unsafe {
408 let __receiver = <BinaryWriter as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
409 {
410 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
411 let __vi = *__vt.get(18usize).unwrap_or_else(|| {
412 panic!(
413 "unity: virtual slot {}
414 out of range (vtable len {}
415) on the runtime class behind {}
416 (method `{}
417`)",
418 18usize,
419 __vt.len(),
420 <BinaryWriter as ::unity::ClassIdentity>::NAME,
421 "Write",
422 )
423 });
424 let __inner: extern "C" fn(BinaryWriter, u32, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
425 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
426 __inner(__receiver, ::core::convert::Into::into(value), __mi)
427 }
428 }
429 }
430 #[doc = "`Write(i64)` overload"]
431 fn write_12(self, value: impl ::core::convert::Into<i64>) -> () {
432 unsafe {
433 let __receiver = <BinaryWriter as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
434 {
435 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
436 let __vi = *__vt.get(19usize).unwrap_or_else(|| {
437 panic!(
438 "unity: virtual slot {}
439 out of range (vtable len {}
440) on the runtime class behind {}
441 (method `{}
442`)",
443 19usize,
444 __vt.len(),
445 <BinaryWriter as ::unity::ClassIdentity>::NAME,
446 "Write",
447 )
448 });
449 let __inner: extern "C" fn(BinaryWriter, i64, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
450 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
451 __inner(__receiver, ::core::convert::Into::into(value), __mi)
452 }
453 }
454 }
455 #[doc = "`Write(u64)` overload"]
456 fn write_13(self, value: impl ::core::convert::Into<u64>) -> () {
457 unsafe {
458 let __receiver = <BinaryWriter as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
459 {
460 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
461 let __vi = *__vt.get(20usize).unwrap_or_else(|| {
462 panic!(
463 "unity: virtual slot {}
464 out of range (vtable len {}
465) on the runtime class behind {}
466 (method `{}
467`)",
468 20usize,
469 __vt.len(),
470 <BinaryWriter as ::unity::ClassIdentity>::NAME,
471 "Write",
472 )
473 });
474 let __inner: extern "C" fn(BinaryWriter, u64, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
475 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
476 __inner(__receiver, ::core::convert::Into::into(value), __mi)
477 }
478 }
479 }
480 #[doc = "`Write(f32)` overload"]
481 fn write_14(self, value: impl ::core::convert::Into<f32>) -> () {
482 unsafe {
483 let __receiver = <BinaryWriter as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
484 {
485 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
486 let __vi = *__vt.get(21usize).unwrap_or_else(|| {
487 panic!(
488 "unity: virtual slot {}
489 out of range (vtable len {}
490) on the runtime class behind {}
491 (method `{}
492`)",
493 21usize,
494 __vt.len(),
495 <BinaryWriter as ::unity::ClassIdentity>::NAME,
496 "Write",
497 )
498 });
499 let __inner: extern "C" fn(BinaryWriter, f32, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
500 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
501 __inner(__receiver, ::core::convert::Into::into(value), __mi)
502 }
503 }
504 }
505 #[doc = "`Write(::unity::Il2CppString)` overload"]
506 fn write_15(self, value: impl ::core::convert::Into<::unity::Il2CppString>) -> () {
507 unsafe {
508 let __receiver = <BinaryWriter as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
509 {
510 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
511 let __vi = *__vt.get(22usize).unwrap_or_else(|| {
512 panic!(
513 "unity: virtual slot {}
514 out of range (vtable len {}
515) on the runtime class behind {}
516 (method `{}
517`)",
518 22usize,
519 __vt.len(),
520 <BinaryWriter as ::unity::ClassIdentity>::NAME,
521 "Write",
522 )
523 });
524 let __inner: extern "C" fn(BinaryWriter, ::unity::Il2CppString, ::unity::OptionalMethod) -> () =
525 ::core::mem::transmute(__vi.method_ptr);
526 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
527 __inner(__receiver, ::core::convert::Into::into(value), __mi)
528 }
529 }
530 }
531 #[doc = "`Write7BitEncodedInt(i32)` overload"]
532 fn write7_bit_encoded_int(self, value: impl ::core::convert::Into<i32>) -> () {
533 unsafe {
534 let __receiver = <BinaryWriter as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
535 ::unity::il2cpp_call!((::unity::module_base()+0x3390b40usize)as*mut u8,();
536(BinaryWriter)__receiver,(i32)::core::convert::Into::into(value))
537 }
538 }
539}
540
541#[cfg(feature = "system-io-binarywriter")]
542impl<__T: IBinaryWriter> IBinaryWriterMethods for __T {}
543
544#[cfg(feature = "system-io-binarywriter")]
545impl BinaryWriter {
546 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
547 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
548 }
549
550 pub fn ctor_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
551 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
552 }
553
554 pub fn dispose_method_info() -> &'static ::unity::il2cpp::MethodInfo {
555 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
556 }
557
558 pub fn dispose_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
559 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
560 }
561
562 pub fn flush_method_info() -> &'static ::unity::il2cpp::MethodInfo {
563 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
564 }
565
566 pub fn write_method_info() -> &'static ::unity::il2cpp::MethodInfo {
567 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
568 }
569
570 pub fn write_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
571 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[8]
572 }
573
574 pub fn write_3_method_info() -> &'static ::unity::il2cpp::MethodInfo {
575 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[9]
576 }
577
578 pub fn write_4_method_info() -> &'static ::unity::il2cpp::MethodInfo {
579 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[10]
580 }
581
582 pub fn write_5_method_info() -> &'static ::unity::il2cpp::MethodInfo {
583 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[11]
584 }
585
586 pub fn write_6_method_info() -> &'static ::unity::il2cpp::MethodInfo {
587 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[12]
588 }
589
590 pub fn write_7_method_info() -> &'static ::unity::il2cpp::MethodInfo {
591 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[13]
592 }
593
594 pub fn write_8_method_info() -> &'static ::unity::il2cpp::MethodInfo {
595 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[14]
596 }
597
598 pub fn write_9_method_info() -> &'static ::unity::il2cpp::MethodInfo {
599 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[15]
600 }
601
602 pub fn write_10_method_info() -> &'static ::unity::il2cpp::MethodInfo {
603 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[17]
604 }
605
606 pub fn write_11_method_info() -> &'static ::unity::il2cpp::MethodInfo {
607 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[18]
608 }
609
610 pub fn write_12_method_info() -> &'static ::unity::il2cpp::MethodInfo {
611 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[19]
612 }
613
614 pub fn write_13_method_info() -> &'static ::unity::il2cpp::MethodInfo {
615 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[20]
616 }
617
618 pub fn write_14_method_info() -> &'static ::unity::il2cpp::MethodInfo {
619 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[21]
620 }
621
622 pub fn write_15_method_info() -> &'static ::unity::il2cpp::MethodInfo {
623 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[22]
624 }
625
626 pub fn write7_bit_encoded_int_method_info() -> &'static ::unity::il2cpp::MethodInfo {
627 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[23]
628 }
629
630 pub fn cctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
631 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[24]
632 }
633}
634
635#[cfg(feature = "system-io-binarywriter")]
636impl BinaryWriter {
637 #[doc = "Direct (non-virtual) call to `BinaryWriter`'s own `Dispose`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
638 pub unsafe fn dispose(this: impl ::core::convert::Into<::unity::IlInstance>, disposing: bool) -> () {
639 let __mi = Self::dispose_method_info();
640 let __inner: extern "C" fn(::unity::IlInstance, bool, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
641 __inner(this.into(), disposing, ::core::option::Option::None)
642 }
643
644 #[doc = "Direct (non-virtual) call to `BinaryWriter`'s own `Dispose`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
645 pub unsafe fn dispose_2(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
646 let __mi = Self::dispose_2_method_info();
647 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
648 __inner(this.into(), ::core::option::Option::None)
649 }
650
651 #[doc = "Direct (non-virtual) call to `BinaryWriter`'s own `Flush`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
652 pub unsafe fn flush(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
653 let __mi = Self::flush_method_info();
654 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
655 __inner(this.into(), ::core::option::Option::None)
656 }
657
658 #[doc = "Direct (non-virtual) call to `BinaryWriter`'s own `Write`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
659 pub unsafe fn write(this: impl ::core::convert::Into<::unity::IlInstance>, value: bool) -> () {
660 let __mi = Self::write_method_info();
661 let __inner: extern "C" fn(::unity::IlInstance, bool, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
662 __inner(this.into(), value, ::core::option::Option::None)
663 }
664
665 #[doc = "Direct (non-virtual) call to `BinaryWriter`'s own `Write`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
666 pub unsafe fn write_2(this: impl ::core::convert::Into<::unity::IlInstance>, value: u8) -> () {
667 let __mi = Self::write_2_method_info();
668 let __inner: extern "C" fn(::unity::IlInstance, u8, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
669 __inner(this.into(), value, ::core::option::Option::None)
670 }
671
672 #[doc = "Direct (non-virtual) call to `BinaryWriter`'s own `Write`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
673 pub unsafe fn write_3(this: impl ::core::convert::Into<::unity::IlInstance>, value: i8) -> () {
674 let __mi = Self::write_3_method_info();
675 let __inner: extern "C" fn(::unity::IlInstance, i8, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
676 __inner(this.into(), value, ::core::option::Option::None)
677 }
678
679 #[doc = "Direct (non-virtual) call to `BinaryWriter`'s own `Write`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
680 pub unsafe fn write_4(this: impl ::core::convert::Into<::unity::IlInstance>, buffer: ::unity::Array<u8>) -> () {
681 let __mi = Self::write_4_method_info();
682 let __inner: extern "C" fn(::unity::IlInstance, ::unity::Array<u8>, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
683 __inner(this.into(), buffer, ::core::option::Option::None)
684 }
685
686 #[doc = "Direct (non-virtual) call to `BinaryWriter`'s own `Write`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
687 pub unsafe fn write_5(this: impl ::core::convert::Into<::unity::IlInstance>, buffer: ::unity::Array<u8>, index: i32, count: i32) -> () {
688 let __mi = Self::write_5_method_info();
689 let __inner: extern "C" fn(::unity::IlInstance, ::unity::Array<u8>, i32, i32, ::unity::OptionalMethod) -> () =
690 ::core::mem::transmute(__mi.method_ptr);
691 __inner(this.into(), buffer, index, count, ::core::option::Option::None)
692 }
693
694 #[doc = "Direct (non-virtual) call to `BinaryWriter`'s own `Write`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
695 pub unsafe fn write_6(this: impl ::core::convert::Into<::unity::IlInstance>, ch: u16) -> () {
696 let __mi = Self::write_6_method_info();
697 let __inner: extern "C" fn(::unity::IlInstance, u16, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
698 __inner(this.into(), ch, ::core::option::Option::None)
699 }
700
701 #[doc = "Direct (non-virtual) call to `BinaryWriter`'s own `Write`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
702 pub unsafe fn write_7(this: impl ::core::convert::Into<::unity::IlInstance>, chars: ::unity::Array<u16>) -> () {
703 let __mi = Self::write_7_method_info();
704 let __inner: extern "C" fn(::unity::IlInstance, ::unity::Array<u16>, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
705 __inner(this.into(), chars, ::core::option::Option::None)
706 }
707
708 #[doc = "Direct (non-virtual) call to `BinaryWriter`'s own `Write`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
709 pub unsafe fn write_8(this: impl ::core::convert::Into<::unity::IlInstance>, value: f64) -> () {
710 let __mi = Self::write_8_method_info();
711 let __inner: extern "C" fn(::unity::IlInstance, f64, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
712 __inner(this.into(), value, ::core::option::Option::None)
713 }
714
715 #[doc = "Direct (non-virtual) call to `BinaryWriter`'s own `Write`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
716 pub unsafe fn write_9(this: impl ::core::convert::Into<::unity::IlInstance>, value: i16) -> () {
717 let __mi = Self::write_9_method_info();
718 let __inner: extern "C" fn(::unity::IlInstance, i16, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
719 __inner(this.into(), value, ::core::option::Option::None)
720 }
721
722 #[doc = "Direct (non-virtual) call to `BinaryWriter`'s own `Write`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
723 pub unsafe fn write_10(this: impl ::core::convert::Into<::unity::IlInstance>, value: i32) -> () {
724 let __mi = Self::write_10_method_info();
725 let __inner: extern "C" fn(::unity::IlInstance, i32, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
726 __inner(this.into(), value, ::core::option::Option::None)
727 }
728
729 #[doc = "Direct (non-virtual) call to `BinaryWriter`'s own `Write`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
730 pub unsafe fn write_11(this: impl ::core::convert::Into<::unity::IlInstance>, value: u32) -> () {
731 let __mi = Self::write_11_method_info();
732 let __inner: extern "C" fn(::unity::IlInstance, u32, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
733 __inner(this.into(), value, ::core::option::Option::None)
734 }
735
736 #[doc = "Direct (non-virtual) call to `BinaryWriter`'s own `Write`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
737 pub unsafe fn write_12(this: impl ::core::convert::Into<::unity::IlInstance>, value: i64) -> () {
738 let __mi = Self::write_12_method_info();
739 let __inner: extern "C" fn(::unity::IlInstance, i64, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
740 __inner(this.into(), value, ::core::option::Option::None)
741 }
742
743 #[doc = "Direct (non-virtual) call to `BinaryWriter`'s own `Write`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
744 pub unsafe fn write_13(this: impl ::core::convert::Into<::unity::IlInstance>, value: u64) -> () {
745 let __mi = Self::write_13_method_info();
746 let __inner: extern "C" fn(::unity::IlInstance, u64, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
747 __inner(this.into(), value, ::core::option::Option::None)
748 }
749
750 #[doc = "Direct (non-virtual) call to `BinaryWriter`'s own `Write`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
751 pub unsafe fn write_14(this: impl ::core::convert::Into<::unity::IlInstance>, value: f32) -> () {
752 let __mi = Self::write_14_method_info();
753 let __inner: extern "C" fn(::unity::IlInstance, f32, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
754 __inner(this.into(), value, ::core::option::Option::None)
755 }
756
757 #[doc = "Direct (non-virtual) call to `BinaryWriter`'s own `Write`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
758 pub unsafe fn write_15(this: impl ::core::convert::Into<::unity::IlInstance>, value: ::unity::Il2CppString) -> () {
759 let __mi = Self::write_15_method_info();
760 let __inner: extern "C" fn(::unity::IlInstance, ::unity::Il2CppString, ::unity::OptionalMethod) -> () =
761 ::core::mem::transmute(__mi.method_ptr);
762 __inner(this.into(), value, ::core::option::Option::None)
763 }
764}
765
766#[cfg(feature = "system-io-binarywriter")]
767impl BinaryWriter {
768 #[doc = "`.ctor()` — no args"]
769 pub fn new() -> Self {
770 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
771 panic!(
772 "{}
773::{}
774 failed to instantiate",
775 ::core::stringify!(BinaryWriter),
776 ::core::stringify!(new),
777 )
778 });
779 <Self as IBinaryWriterMethods>::ctor(this);
780 this
781 }
782
783 #[doc = "`.ctor(crate::system::io::stream::Stream)` — overload selector"]
784 pub fn new_2(output: crate::system::io::stream::Stream) -> Self {
785 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
786 panic!(
787 "{}
788::{}
789 failed to instantiate",
790 ::core::stringify!(BinaryWriter),
791 ::core::stringify!(new_2),
792 )
793 });
794 <Self as IBinaryWriterMethods>::ctor_2(this, output);
795 this
796 }
797}
798
799#[cfg(feature = "system-io-binarywriter")]
800#[doc(hidden)]
801pub mod prelude {
802 pub use super::{BinaryWriter, IBinaryWriter, IBinaryWriterMethods};
803 pub use crate::system::object::IObject;
804 #[cfg(feature = "system-object")]
805 pub use crate::system::object::IObjectMethods;
806}