1#[cfg(feature = "system-io-textwriter-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/textwriter/TextWriter.md"))]
11 #[::unity::class(namespace = "System.IO", name = "TextWriter")]
12 pub struct TextWriter {
13 #[static_field]
14 #[rename(name = "Null")]
15 pub null: crate::system::io::textwriter::TextWriter,
16 #[static_field]
17 #[rename(name = "_WriteCharDelegate")]
18 pub write_char_delegate: crate::system::action_1::Action_1<crate::system::object::Object>,
19 #[static_field]
20 #[rename(name = "_WriteStringDelegate")]
21 pub write_string_delegate: crate::system::action_1::Action_1<crate::system::object::Object>,
22 #[static_field]
23 #[rename(name = "_WriteCharArrayRangeDelegate")]
24 pub write_char_array_range_delegate: crate::system::action_1::Action_1<crate::system::object::Object>,
25 #[static_field]
26 #[rename(name = "_WriteLineCharDelegate")]
27 pub write_line_char_delegate: crate::system::action_1::Action_1<crate::system::object::Object>,
28 #[static_field]
29 #[rename(name = "_WriteLineStringDelegate")]
30 pub write_line_string_delegate: crate::system::action_1::Action_1<crate::system::object::Object>,
31 #[static_field]
32 #[rename(name = "_WriteLineCharArrayRangeDelegate")]
33 pub write_line_char_array_range_delegate: crate::system::action_1::Action_1<crate::system::object::Object>,
34 #[static_field]
35 #[rename(name = "_FlushDelegate")]
36 pub flush_delegate: crate::system::action_1::Action_1<crate::system::object::Object>,
37 #[offset(24)]
38 #[rename(name = "CoreNewLine")]
39 pub core_new_line: ::unity::Array<u16>,
40 }
41
42 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/system/io/textwriter/TextWriter_SyncTextWriter.md"))]
43 #[::unity::class(namespace = "System.IO", name = "TextWriter.SyncTextWriter")]
44 #[parent(crate::system::io::textwriter::TextWriter)]
45 pub struct TextWriter_SyncTextWriter {
46 #[offset(40)]
47 #[rename(name = "_out")]
48 pub out: crate::system::io::textwriter::TextWriter,
49 }
50
51 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/system/io/textwriter/TextWriter_NullTextWriter.md"))]
52 #[::unity::class(namespace = "System.IO", name = "TextWriter.NullTextWriter")]
53 #[parent(crate::system::io::textwriter::TextWriter)]
54 pub struct TextWriter_NullTextWriter {}
55}
56
57#[cfg(feature = "system-io-textwriter-types")]
58pub use __types::*;
59
60#[cfg(feature = "system-io-textwriter")]
61impl TextWriter {
62 #[doc = "`get_InitialNewLine()` overload"]
63 pub fn get_initial_new_line() -> ::unity::Il2CppString {
64 unsafe {
65 ::unity::il2cpp_call!((::unity::module_base()+0x34e1330usize)as*mut u8, ::unity::Il2CppString;
66 )
67 }
68 }
69
70 #[doc = "`Synchronized(crate::system::io::textwriter::TextWriter)` overload"]
71 pub fn synchronized(writer: impl ::core::convert::Into<crate::system::io::textwriter::TextWriter>) -> crate::system::io::textwriter::TextWriter {
72 unsafe {
73 ::unity::il2cpp_call!((::unity::module_base()+0x34e16a0usize)as*mut u8,crate::system::io::textwriter::TextWriter;
74(crate::system::io::textwriter::TextWriter)::core::convert::Into::into(writer))
75 }
76 }
77
78 #[doc = "`.cctor()` overload"]
79 pub fn cctor() -> () {
80 unsafe {
81 ::unity::il2cpp_call!((::unity::module_base()+0x34e1cd0usize)as*mut u8,();
82 )
83 }
84 }
85}
86
87#[cfg(feature = "system-io-textwriter")]
88pub trait ITextWriterMethods: ITextWriter {
89 #[doc = "`.ctor()` overload"]
90 fn ctor(self) -> () {
91 unsafe {
92 let __receiver = <TextWriter as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
93 ::unity::il2cpp_call!((::unity::module_base()+0x34e1340usize)as*mut u8,();
94(TextWriter)__receiver)
95 }
96 }
97 #[doc = "`Close()` overload"]
98 fn close(self) -> () {
99 unsafe {
100 let __receiver = <TextWriter as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
101 {
102 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
103 let __vi = *__vt.get(8usize).unwrap_or_else(|| {
104 panic!(
105 "unity: virtual slot {}
106 out of range (vtable len {}
107) on the runtime class behind {}
108 (method `{}
109`)",
110 8usize,
111 __vt.len(),
112 <TextWriter as ::unity::ClassIdentity>::NAME,
113 "Close",
114 )
115 });
116 let __inner: extern "C" fn(TextWriter, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
117 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
118 __inner(__receiver, __mi)
119 }
120 }
121 }
122 #[doc = "`Dispose(bool)` overload"]
123 fn dispose(self, disposing: impl ::core::convert::Into<bool>) -> () {
124 unsafe {
125 let __receiver = <TextWriter as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
126 {
127 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
128 let __vi = *__vt.get(9usize).unwrap_or_else(|| {
129 panic!(
130 "unity: virtual slot {}
131 out of range (vtable len {}
132) on the runtime class behind {}
133 (method `{}
134`)",
135 9usize,
136 __vt.len(),
137 <TextWriter as ::unity::ClassIdentity>::NAME,
138 "Dispose",
139 )
140 });
141 let __inner: extern "C" fn(TextWriter, bool, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
142 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
143 __inner(__receiver, ::core::convert::Into::into(disposing), __mi)
144 }
145 }
146 }
147 #[doc = "`Dispose()` overload"]
148 fn dispose_2(self) -> () {
149 unsafe {
150 let __receiver = <TextWriter as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
151 {
152 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
153 let __vi = *__vt.get(6usize).unwrap_or_else(|| {
154 panic!(
155 "unity: virtual slot {}
156 out of range (vtable len {}
157) on the runtime class behind {}
158 (method `{}
159`)",
160 6usize,
161 __vt.len(),
162 <TextWriter as ::unity::ClassIdentity>::NAME,
163 "Dispose",
164 )
165 });
166 let __inner: extern "C" fn(TextWriter, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
167 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
168 __inner(__receiver, __mi)
169 }
170 }
171 }
172 #[doc = "`Flush()` overload"]
173 fn flush(self) -> () {
174 unsafe {
175 let __receiver = <TextWriter as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
176 {
177 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
178 let __vi = *__vt.get(10usize).unwrap_or_else(|| {
179 panic!(
180 "unity: virtual slot {}
181 out of range (vtable len {}
182) on the runtime class behind {}
183 (method `{}
184`)",
185 10usize,
186 __vt.len(),
187 <TextWriter as ::unity::ClassIdentity>::NAME,
188 "Flush",
189 )
190 });
191 let __inner: extern "C" fn(TextWriter, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
192 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
193 __inner(__receiver, __mi)
194 }
195 }
196 }
197 #[doc = "`Write(u16)` overload"]
198 fn write(self, value: impl ::core::convert::Into<u16>) -> () {
199 unsafe {
200 let __receiver = <TextWriter as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
201 {
202 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
203 let __vi = *__vt.get(12usize).unwrap_or_else(|| {
204 panic!(
205 "unity: virtual slot {}
206 out of range (vtable len {}
207) on the runtime class behind {}
208 (method `{}
209`)",
210 12usize,
211 __vt.len(),
212 <TextWriter as ::unity::ClassIdentity>::NAME,
213 "Write",
214 )
215 });
216 let __inner: extern "C" fn(TextWriter, u16, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
217 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
218 __inner(__receiver, ::core::convert::Into::into(value), __mi)
219 }
220 }
221 }
222 #[doc = "`Write(::unity::Array<u16>)` overload"]
223 fn write_2(self, buffer: impl ::core::convert::Into<::unity::Array<u16>>) -> () {
224 unsafe {
225 let __receiver = <TextWriter as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
226 {
227 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
228 let __vi = *__vt.get(13usize).unwrap_or_else(|| {
229 panic!(
230 "unity: virtual slot {}
231 out of range (vtable len {}
232) on the runtime class behind {}
233 (method `{}
234`)",
235 13usize,
236 __vt.len(),
237 <TextWriter as ::unity::ClassIdentity>::NAME,
238 "Write",
239 )
240 });
241 let __inner: extern "C" fn(TextWriter, ::unity::Array<u16>, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
242 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
243 __inner(__receiver, ::core::convert::Into::into(buffer), __mi)
244 }
245 }
246 }
247 #[doc = "`Write(::unity::Array<u16>, i32, i32)` overload"]
248 fn write_3(
249 self,
250 buffer: impl ::core::convert::Into<::unity::Array<u16>>,
251 index: impl ::core::convert::Into<i32>,
252 count: impl ::core::convert::Into<i32>,
253 ) -> () {
254 unsafe {
255 let __receiver = <TextWriter 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(14usize).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 14usize,
266 __vt.len(),
267 <TextWriter as ::unity::ClassIdentity>::NAME,
268 "Write",
269 )
270 });
271 let __inner: extern "C" fn(TextWriter, ::unity::Array<u16>, i32, i32, ::unity::OptionalMethod) -> () =
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(
275 __receiver,
276 ::core::convert::Into::into(buffer),
277 ::core::convert::Into::into(index),
278 ::core::convert::Into::into(count),
279 __mi,
280 )
281 }
282 }
283 }
284 #[doc = "`Write(::unity::Il2CppString)` overload"]
285 fn write_4(self, value: impl ::core::convert::Into<::unity::Il2CppString>) -> () {
286 unsafe {
287 let __receiver = <TextWriter as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
288 {
289 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
290 let __vi = *__vt.get(15usize).unwrap_or_else(|| {
291 panic!(
292 "unity: virtual slot {}
293 out of range (vtable len {}
294) on the runtime class behind {}
295 (method `{}
296`)",
297 15usize,
298 __vt.len(),
299 <TextWriter as ::unity::ClassIdentity>::NAME,
300 "Write",
301 )
302 });
303 let __inner: extern "C" fn(TextWriter, ::unity::Il2CppString, ::unity::OptionalMethod) -> () =
304 ::core::mem::transmute(__vi.method_ptr);
305 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
306 __inner(__receiver, ::core::convert::Into::into(value), __mi)
307 }
308 }
309 }
310 #[doc = "`WriteLine()` overload"]
311 fn write_line(self) -> () {
312 unsafe {
313 let __receiver = <TextWriter as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
314 {
315 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
316 let __vi = *__vt.get(16usize).unwrap_or_else(|| {
317 panic!(
318 "unity: virtual slot {}
319 out of range (vtable len {}
320) on the runtime class behind {}
321 (method `{}
322`)",
323 16usize,
324 __vt.len(),
325 <TextWriter as ::unity::ClassIdentity>::NAME,
326 "WriteLine",
327 )
328 });
329 let __inner: extern "C" fn(TextWriter, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
330 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
331 __inner(__receiver, __mi)
332 }
333 }
334 }
335 #[doc = "`WriteLine(u16)` overload"]
336 fn write_line_2(self, value: impl ::core::convert::Into<u16>) -> () {
337 unsafe {
338 let __receiver = <TextWriter as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
339 {
340 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
341 let __vi = *__vt.get(17usize).unwrap_or_else(|| {
342 panic!(
343 "unity: virtual slot {}
344 out of range (vtable len {}
345) on the runtime class behind {}
346 (method `{}
347`)",
348 17usize,
349 __vt.len(),
350 <TextWriter as ::unity::ClassIdentity>::NAME,
351 "WriteLine",
352 )
353 });
354 let __inner: extern "C" fn(TextWriter, u16, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
355 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
356 __inner(__receiver, ::core::convert::Into::into(value), __mi)
357 }
358 }
359 }
360 #[doc = "`WriteLine(::unity::Array<u16>, i32, i32)` overload"]
361 fn write_line_3(
362 self,
363 buffer: impl ::core::convert::Into<::unity::Array<u16>>,
364 index: impl ::core::convert::Into<i32>,
365 count: impl ::core::convert::Into<i32>,
366 ) -> () {
367 unsafe {
368 let __receiver = <TextWriter as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
369 {
370 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
371 let __vi = *__vt.get(18usize).unwrap_or_else(|| {
372 panic!(
373 "unity: virtual slot {}
374 out of range (vtable len {}
375) on the runtime class behind {}
376 (method `{}
377`)",
378 18usize,
379 __vt.len(),
380 <TextWriter as ::unity::ClassIdentity>::NAME,
381 "WriteLine",
382 )
383 });
384 let __inner: extern "C" fn(TextWriter, ::unity::Array<u16>, i32, i32, ::unity::OptionalMethod) -> () =
385 ::core::mem::transmute(__vi.method_ptr);
386 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
387 __inner(
388 __receiver,
389 ::core::convert::Into::into(buffer),
390 ::core::convert::Into::into(index),
391 ::core::convert::Into::into(count),
392 __mi,
393 )
394 }
395 }
396 }
397 #[doc = "`WriteLine(::unity::Il2CppString)` overload"]
398 fn write_line_4(self, value: impl ::core::convert::Into<::unity::Il2CppString>) -> () {
399 unsafe {
400 let __receiver = <TextWriter as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
401 {
402 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
403 let __vi = *__vt.get(19usize).unwrap_or_else(|| {
404 panic!(
405 "unity: virtual slot {}
406 out of range (vtable len {}
407) on the runtime class behind {}
408 (method `{}
409`)",
410 19usize,
411 __vt.len(),
412 <TextWriter as ::unity::ClassIdentity>::NAME,
413 "WriteLine",
414 )
415 });
416 let __inner: extern "C" fn(TextWriter, ::unity::Il2CppString, ::unity::OptionalMethod) -> () =
417 ::core::mem::transmute(__vi.method_ptr);
418 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
419 __inner(__receiver, ::core::convert::Into::into(value), __mi)
420 }
421 }
422 }
423 #[doc = "`WriteLine(::unity::Il2CppString, crate::system::object::Object)` overload"]
424 fn write_line_5(
425 self,
426 format: impl ::core::convert::Into<::unity::Il2CppString>,
427 arg0: impl ::core::convert::Into<crate::system::object::Object>,
428 ) -> () {
429 unsafe {
430 let __receiver = <TextWriter as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
431 {
432 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
433 let __vi = *__vt.get(20usize).unwrap_or_else(|| {
434 panic!(
435 "unity: virtual slot {}
436 out of range (vtable len {}
437) on the runtime class behind {}
438 (method `{}
439`)",
440 20usize,
441 __vt.len(),
442 <TextWriter as ::unity::ClassIdentity>::NAME,
443 "WriteLine",
444 )
445 });
446 let __inner: extern "C" fn(TextWriter, ::unity::Il2CppString, crate::system::object::Object, ::unity::OptionalMethod) -> () =
447 ::core::mem::transmute(__vi.method_ptr);
448 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
449 __inner(__receiver, ::core::convert::Into::into(format), ::core::convert::Into::into(arg0), __mi)
450 }
451 }
452 }
453 #[doc = "`WriteLine(::unity::Il2CppString, crate::system::object::Object, crate::system::object::Object)` overload"]
454 fn write_line_6(
455 self,
456 format: impl ::core::convert::Into<::unity::Il2CppString>,
457 arg0: impl ::core::convert::Into<crate::system::object::Object>,
458 arg1: impl ::core::convert::Into<crate::system::object::Object>,
459 ) -> () {
460 unsafe {
461 let __receiver = <TextWriter as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
462 {
463 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
464 let __vi = *__vt.get(21usize).unwrap_or_else(|| {
465 panic!(
466 "unity: virtual slot {}
467 out of range (vtable len {}
468) on the runtime class behind {}
469 (method `{}
470`)",
471 21usize,
472 __vt.len(),
473 <TextWriter as ::unity::ClassIdentity>::NAME,
474 "WriteLine",
475 )
476 });
477 let __inner: extern "C" fn(
478 TextWriter,
479 ::unity::Il2CppString,
480 crate::system::object::Object,
481 crate::system::object::Object,
482 ::unity::OptionalMethod,
483 ) -> () = ::core::mem::transmute(__vi.method_ptr);
484 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
485 __inner(
486 __receiver,
487 ::core::convert::Into::into(format),
488 ::core::convert::Into::into(arg0),
489 ::core::convert::Into::into(arg1),
490 __mi,
491 )
492 }
493 }
494 }
495}
496
497#[cfg(feature = "system-io-textwriter")]
498impl<__T: ITextWriter> ITextWriterMethods for __T {}
499
500#[cfg(feature = "system-io-textwriter")]
501impl TextWriter {
502 pub fn get_initial_new_line_method_info() -> &'static ::unity::il2cpp::MethodInfo {
503 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
504 }
505
506 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
507 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
508 }
509
510 pub fn close_method_info() -> &'static ::unity::il2cpp::MethodInfo {
511 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
512 }
513
514 pub fn dispose_method_info() -> &'static ::unity::il2cpp::MethodInfo {
515 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
516 }
517
518 pub fn dispose_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
519 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
520 }
521
522 pub fn flush_method_info() -> &'static ::unity::il2cpp::MethodInfo {
523 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
524 }
525
526 pub fn synchronized_method_info() -> &'static ::unity::il2cpp::MethodInfo {
527 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[9]
528 }
529
530 pub fn write_method_info() -> &'static ::unity::il2cpp::MethodInfo {
531 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[10]
532 }
533
534 pub fn write_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
535 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[11]
536 }
537
538 pub fn write_3_method_info() -> &'static ::unity::il2cpp::MethodInfo {
539 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[12]
540 }
541
542 pub fn write_4_method_info() -> &'static ::unity::il2cpp::MethodInfo {
543 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[13]
544 }
545
546 pub fn write_line_method_info() -> &'static ::unity::il2cpp::MethodInfo {
547 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[14]
548 }
549
550 pub fn write_line_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
551 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[15]
552 }
553
554 pub fn write_line_3_method_info() -> &'static ::unity::il2cpp::MethodInfo {
555 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[16]
556 }
557
558 pub fn write_line_4_method_info() -> &'static ::unity::il2cpp::MethodInfo {
559 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[17]
560 }
561
562 pub fn write_line_5_method_info() -> &'static ::unity::il2cpp::MethodInfo {
563 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[18]
564 }
565
566 pub fn write_line_6_method_info() -> &'static ::unity::il2cpp::MethodInfo {
567 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[19]
568 }
569
570 pub fn cctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
571 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[20]
572 }
573}
574
575#[cfg(feature = "system-io-textwriter")]
576impl TextWriter {
577 #[doc = "Direct (non-virtual) call to `TextWriter`'s own `Close`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
578 pub unsafe fn close(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
579 let __mi = Self::close_method_info();
580 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
581 __inner(this.into(), ::core::option::Option::None)
582 }
583
584 #[doc = "Direct (non-virtual) call to `TextWriter`'s own `Dispose`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
585 pub unsafe fn dispose(this: impl ::core::convert::Into<::unity::IlInstance>, disposing: bool) -> () {
586 let __mi = Self::dispose_method_info();
587 let __inner: extern "C" fn(::unity::IlInstance, bool, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
588 __inner(this.into(), disposing, ::core::option::Option::None)
589 }
590
591 #[doc = "Direct (non-virtual) call to `TextWriter`'s own `Dispose`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
592 pub unsafe fn dispose_2(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
593 let __mi = Self::dispose_2_method_info();
594 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
595 __inner(this.into(), ::core::option::Option::None)
596 }
597
598 #[doc = "Direct (non-virtual) call to `TextWriter`'s own `Flush`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
599 pub unsafe fn flush(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
600 let __mi = Self::flush_method_info();
601 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
602 __inner(this.into(), ::core::option::Option::None)
603 }
604
605 #[doc = "Direct (non-virtual) call to `TextWriter`'s own `Write`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
606 pub unsafe fn write(this: impl ::core::convert::Into<::unity::IlInstance>, value: u16) -> () {
607 let __mi = Self::write_method_info();
608 let __inner: extern "C" fn(::unity::IlInstance, u16, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
609 __inner(this.into(), value, ::core::option::Option::None)
610 }
611
612 #[doc = "Direct (non-virtual) call to `TextWriter`'s own `Write`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
613 pub unsafe fn write_2(this: impl ::core::convert::Into<::unity::IlInstance>, buffer: ::unity::Array<u16>) -> () {
614 let __mi = Self::write_2_method_info();
615 let __inner: extern "C" fn(::unity::IlInstance, ::unity::Array<u16>, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
616 __inner(this.into(), buffer, ::core::option::Option::None)
617 }
618
619 #[doc = "Direct (non-virtual) call to `TextWriter`'s own `Write`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
620 pub unsafe fn write_3(this: impl ::core::convert::Into<::unity::IlInstance>, buffer: ::unity::Array<u16>, index: i32, count: i32) -> () {
621 let __mi = Self::write_3_method_info();
622 let __inner: extern "C" fn(::unity::IlInstance, ::unity::Array<u16>, i32, i32, ::unity::OptionalMethod) -> () =
623 ::core::mem::transmute(__mi.method_ptr);
624 __inner(this.into(), buffer, index, count, ::core::option::Option::None)
625 }
626
627 #[doc = "Direct (non-virtual) call to `TextWriter`'s own `Write`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
628 pub unsafe fn write_4(this: impl ::core::convert::Into<::unity::IlInstance>, value: ::unity::Il2CppString) -> () {
629 let __mi = Self::write_4_method_info();
630 let __inner: extern "C" fn(::unity::IlInstance, ::unity::Il2CppString, ::unity::OptionalMethod) -> () =
631 ::core::mem::transmute(__mi.method_ptr);
632 __inner(this.into(), value, ::core::option::Option::None)
633 }
634
635 #[doc = "Direct (non-virtual) call to `TextWriter`'s own `WriteLine`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
636 pub unsafe fn write_line(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
637 let __mi = Self::write_line_method_info();
638 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
639 __inner(this.into(), ::core::option::Option::None)
640 }
641
642 #[doc = "Direct (non-virtual) call to `TextWriter`'s own `WriteLine`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
643 pub unsafe fn write_line_2(this: impl ::core::convert::Into<::unity::IlInstance>, value: u16) -> () {
644 let __mi = Self::write_line_2_method_info();
645 let __inner: extern "C" fn(::unity::IlInstance, u16, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
646 __inner(this.into(), value, ::core::option::Option::None)
647 }
648
649 #[doc = "Direct (non-virtual) call to `TextWriter`'s own `WriteLine`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
650 pub unsafe fn write_line_3(this: impl ::core::convert::Into<::unity::IlInstance>, buffer: ::unity::Array<u16>, index: i32, count: i32) -> () {
651 let __mi = Self::write_line_3_method_info();
652 let __inner: extern "C" fn(::unity::IlInstance, ::unity::Array<u16>, i32, i32, ::unity::OptionalMethod) -> () =
653 ::core::mem::transmute(__mi.method_ptr);
654 __inner(this.into(), buffer, index, count, ::core::option::Option::None)
655 }
656
657 #[doc = "Direct (non-virtual) call to `TextWriter`'s own `WriteLine`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
658 pub unsafe fn write_line_4(this: impl ::core::convert::Into<::unity::IlInstance>, value: ::unity::Il2CppString) -> () {
659 let __mi = Self::write_line_4_method_info();
660 let __inner: extern "C" fn(::unity::IlInstance, ::unity::Il2CppString, ::unity::OptionalMethod) -> () =
661 ::core::mem::transmute(__mi.method_ptr);
662 __inner(this.into(), value, ::core::option::Option::None)
663 }
664
665 #[doc = "Direct (non-virtual) call to `TextWriter`'s own `WriteLine`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
666 pub unsafe fn write_line_5(
667 this: impl ::core::convert::Into<::unity::IlInstance>,
668 format: ::unity::Il2CppString,
669 arg0: crate::system::object::Object,
670 ) -> () {
671 let __mi = Self::write_line_5_method_info();
672 let __inner: extern "C" fn(::unity::IlInstance, ::unity::Il2CppString, crate::system::object::Object, ::unity::OptionalMethod) -> () =
673 ::core::mem::transmute(__mi.method_ptr);
674 __inner(this.into(), format, arg0, ::core::option::Option::None)
675 }
676
677 #[doc = "Direct (non-virtual) call to `TextWriter`'s own `WriteLine`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
678 pub unsafe fn write_line_6(
679 this: impl ::core::convert::Into<::unity::IlInstance>,
680 format: ::unity::Il2CppString,
681 arg0: crate::system::object::Object,
682 arg1: crate::system::object::Object,
683 ) -> () {
684 let __mi = Self::write_line_6_method_info();
685 let __inner: extern "C" fn(
686 ::unity::IlInstance,
687 ::unity::Il2CppString,
688 crate::system::object::Object,
689 crate::system::object::Object,
690 ::unity::OptionalMethod,
691 ) -> () = ::core::mem::transmute(__mi.method_ptr);
692 __inner(this.into(), format, arg0, arg1, ::core::option::Option::None)
693 }
694}
695
696#[cfg(feature = "system-io-textwriter")]
697impl TextWriter {
698 #[doc = "`.ctor()` — no args"]
699 pub fn new() -> Self {
700 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
701 panic!(
702 "{}
703::{}
704 failed to instantiate",
705 ::core::stringify!(TextWriter),
706 ::core::stringify!(new),
707 )
708 });
709 <Self as ITextWriterMethods>::ctor(this);
710 this
711 }
712}
713
714#[cfg(feature = "system-io-textwriter")]
715pub trait ITextWriter_SyncTextWriterMethods: ITextWriter_SyncTextWriter {
716 #[doc = "`.ctor(crate::system::io::textwriter::TextWriter)` overload"]
717 fn ctor(self, t: impl ::core::convert::Into<crate::system::io::textwriter::TextWriter>) -> () {
718 unsafe {
719 let __receiver =
720 <TextWriter_SyncTextWriter as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
721 ::unity::il2cpp_call!((::unity::module_base()+0x3c5af90usize)as*mut u8,();
722(TextWriter_SyncTextWriter)__receiver,(crate::system::io::textwriter::TextWriter)::core::convert::Into::into(t))
723 }
724 }
725 #[doc = "`Close()` overload"]
726 fn close(self) -> () {
727 unsafe {
728 let __receiver =
729 <TextWriter_SyncTextWriter as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
730 {
731 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
732 let __vi = *__vt.get(8usize).unwrap_or_else(|| {
733 panic!(
734 "unity: virtual slot {}
735 out of range (vtable len {}
736) on the runtime class behind {}
737 (method `{}
738`)",
739 8usize,
740 __vt.len(),
741 <TextWriter_SyncTextWriter as ::unity::ClassIdentity>::NAME,
742 "Close",
743 )
744 });
745 let __inner: extern "C" fn(TextWriter_SyncTextWriter, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
746 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
747 __inner(__receiver, __mi)
748 }
749 }
750 }
751 #[doc = "`Dispose(bool)` overload"]
752 fn dispose(self, disposing: impl ::core::convert::Into<bool>) -> () {
753 unsafe {
754 let __receiver =
755 <TextWriter_SyncTextWriter as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
756 {
757 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
758 let __vi = *__vt.get(9usize).unwrap_or_else(|| {
759 panic!(
760 "unity: virtual slot {}
761 out of range (vtable len {}
762) on the runtime class behind {}
763 (method `{}
764`)",
765 9usize,
766 __vt.len(),
767 <TextWriter_SyncTextWriter as ::unity::ClassIdentity>::NAME,
768 "Dispose",
769 )
770 });
771 let __inner: extern "C" fn(TextWriter_SyncTextWriter, bool, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
772 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
773 __inner(__receiver, ::core::convert::Into::into(disposing), __mi)
774 }
775 }
776 }
777 #[doc = "`Flush()` overload"]
778 fn flush(self) -> () {
779 unsafe {
780 let __receiver =
781 <TextWriter_SyncTextWriter as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
782 {
783 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
784 let __vi = *__vt.get(10usize).unwrap_or_else(|| {
785 panic!(
786 "unity: virtual slot {}
787 out of range (vtable len {}
788) on the runtime class behind {}
789 (method `{}
790`)",
791 10usize,
792 __vt.len(),
793 <TextWriter_SyncTextWriter as ::unity::ClassIdentity>::NAME,
794 "Flush",
795 )
796 });
797 let __inner: extern "C" fn(TextWriter_SyncTextWriter, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
798 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
799 __inner(__receiver, __mi)
800 }
801 }
802 }
803 #[doc = "`Write(u16)` overload"]
804 fn write(self, value: impl ::core::convert::Into<u16>) -> () {
805 unsafe {
806 let __receiver =
807 <TextWriter_SyncTextWriter as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
808 {
809 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
810 let __vi = *__vt.get(12usize).unwrap_or_else(|| {
811 panic!(
812 "unity: virtual slot {}
813 out of range (vtable len {}
814) on the runtime class behind {}
815 (method `{}
816`)",
817 12usize,
818 __vt.len(),
819 <TextWriter_SyncTextWriter as ::unity::ClassIdentity>::NAME,
820 "Write",
821 )
822 });
823 let __inner: extern "C" fn(TextWriter_SyncTextWriter, u16, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
824 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
825 __inner(__receiver, ::core::convert::Into::into(value), __mi)
826 }
827 }
828 }
829 #[doc = "`Write(::unity::Array<u16>)` overload"]
830 fn write_2(self, buffer: impl ::core::convert::Into<::unity::Array<u16>>) -> () {
831 unsafe {
832 let __receiver =
833 <TextWriter_SyncTextWriter as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
834 {
835 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
836 let __vi = *__vt.get(13usize).unwrap_or_else(|| {
837 panic!(
838 "unity: virtual slot {}
839 out of range (vtable len {}
840) on the runtime class behind {}
841 (method `{}
842`)",
843 13usize,
844 __vt.len(),
845 <TextWriter_SyncTextWriter as ::unity::ClassIdentity>::NAME,
846 "Write",
847 )
848 });
849 let __inner: extern "C" fn(TextWriter_SyncTextWriter, ::unity::Array<u16>, ::unity::OptionalMethod) -> () =
850 ::core::mem::transmute(__vi.method_ptr);
851 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
852 __inner(__receiver, ::core::convert::Into::into(buffer), __mi)
853 }
854 }
855 }
856 #[doc = "`Write(::unity::Array<u16>, i32, i32)` overload"]
857 fn write_3(
858 self,
859 buffer: impl ::core::convert::Into<::unity::Array<u16>>,
860 index: impl ::core::convert::Into<i32>,
861 count: impl ::core::convert::Into<i32>,
862 ) -> () {
863 unsafe {
864 let __receiver =
865 <TextWriter_SyncTextWriter as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
866 {
867 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
868 let __vi = *__vt.get(14usize).unwrap_or_else(|| {
869 panic!(
870 "unity: virtual slot {}
871 out of range (vtable len {}
872) on the runtime class behind {}
873 (method `{}
874`)",
875 14usize,
876 __vt.len(),
877 <TextWriter_SyncTextWriter as ::unity::ClassIdentity>::NAME,
878 "Write",
879 )
880 });
881 let __inner: extern "C" fn(TextWriter_SyncTextWriter, ::unity::Array<u16>, i32, i32, ::unity::OptionalMethod) -> () =
882 ::core::mem::transmute(__vi.method_ptr);
883 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
884 __inner(
885 __receiver,
886 ::core::convert::Into::into(buffer),
887 ::core::convert::Into::into(index),
888 ::core::convert::Into::into(count),
889 __mi,
890 )
891 }
892 }
893 }
894 #[doc = "`Write(::unity::Il2CppString)` overload"]
895 fn write_4(self, value: impl ::core::convert::Into<::unity::Il2CppString>) -> () {
896 unsafe {
897 let __receiver =
898 <TextWriter_SyncTextWriter as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
899 {
900 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
901 let __vi = *__vt.get(15usize).unwrap_or_else(|| {
902 panic!(
903 "unity: virtual slot {}
904 out of range (vtable len {}
905) on the runtime class behind {}
906 (method `{}
907`)",
908 15usize,
909 __vt.len(),
910 <TextWriter_SyncTextWriter as ::unity::ClassIdentity>::NAME,
911 "Write",
912 )
913 });
914 let __inner: extern "C" fn(TextWriter_SyncTextWriter, ::unity::Il2CppString, ::unity::OptionalMethod) -> () =
915 ::core::mem::transmute(__vi.method_ptr);
916 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
917 __inner(__receiver, ::core::convert::Into::into(value), __mi)
918 }
919 }
920 }
921 #[doc = "`WriteLine()` overload"]
922 fn write_line(self) -> () {
923 unsafe {
924 let __receiver =
925 <TextWriter_SyncTextWriter as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
926 {
927 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
928 let __vi = *__vt.get(16usize).unwrap_or_else(|| {
929 panic!(
930 "unity: virtual slot {}
931 out of range (vtable len {}
932) on the runtime class behind {}
933 (method `{}
934`)",
935 16usize,
936 __vt.len(),
937 <TextWriter_SyncTextWriter as ::unity::ClassIdentity>::NAME,
938 "WriteLine",
939 )
940 });
941 let __inner: extern "C" fn(TextWriter_SyncTextWriter, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
942 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
943 __inner(__receiver, __mi)
944 }
945 }
946 }
947 #[doc = "`WriteLine(u16)` overload"]
948 fn write_line_2(self, value: impl ::core::convert::Into<u16>) -> () {
949 unsafe {
950 let __receiver =
951 <TextWriter_SyncTextWriter as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
952 {
953 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
954 let __vi = *__vt.get(17usize).unwrap_or_else(|| {
955 panic!(
956 "unity: virtual slot {}
957 out of range (vtable len {}
958) on the runtime class behind {}
959 (method `{}
960`)",
961 17usize,
962 __vt.len(),
963 <TextWriter_SyncTextWriter as ::unity::ClassIdentity>::NAME,
964 "WriteLine",
965 )
966 });
967 let __inner: extern "C" fn(TextWriter_SyncTextWriter, u16, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
968 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
969 __inner(__receiver, ::core::convert::Into::into(value), __mi)
970 }
971 }
972 }
973 #[doc = "`WriteLine(::unity::Array<u16>, i32, i32)` overload"]
974 fn write_line_3(
975 self,
976 buffer: impl ::core::convert::Into<::unity::Array<u16>>,
977 index: impl ::core::convert::Into<i32>,
978 count: impl ::core::convert::Into<i32>,
979 ) -> () {
980 unsafe {
981 let __receiver =
982 <TextWriter_SyncTextWriter as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
983 {
984 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
985 let __vi = *__vt.get(18usize).unwrap_or_else(|| {
986 panic!(
987 "unity: virtual slot {}
988 out of range (vtable len {}
989) on the runtime class behind {}
990 (method `{}
991`)",
992 18usize,
993 __vt.len(),
994 <TextWriter_SyncTextWriter as ::unity::ClassIdentity>::NAME,
995 "WriteLine",
996 )
997 });
998 let __inner: extern "C" fn(TextWriter_SyncTextWriter, ::unity::Array<u16>, i32, i32, ::unity::OptionalMethod) -> () =
999 ::core::mem::transmute(__vi.method_ptr);
1000 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1001 __inner(
1002 __receiver,
1003 ::core::convert::Into::into(buffer),
1004 ::core::convert::Into::into(index),
1005 ::core::convert::Into::into(count),
1006 __mi,
1007 )
1008 }
1009 }
1010 }
1011 #[doc = "`WriteLine(::unity::Il2CppString)` overload"]
1012 fn write_line_4(self, value: impl ::core::convert::Into<::unity::Il2CppString>) -> () {
1013 unsafe {
1014 let __receiver =
1015 <TextWriter_SyncTextWriter as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1016 {
1017 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1018 let __vi = *__vt.get(19usize).unwrap_or_else(|| {
1019 panic!(
1020 "unity: virtual slot {}
1021 out of range (vtable len {}
1022) on the runtime class behind {}
1023 (method `{}
1024`)",
1025 19usize,
1026 __vt.len(),
1027 <TextWriter_SyncTextWriter as ::unity::ClassIdentity>::NAME,
1028 "WriteLine",
1029 )
1030 });
1031 let __inner: extern "C" fn(TextWriter_SyncTextWriter, ::unity::Il2CppString, ::unity::OptionalMethod) -> () =
1032 ::core::mem::transmute(__vi.method_ptr);
1033 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1034 __inner(__receiver, ::core::convert::Into::into(value), __mi)
1035 }
1036 }
1037 }
1038 #[doc = "`WriteLine(::unity::Il2CppString, crate::system::object::Object)` overload"]
1039 fn write_line_5(
1040 self,
1041 format: impl ::core::convert::Into<::unity::Il2CppString>,
1042 arg0: impl ::core::convert::Into<crate::system::object::Object>,
1043 ) -> () {
1044 unsafe {
1045 let __receiver =
1046 <TextWriter_SyncTextWriter as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1047 {
1048 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1049 let __vi = *__vt.get(20usize).unwrap_or_else(|| {
1050 panic!(
1051 "unity: virtual slot {}
1052 out of range (vtable len {}
1053) on the runtime class behind {}
1054 (method `{}
1055`)",
1056 20usize,
1057 __vt.len(),
1058 <TextWriter_SyncTextWriter as ::unity::ClassIdentity>::NAME,
1059 "WriteLine",
1060 )
1061 });
1062 let __inner: extern "C" fn(
1063 TextWriter_SyncTextWriter,
1064 ::unity::Il2CppString,
1065 crate::system::object::Object,
1066 ::unity::OptionalMethod,
1067 ) -> () = ::core::mem::transmute(__vi.method_ptr);
1068 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1069 __inner(__receiver, ::core::convert::Into::into(format), ::core::convert::Into::into(arg0), __mi)
1070 }
1071 }
1072 }
1073 #[doc = "`WriteLine(::unity::Il2CppString, crate::system::object::Object, crate::system::object::Object)` overload"]
1074 fn write_line_6(
1075 self,
1076 format: impl ::core::convert::Into<::unity::Il2CppString>,
1077 arg0: impl ::core::convert::Into<crate::system::object::Object>,
1078 arg1: impl ::core::convert::Into<crate::system::object::Object>,
1079 ) -> () {
1080 unsafe {
1081 let __receiver =
1082 <TextWriter_SyncTextWriter as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1083 {
1084 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1085 let __vi = *__vt.get(21usize).unwrap_or_else(|| {
1086 panic!(
1087 "unity: virtual slot {}
1088 out of range (vtable len {}
1089) on the runtime class behind {}
1090 (method `{}
1091`)",
1092 21usize,
1093 __vt.len(),
1094 <TextWriter_SyncTextWriter as ::unity::ClassIdentity>::NAME,
1095 "WriteLine",
1096 )
1097 });
1098 let __inner: extern "C" fn(
1099 TextWriter_SyncTextWriter,
1100 ::unity::Il2CppString,
1101 crate::system::object::Object,
1102 crate::system::object::Object,
1103 ::unity::OptionalMethod,
1104 ) -> () = ::core::mem::transmute(__vi.method_ptr);
1105 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1106 __inner(
1107 __receiver,
1108 ::core::convert::Into::into(format),
1109 ::core::convert::Into::into(arg0),
1110 ::core::convert::Into::into(arg1),
1111 __mi,
1112 )
1113 }
1114 }
1115 }
1116}
1117
1118#[cfg(feature = "system-io-textwriter")]
1119impl<__T: ITextWriter_SyncTextWriter> ITextWriter_SyncTextWriterMethods for __T {}
1120
1121#[cfg(feature = "system-io-textwriter")]
1122impl TextWriter_SyncTextWriter {
1123 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1124 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
1125 }
1126
1127 pub fn close_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1128 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
1129 }
1130
1131 pub fn dispose_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1132 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
1133 }
1134
1135 pub fn flush_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1136 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
1137 }
1138
1139 pub fn write_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1140 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
1141 }
1142
1143 pub fn write_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1144 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
1145 }
1146
1147 pub fn write_3_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1148 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[8]
1149 }
1150
1151 pub fn write_4_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1152 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[9]
1153 }
1154
1155 pub fn write_line_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1156 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[10]
1157 }
1158
1159 pub fn write_line_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1160 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[11]
1161 }
1162
1163 pub fn write_line_3_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1164 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[12]
1165 }
1166
1167 pub fn write_line_4_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1168 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[13]
1169 }
1170
1171 pub fn write_line_5_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1172 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[14]
1173 }
1174
1175 pub fn write_line_6_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1176 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[15]
1177 }
1178}
1179
1180#[cfg(feature = "system-io-textwriter")]
1181impl TextWriter_SyncTextWriter {
1182 #[doc = "Direct (non-virtual) call to `TextWriter_SyncTextWriter`'s own `Close`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1183 pub unsafe fn close(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
1184 let __mi = Self::close_method_info();
1185 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
1186 __inner(this.into(), ::core::option::Option::None)
1187 }
1188
1189 #[doc = "Direct (non-virtual) call to `TextWriter_SyncTextWriter`'s own `Dispose`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1190 pub unsafe fn dispose(this: impl ::core::convert::Into<::unity::IlInstance>, disposing: bool) -> () {
1191 let __mi = Self::dispose_method_info();
1192 let __inner: extern "C" fn(::unity::IlInstance, bool, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
1193 __inner(this.into(), disposing, ::core::option::Option::None)
1194 }
1195
1196 #[doc = "Direct (non-virtual) call to `TextWriter_SyncTextWriter`'s own `Flush`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1197 pub unsafe fn flush(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
1198 let __mi = Self::flush_method_info();
1199 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
1200 __inner(this.into(), ::core::option::Option::None)
1201 }
1202
1203 #[doc = "Direct (non-virtual) call to `TextWriter_SyncTextWriter`'s own `Write`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1204 pub unsafe fn write(this: impl ::core::convert::Into<::unity::IlInstance>, value: u16) -> () {
1205 let __mi = Self::write_method_info();
1206 let __inner: extern "C" fn(::unity::IlInstance, u16, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
1207 __inner(this.into(), value, ::core::option::Option::None)
1208 }
1209
1210 #[doc = "Direct (non-virtual) call to `TextWriter_SyncTextWriter`'s own `Write`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1211 pub unsafe fn write_2(this: impl ::core::convert::Into<::unity::IlInstance>, buffer: ::unity::Array<u16>) -> () {
1212 let __mi = Self::write_2_method_info();
1213 let __inner: extern "C" fn(::unity::IlInstance, ::unity::Array<u16>, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
1214 __inner(this.into(), buffer, ::core::option::Option::None)
1215 }
1216
1217 #[doc = "Direct (non-virtual) call to `TextWriter_SyncTextWriter`'s own `Write`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1218 pub unsafe fn write_3(this: impl ::core::convert::Into<::unity::IlInstance>, buffer: ::unity::Array<u16>, index: i32, count: i32) -> () {
1219 let __mi = Self::write_3_method_info();
1220 let __inner: extern "C" fn(::unity::IlInstance, ::unity::Array<u16>, i32, i32, ::unity::OptionalMethod) -> () =
1221 ::core::mem::transmute(__mi.method_ptr);
1222 __inner(this.into(), buffer, index, count, ::core::option::Option::None)
1223 }
1224
1225 #[doc = "Direct (non-virtual) call to `TextWriter_SyncTextWriter`'s own `Write`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1226 pub unsafe fn write_4(this: impl ::core::convert::Into<::unity::IlInstance>, value: ::unity::Il2CppString) -> () {
1227 let __mi = Self::write_4_method_info();
1228 let __inner: extern "C" fn(::unity::IlInstance, ::unity::Il2CppString, ::unity::OptionalMethod) -> () =
1229 ::core::mem::transmute(__mi.method_ptr);
1230 __inner(this.into(), value, ::core::option::Option::None)
1231 }
1232
1233 #[doc = "Direct (non-virtual) call to `TextWriter_SyncTextWriter`'s own `WriteLine`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1234 pub unsafe fn write_line(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
1235 let __mi = Self::write_line_method_info();
1236 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
1237 __inner(this.into(), ::core::option::Option::None)
1238 }
1239
1240 #[doc = "Direct (non-virtual) call to `TextWriter_SyncTextWriter`'s own `WriteLine`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1241 pub unsafe fn write_line_2(this: impl ::core::convert::Into<::unity::IlInstance>, value: u16) -> () {
1242 let __mi = Self::write_line_2_method_info();
1243 let __inner: extern "C" fn(::unity::IlInstance, u16, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
1244 __inner(this.into(), value, ::core::option::Option::None)
1245 }
1246
1247 #[doc = "Direct (non-virtual) call to `TextWriter_SyncTextWriter`'s own `WriteLine`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1248 pub unsafe fn write_line_3(this: impl ::core::convert::Into<::unity::IlInstance>, buffer: ::unity::Array<u16>, index: i32, count: i32) -> () {
1249 let __mi = Self::write_line_3_method_info();
1250 let __inner: extern "C" fn(::unity::IlInstance, ::unity::Array<u16>, i32, i32, ::unity::OptionalMethod) -> () =
1251 ::core::mem::transmute(__mi.method_ptr);
1252 __inner(this.into(), buffer, index, count, ::core::option::Option::None)
1253 }
1254
1255 #[doc = "Direct (non-virtual) call to `TextWriter_SyncTextWriter`'s own `WriteLine`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1256 pub unsafe fn write_line_4(this: impl ::core::convert::Into<::unity::IlInstance>, value: ::unity::Il2CppString) -> () {
1257 let __mi = Self::write_line_4_method_info();
1258 let __inner: extern "C" fn(::unity::IlInstance, ::unity::Il2CppString, ::unity::OptionalMethod) -> () =
1259 ::core::mem::transmute(__mi.method_ptr);
1260 __inner(this.into(), value, ::core::option::Option::None)
1261 }
1262
1263 #[doc = "Direct (non-virtual) call to `TextWriter_SyncTextWriter`'s own `WriteLine`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1264 pub unsafe fn write_line_5(
1265 this: impl ::core::convert::Into<::unity::IlInstance>,
1266 format: ::unity::Il2CppString,
1267 arg0: crate::system::object::Object,
1268 ) -> () {
1269 let __mi = Self::write_line_5_method_info();
1270 let __inner: extern "C" fn(::unity::IlInstance, ::unity::Il2CppString, crate::system::object::Object, ::unity::OptionalMethod) -> () =
1271 ::core::mem::transmute(__mi.method_ptr);
1272 __inner(this.into(), format, arg0, ::core::option::Option::None)
1273 }
1274
1275 #[doc = "Direct (non-virtual) call to `TextWriter_SyncTextWriter`'s own `WriteLine`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1276 pub unsafe fn write_line_6(
1277 this: impl ::core::convert::Into<::unity::IlInstance>,
1278 format: ::unity::Il2CppString,
1279 arg0: crate::system::object::Object,
1280 arg1: crate::system::object::Object,
1281 ) -> () {
1282 let __mi = Self::write_line_6_method_info();
1283 let __inner: extern "C" fn(
1284 ::unity::IlInstance,
1285 ::unity::Il2CppString,
1286 crate::system::object::Object,
1287 crate::system::object::Object,
1288 ::unity::OptionalMethod,
1289 ) -> () = ::core::mem::transmute(__mi.method_ptr);
1290 __inner(this.into(), format, arg0, arg1, ::core::option::Option::None)
1291 }
1292}
1293
1294#[cfg(feature = "system-io-textwriter")]
1295impl TextWriter_SyncTextWriter {
1296 #[doc = "`.ctor(crate::system::io::textwriter::TextWriter)` — overload selector"]
1297 pub fn new(t: crate::system::io::textwriter::TextWriter) -> Self {
1298 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1299 panic!(
1300 "{}
1301::{}
1302 failed to instantiate",
1303 ::core::stringify!(TextWriter_SyncTextWriter),
1304 ::core::stringify!(new),
1305 )
1306 });
1307 <Self as ITextWriter_SyncTextWriterMethods>::ctor(this, t);
1308 this
1309 }
1310}
1311
1312#[cfg(feature = "system-io-textwriter")]
1313pub trait ITextWriter_NullTextWriterMethods: ITextWriter_NullTextWriter {
1314 #[doc = "`.ctor()` overload"]
1315 fn ctor(self) -> () {
1316 unsafe {
1317 let __receiver =
1318 <TextWriter_NullTextWriter as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1319 ::unity::il2cpp_call!((::unity::module_base()+0x3c5ae90usize)as*mut u8,();
1320(TextWriter_NullTextWriter)__receiver)
1321 }
1322 }
1323 #[doc = "`Write(::unity::Array<u16>, i32, i32)` overload"]
1324 fn write(
1325 self,
1326 buffer: impl ::core::convert::Into<::unity::Array<u16>>,
1327 index: impl ::core::convert::Into<i32>,
1328 count: impl ::core::convert::Into<i32>,
1329 ) -> () {
1330 unsafe {
1331 let __receiver =
1332 <TextWriter_NullTextWriter as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1333 {
1334 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1335 let __vi = *__vt.get(14usize).unwrap_or_else(|| {
1336 panic!(
1337 "unity: virtual slot {}
1338 out of range (vtable len {}
1339) on the runtime class behind {}
1340 (method `{}
1341`)",
1342 14usize,
1343 __vt.len(),
1344 <TextWriter_NullTextWriter as ::unity::ClassIdentity>::NAME,
1345 "Write",
1346 )
1347 });
1348 let __inner: extern "C" fn(TextWriter_NullTextWriter, ::unity::Array<u16>, i32, i32, ::unity::OptionalMethod) -> () =
1349 ::core::mem::transmute(__vi.method_ptr);
1350 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1351 __inner(
1352 __receiver,
1353 ::core::convert::Into::into(buffer),
1354 ::core::convert::Into::into(index),
1355 ::core::convert::Into::into(count),
1356 __mi,
1357 )
1358 }
1359 }
1360 }
1361 #[doc = "`Write(::unity::Il2CppString)` overload"]
1362 fn write_2(self, value: impl ::core::convert::Into<::unity::Il2CppString>) -> () {
1363 unsafe {
1364 let __receiver =
1365 <TextWriter_NullTextWriter as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1366 {
1367 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1368 let __vi = *__vt.get(15usize).unwrap_or_else(|| {
1369 panic!(
1370 "unity: virtual slot {}
1371 out of range (vtable len {}
1372) on the runtime class behind {}
1373 (method `{}
1374`)",
1375 15usize,
1376 __vt.len(),
1377 <TextWriter_NullTextWriter as ::unity::ClassIdentity>::NAME,
1378 "Write",
1379 )
1380 });
1381 let __inner: extern "C" fn(TextWriter_NullTextWriter, ::unity::Il2CppString, ::unity::OptionalMethod) -> () =
1382 ::core::mem::transmute(__vi.method_ptr);
1383 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1384 __inner(__receiver, ::core::convert::Into::into(value), __mi)
1385 }
1386 }
1387 }
1388 #[doc = "`WriteLine()` overload"]
1389 fn write_line(self) -> () {
1390 unsafe {
1391 let __receiver =
1392 <TextWriter_NullTextWriter as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1393 {
1394 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1395 let __vi = *__vt.get(16usize).unwrap_or_else(|| {
1396 panic!(
1397 "unity: virtual slot {}
1398 out of range (vtable len {}
1399) on the runtime class behind {}
1400 (method `{}
1401`)",
1402 16usize,
1403 __vt.len(),
1404 <TextWriter_NullTextWriter as ::unity::ClassIdentity>::NAME,
1405 "WriteLine",
1406 )
1407 });
1408 let __inner: extern "C" fn(TextWriter_NullTextWriter, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
1409 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1410 __inner(__receiver, __mi)
1411 }
1412 }
1413 }
1414 #[doc = "`WriteLine(::unity::Il2CppString)` overload"]
1415 fn write_line_2(self, value: impl ::core::convert::Into<::unity::Il2CppString>) -> () {
1416 unsafe {
1417 let __receiver =
1418 <TextWriter_NullTextWriter as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1419 {
1420 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1421 let __vi = *__vt.get(19usize).unwrap_or_else(|| {
1422 panic!(
1423 "unity: virtual slot {}
1424 out of range (vtable len {}
1425) on the runtime class behind {}
1426 (method `{}
1427`)",
1428 19usize,
1429 __vt.len(),
1430 <TextWriter_NullTextWriter as ::unity::ClassIdentity>::NAME,
1431 "WriteLine",
1432 )
1433 });
1434 let __inner: extern "C" fn(TextWriter_NullTextWriter, ::unity::Il2CppString, ::unity::OptionalMethod) -> () =
1435 ::core::mem::transmute(__vi.method_ptr);
1436 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1437 __inner(__receiver, ::core::convert::Into::into(value), __mi)
1438 }
1439 }
1440 }
1441}
1442
1443#[cfg(feature = "system-io-textwriter")]
1444impl<__T: ITextWriter_NullTextWriter> ITextWriter_NullTextWriterMethods for __T {}
1445
1446#[cfg(feature = "system-io-textwriter")]
1447impl TextWriter_NullTextWriter {
1448 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1449 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
1450 }
1451
1452 pub fn write_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1453 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
1454 }
1455
1456 pub fn write_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1457 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
1458 }
1459
1460 pub fn write_line_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1461 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
1462 }
1463
1464 pub fn write_line_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1465 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
1466 }
1467}
1468
1469#[cfg(feature = "system-io-textwriter")]
1470impl TextWriter_NullTextWriter {
1471 #[doc = "Direct (non-virtual) call to `TextWriter_NullTextWriter`'s own `Write`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1472 pub unsafe fn write(this: impl ::core::convert::Into<::unity::IlInstance>, buffer: ::unity::Array<u16>, index: i32, count: i32) -> () {
1473 let __mi = Self::write_method_info();
1474 let __inner: extern "C" fn(::unity::IlInstance, ::unity::Array<u16>, i32, i32, ::unity::OptionalMethod) -> () =
1475 ::core::mem::transmute(__mi.method_ptr);
1476 __inner(this.into(), buffer, index, count, ::core::option::Option::None)
1477 }
1478
1479 #[doc = "Direct (non-virtual) call to `TextWriter_NullTextWriter`'s own `Write`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1480 pub unsafe fn write_2(this: impl ::core::convert::Into<::unity::IlInstance>, value: ::unity::Il2CppString) -> () {
1481 let __mi = Self::write_2_method_info();
1482 let __inner: extern "C" fn(::unity::IlInstance, ::unity::Il2CppString, ::unity::OptionalMethod) -> () =
1483 ::core::mem::transmute(__mi.method_ptr);
1484 __inner(this.into(), value, ::core::option::Option::None)
1485 }
1486
1487 #[doc = "Direct (non-virtual) call to `TextWriter_NullTextWriter`'s own `WriteLine`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1488 pub unsafe fn write_line(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
1489 let __mi = Self::write_line_method_info();
1490 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
1491 __inner(this.into(), ::core::option::Option::None)
1492 }
1493
1494 #[doc = "Direct (non-virtual) call to `TextWriter_NullTextWriter`'s own `WriteLine`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1495 pub unsafe fn write_line_2(this: impl ::core::convert::Into<::unity::IlInstance>, value: ::unity::Il2CppString) -> () {
1496 let __mi = Self::write_line_2_method_info();
1497 let __inner: extern "C" fn(::unity::IlInstance, ::unity::Il2CppString, ::unity::OptionalMethod) -> () =
1498 ::core::mem::transmute(__mi.method_ptr);
1499 __inner(this.into(), value, ::core::option::Option::None)
1500 }
1501}
1502
1503#[cfg(feature = "system-io-textwriter")]
1504impl TextWriter_NullTextWriter {
1505 #[doc = "`.ctor()` — no args"]
1506 pub fn new() -> Self {
1507 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1508 panic!(
1509 "{}
1510::{}
1511 failed to instantiate",
1512 ::core::stringify!(TextWriter_NullTextWriter),
1513 ::core::stringify!(new),
1514 )
1515 });
1516 <Self as ITextWriter_NullTextWriterMethods>::ctor(this);
1517 this
1518 }
1519}
1520
1521#[cfg(feature = "system-io-textwriter")]
1522#[doc(hidden)]
1523pub mod prelude {
1524 pub use super::{
1525 ITextWriter, ITextWriterMethods, ITextWriter_NullTextWriter, ITextWriter_NullTextWriterMethods, ITextWriter_SyncTextWriter,
1526 ITextWriter_SyncTextWriterMethods, TextWriter, TextWriter_NullTextWriter, TextWriter_SyncTextWriter,
1527 };
1528 pub use crate::system::object::IObject;
1529 #[cfg(feature = "system-object")]
1530 pub use crate::system::object::IObjectMethods;
1531}