1#![feature(type_name_of_val)]
2#![feature(core_intrinsics)]
3#![feature(get_mut_unchecked)]
4
5#[macro_use]
6extern crate serde;
7#[macro_use]
8extern crate jvm_macro;
9
10pub mod java {
11
12 pub mod io {
13
14
15 use serde::{Serialize, Deserialize, Serializer};
16 use serde::Deserializer;
17 use std::any::*;
18 use std::collections::HashMap;
19 use std::sync::{Mutex, Arc};
20 use std::fmt::{Debug, Display};
21 use std::time::Instant;
22 use serde::ser::{SerializeSeq, SerializeTuple, SerializeTupleStruct, SerializeTupleVariant, SerializeMap, SerializeStructVariant, SerializeStruct};
23 use std::fmt;
24 use std::sync::atomic::{AtomicBool, Ordering};
25 use serde::de::Visitor;
26 use std::convert::TryInto;
27
28
29 pub trait Serializable {
30
31 type Item1 : Serializable + Debug;
32 type Item2 : Serializable + Debug;
33 type Item3 : Serializable + Debug;
34 type Item4 : Serializable + Debug;
35 type Item5 : Serializable + Debug;
36
37 fn java_class_name (&self) -> String;
38 fn serial_version_uid(&self) -> u64;
39 fn get_field<T: Any + Clone + 'static>(s: &Self, field: &str) -> T;
40 fn set_field<T: Any + Clone + 'static>(s: &mut Self, field: &str, val : T);
41 fn get_fields(&self) -> Vec<(String, String, i32)>;
42 fn get_item1(&self) -> Option<&Self::Item1>;
43 fn get_item2(&self) -> Option<&Self::Item2>;
44 fn get_item3(&self) -> Option<&Self::Item3>;
45 fn get_item4(&self) -> Option<&Self::Item4>;
46 fn get_item5(&self) -> Option<&Self::Item5>;
47
48 }
49
50 pub struct ObjectOutputStream {
51 bout : Vec<u8>
52 }
53
54 impl ObjectOutputStream {
55
56 pub fn new() -> ObjectOutputStream {
57 return ObjectOutputStream {
58 bout : Vec::new(),
59 };
60 }
61
62 #[inline]
63 pub fn write_object<SER>(&mut self, object: &SER)
64 where SER: Any + Serialize + Debug + Clone + Serializable {
65 self.write_object0(object);
66 }
67
68 #[inline]
69 pub fn write_object0<SER>(&mut self, object: &SER)
70 where SER: Any + Serialize + Debug + Clone + Serializable {
71
72
73 let size = bincode::serialized_size(object).unwrap();
74
75 let mut jvm_ser = JvmSerializer {
76 buf: Vec::with_capacity(size as usize),
77 inner: false,
78 value_buf: Vec::with_capacity(size as usize),
79 metadata_structs : HashMap::new(),
80 read_idx: 0,
81 inner_is_object: false,
82 };
83
84 jvm_ser.build_metadata(Some(object));
85 jvm_ser.write_head(object);
86 let _ = object.serialize(&mut jvm_ser);
87
88 self.bout = jvm_ser.buf;
89 }
90
91 pub fn to_byte_array(&self) -> Vec<u8> {
92 self.bout.clone()
93 }
94
95 }
96
97 pub struct ObjectInputStream {
98
99 }
100
101 impl ObjectInputStream {
102 #[inline]
103 pub fn read_object<'a, SER>(&mut self, data: Vec<u8>) -> SER
104 where SER: Any + Serialize + Deserialize<'a> + Debug + Clone + Serializable + Default {
105
106 let mut jvm_ser = JvmSerializer {
107 buf: data,
108 inner: false,
109 value_buf: Vec::with_capacity(0),
110 metadata_structs : HashMap::new(),
111 read_idx: 0,
112 inner_is_object: false,
113 };
114
115 jvm_ser.read_head::<SER>();
116 return SER::deserialize(&mut jvm_ser).unwrap();
117 }
118 }
119
120
121 pub struct Compound<'a> {
122 ser: &'a mut JvmSerializer,
123 }
124
125
126 impl <'a>SerializeSeq for Compound<'a> {
127 type Ok = ();
128 type Error = Error;
129
130 fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error> where
131 T: Serialize {
132 unimplemented!()
133 }
134
135 fn end(self) -> Result<Self::Ok, Self::Error> {
136 unimplemented!()
137 }
138 }
139
140 impl <'a>SerializeTuple for Compound<'a> {
141 type Ok = ();
142 type Error = Error;
143
144 fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error> where
145 T: Serialize {
146 unimplemented!()
147 }
148
149 fn end(self) -> Result<Self::Ok, Self::Error> {
150 unimplemented!()
151 }
152 }
153
154 impl <'a>SerializeTupleStruct for Compound<'a> {
155 type Ok = ();
156 type Error = Error;
157
158 fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error> where
159 T: Serialize {
160 unimplemented!()
161 }
162
163 fn end(self) -> Result<Self::Ok, Self::Error> {
164 unimplemented!()
165 }
166 }
167
168 impl <'a>SerializeTupleVariant for Compound<'a> {
169 type Ok = ();
170 type Error = Error;
171
172 fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error> where
173 T: Serialize {
174 unimplemented!()
175 }
176
177 fn end(self) -> Result<Self::Ok, Self::Error> {
178 unimplemented!()
179 }
180 }
181
182 impl <'a>SerializeMap for Compound<'a> {
183 type Ok = ();
184 type Error = Error;
185
186 fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<(), Self::Error> where
187 T: Serialize {
188 unimplemented!()
189 }
190
191 fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error> where
192 T: Serialize {
193 unimplemented!()
194 }
195
196 fn end(self) -> Result<Self::Ok, Self::Error> {
197 unimplemented!()
198 }
199 }
200
201 impl <'a>SerializeStruct for Compound<'a> {
202 type Ok = ();
203 type Error = Error;
204
205
206 #[inline]
207 fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error> where
208 T: ?Sized + Serialize {
209
210 let class_name = type_name_of_val(value);
211 let jvm_data = self.ser.metadata_structs.get(class_name);
212 match jvm_data {
213 Some(data) => {
214
215 if data.0 != "java.lang.Object" {
216 self.ser.buf.push(115); self.ser.buf.push(114);
218 self.ser.buf.extend_from_slice(&(data.0.len() as i16).to_be_bytes());
219 self.ser.buf.extend_from_slice(data.0.as_bytes());
220
221 self.ser.buf.extend_from_slice(&data.1.to_be_bytes());
222 self.ser.buf.push(2); self.ser.buf.extend_from_slice(&data.2.to_be_bytes());
224 }
225
226 self.ser.inner = true;
227 },
228 None => {
229
230 match class_name {
231 "i32" => {
232 if self.ser.inner {
233 self.ser.buf.push(73 as u8);
234 self.ser.buf.extend_from_slice(&(key.len() as i16).to_be_bytes());
235 self.ser.buf.extend_from_slice(key.as_bytes());
236 }
237 }
238 "alloc::string::String" => {
239 if self.ser.inner {
240 if !self.ser.inner_is_object {
242 self.ser.buf.push(76);
243 self.ser.buf.extend_from_slice(&(key.len() as i16).to_be_bytes());
244 self.ser.buf.extend_from_slice(key.as_bytes());
245 } else {
246 self.ser.inner_is_object = false;
247 }
248
249
250 }
251 }
252 _ => {
253
254 }
255 }
256
257 }
258 }
259 value.serialize(&mut *self.ser)
260 }
261
262 #[inline]
263 fn end(self) -> Result<Self::Ok, Self::Error> {
264 if self.ser.inner {
265 self.ser.buf.push(113);
266 self.ser.buf.push(0);
267 self.ser.buf.push(126);
268 self.ser.buf.push(0);
269 self.ser.buf.push(1);
270 self.ser.buf.push(120); self.ser.buf.push(112); self.ser.inner = false;
273 }
274 self.ser.buf.extend(self.ser.value_buf.iter());
275 self.ser.value_buf.clear();
276 Ok(())
277 }
278 }
279
280 impl <'a>SerializeStructVariant for Compound<'a> {
281 type Ok = ();
282 type Error = Error;
283
284 fn serialize_field<T: ?Sized>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error> where
285 T: Serialize {
286 unimplemented!()
287 }
288
289 fn end(self) -> Result<Self::Ok, Self::Error> {
290 unimplemented!()
291 }
292 }
293
294 pub struct JvmSerializer {
295
296 buf: Vec<u8>,
297 inner: bool,
298 value_buf : Vec<u8>,
299 inner_is_object: bool,
300 metadata_structs : HashMap<String, (String, i64, i16)>,
302 read_idx: usize
303
304 }
305
306 impl JvmSerializer {
307
308 #[inline]
309 fn build_metadata<T>(&mut self, ob: Option<&T>) where T: Serializable + Debug {
310 match ob {
311 Some(object) => {
312 let name = type_name_of_val(object);
313 let uid = object.serial_version_uid();
314 let jvm_name = object.java_class_name();
315 let count = object.get_fields().len();
316 let idx = name.rfind("::").unwrap();
317 self.metadata_structs.insert(name.to_owned(), (jvm_name.clone(), uid as i64, count as i16));
318 self.metadata_structs.insert(name[idx+2..].to_owned(), (jvm_name, uid as i64, count as i16));
319 self.build_metadata(object.get_item1());
320 self.build_metadata(object.get_item2());
321 self.build_metadata(object.get_item3());
322 self.build_metadata(object.get_item4());
323 self.build_metadata(object.get_item5());
324 },
325 None => {}
326 }
327 }
328
329 #[inline]
330 pub fn read_head<SER>(&mut self) {
331 self.read_idx = 7;
333 let class_name_len = i16::from_be_bytes(self.buf[self.read_idx..self.read_idx + 2].try_into().unwrap());
334 self.read_idx += 2;
335 let _class_name = String::from_utf8_lossy(self.buf[self.read_idx..self.read_idx + class_name_len as usize].try_into().unwrap());
336 self.read_idx += class_name_len as usize;
337 self.read_idx += 8;
339 self.read_idx += 1;
341 let num_fileds = i16::from_be_bytes(self.buf[self.read_idx..self.read_idx + 2].try_into().unwrap());
343 self.read_idx += 2;
344 for i in 0..num_fileds {
346 let f_type = char::from(self.buf[self.read_idx]);
347 self.read_idx += 1;
348 let field_len = i16::from_be_bytes(self.buf[self.read_idx..self.read_idx + 2].try_into().unwrap());
349 self.read_idx += 2;
350 let _field_name = String::from_utf8_lossy(self.buf[self.read_idx..self.read_idx + field_len as usize].try_into().unwrap());
351 self.read_idx += field_len as usize;
352
353 if f_type == 'L' {
354 let _tc_string = char::from(self.buf[self.read_idx]);
355 self.read_idx += 1;
356 let field_type_len = i16::from_be_bytes(self.buf[self.read_idx..self.read_idx + 2].try_into().unwrap());
357 self.read_idx += 2;
358 let _field_type = String::from_utf8_lossy(self.buf[self.read_idx..self.read_idx + field_type_len as usize].try_into().unwrap());
359 self.read_idx += field_type_len as usize;
360 }
361 }
362 self.read_idx += 2;}
364
365 #[inline]
366 pub fn write_head<SER>(&mut self, ob : &SER)
367 where SER: Serializable {
368
369 self.buf.push(0); self.buf.extend_from_slice(&(-21267 as i16).to_be_bytes()); self.buf.extend_from_slice(&(5 as i16).to_be_bytes()); self.buf.push(115); self.buf.push(114); self.buf.extend_from_slice(&(ob.java_class_name().len() as i16).to_be_bytes());
376 self.buf.extend_from_slice(ob.java_class_name().as_bytes());
377 self.buf.extend_from_slice(&ob.serial_version_uid().to_be_bytes());
379 self.buf.push(0|2);
381 let fields = ob.get_fields();
383 self.buf.extend_from_slice(&(fields.len() as i16).to_be_bytes());
384
385 for (name, type_, idx) in fields {
387 let mut jvm_type_name = String::new();
388 match type_.as_str() {
389 "i32" => {
390 self.buf.push('I' as u8);
391 },
392 "u8" => {
393 self.buf.push('B' as u8);
394 },
395 "char" => {
396 self.buf.push('C' as u8);
397 },
398 "f64" => {
399 self.buf.push('D' as u8);
400 },
401 "f32" => {
402 self.buf.push('F' as u8);
403 },
404 "i64" => {
405 self.buf.push('J' as u8);
406 },
407 "i16" => {
408 self.buf.push('S' as u8);
409 },
410 "bool" => {
411 self.buf.push('Z' as u8);
412 },
413 "String" => {
414 self.buf.push('L' as u8);
415 jvm_type_name.push_str("Ljava/lang/String;")
416 }
417 _ => {
418 self.buf.push('L' as u8);
419 jvm_type_name.push('L');
420 let jvm_data = self.metadata_structs.get(&type_);
421 match jvm_data {
422 Some(data) => {
423 if data.0 == "java.lang.Object" {
424 self.inner_is_object = true;
425 }
426 jvm_type_name.push_str(&data.0.replace(".", "/"));
427 },
428 None => {}
429 }
430
431 jvm_type_name.push(';');
432 }
433 };
434 self.buf.extend_from_slice(&(name.len() as i16).to_be_bytes());
435 self.buf.extend_from_slice(name.as_bytes());
436 if !jvm_type_name.is_empty() {
437 self.buf.push(116); self.buf.extend_from_slice(&(jvm_type_name.len() as i16).to_be_bytes());
439 self.buf.extend_from_slice(jvm_type_name.as_bytes());
440 }
441 }
442 if !self.inner_is_object {
443 self.buf.push(120); self.buf.push(112); }
446 }
447
448 }
449
450
451
452 impl<'a> Serializer for &'a mut JvmSerializer {
453 type Ok = ();
454 type Error = Error;
455 type SerializeSeq = Compound<'a>;
456 type SerializeTuple = Compound<'a>;
457 type SerializeTupleStruct = Compound<'a>;
458 type SerializeTupleVariant = Compound<'a>;
459 type SerializeMap = Compound<'a>;
460 type SerializeStruct = Compound<'a>;
461 type SerializeStructVariant = Compound<'a>;
462
463 #[inline]
464 fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error> {
465 if v {
466 self.buf.push(1);
467 } else {
468 self.buf.push(0);
469 }
470 Ok(())
471 }
472
473 #[inline]
474 fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error> {
475 self.buf.extend_from_slice(&v.to_be_bytes());
476 Ok(())
477 }
478
479 #[inline]
480 fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error> {
481 self.buf.extend_from_slice(&v.to_be_bytes());
482 Ok(())
483 }
484
485 #[inline]
486 fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error> {
487 if self.inner {
488 self.value_buf.extend_from_slice(&v.to_be_bytes());
489 } else {
490 self.buf.extend_from_slice(&v.to_be_bytes());
491 }
492 Ok(())
493 }
494
495 #[inline]
496 fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> {
497 self.buf.extend_from_slice(&v.to_be_bytes());
498 Ok(())
499 }
500
501 #[inline]
502 fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> {
503 self.buf.extend_from_slice(&v.to_be_bytes());
504 Ok(())
505 }
506
507 #[inline]
508 fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error> {
509 self.buf.extend_from_slice(&v.to_be_bytes());
510 Ok(())
511 }
512
513 #[inline]
514 fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error> {
515 self.buf.extend_from_slice(&v.to_be_bytes());
516 Ok(())
517 }
518
519 #[inline]
520 fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error> {
521 self.buf.extend_from_slice(&v.to_be_bytes());
522 Ok(())
523 }
524
525 #[inline]
526 fn serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error> {
527 self.buf.extend_from_slice(&v.to_be_bytes());
528 Ok(())
529 }
530
531 #[inline]
532 fn serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error> {
533 self.buf.extend_from_slice(&v.to_be_bytes());
534 Ok(())
535 }
536
537 #[inline]
538 fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error> {
539 self.buf.push(v as u8);
540 Ok(())
541 }
542
543 #[inline]
544 fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {
545 if self.inner {
546 self.value_buf.push(116);self.value_buf.extend_from_slice(&(v.len() as i16).to_be_bytes());
548 self.value_buf.extend_from_slice(v.as_bytes());
549 } else {
550 self.buf.push(116);self.buf.extend_from_slice(&(v.len() as i16).to_be_bytes());
552 self.buf.extend_from_slice(v.as_bytes());
553 }
554 Ok(())
555 }
556
557 #[inline]
558 fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, Self::Error> {
559 self.buf.extend_from_slice(v);
560 Ok(())
561 }
562
563 #[inline]
564 fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
565 unimplemented!()
566 }
567
568 #[inline]
569 fn serialize_some<T: ?Sized>(self, value: &T) -> Result<Self::Ok, Self::Error> where
570 T: Serialize {
571 unimplemented!()
572 }
573
574 #[inline]
575 fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
576 unimplemented!()
577 }
578
579 #[inline]
580 fn serialize_unit_struct(self, name: &'static str) -> Result<Self::Ok, Self::Error> {
581 unimplemented!()
582 }
583
584 #[inline]
585 fn serialize_unit_variant(self, name: &'static str, variant_index: u32, variant: &'static str) -> Result<Self::Ok, Self::Error> {
586 unimplemented!()
587 }
588
589 #[inline]
590 fn serialize_newtype_struct<T: ?Sized>(self, name: &'static str, value: &T) -> Result<Self::Ok, Self::Error> where
591 T: Serialize {
592 unimplemented!()
593 }
594
595 #[inline]
596 fn serialize_newtype_variant<T: ?Sized>(self, name: &'static str, variant_index: u32, variant: &'static str, value: &T) -> Result<Self::Ok, Self::Error> where
597 T: Serialize {
598 unimplemented!()
599 }
600
601 #[inline]
602 fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
603 Ok(Compound { ser: self })
604 }
605
606 #[inline]
607 fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error> {
608 Ok(Compound { ser: self })
609 }
610
611 #[inline]
612 fn serialize_tuple_struct(self, name: &'static str, len: usize) -> Result<Self::SerializeTupleStruct, Self::Error> {
613 Ok(Compound { ser: self })
614 }
615
616 #[inline]
617 fn serialize_tuple_variant(self, name: &'static str, variant_index: u32, variant: &'static str, len: usize) -> Result<Self::SerializeTupleVariant, Self::Error> {
618 Ok(Compound { ser: self })
619 }
620
621 #[inline]
622 fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
623 Ok(Compound { ser: self })
624 }
625
626 #[inline]
627 fn serialize_struct(self, name: &'static str, len: usize) -> Result<Self::SerializeStruct, Self::Error> {
628 Ok(Compound { ser: self })
629 }
630
631 #[inline]
632 fn serialize_struct_variant(self, name: &'static str, variant_index: u32, variant: &'static str, len: usize) -> Result<Self::SerializeStructVariant, Self::Error> {
633 Ok(Compound { ser: self })
634 }
635
636 #[inline]
637 fn collect_str<T: ?Sized>(self, value: &T) -> Result<Self::Ok, Self::Error> where T: Display {
638 unimplemented!()
639 }
640 }
641
642
643
644 impl<'de, 'a> Deserializer<'de> for &'a mut JvmSerializer {
645 type Error = Error;
646
647 fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error> where
648 V: Visitor<'de> {
649 unimplemented!()
650 }
651
652 fn deserialize_bool<V>(self, visitor: V) -> Result<<V as Visitor<'de>>::Value, Self::Error> where
653 V: Visitor<'de> {
654 unimplemented!()
655 }
656
657 fn deserialize_i8<V>(self, visitor: V) -> Result<<V as Visitor<'de>>::Value, Self::Error> where
658 V: Visitor<'de> {
659 unimplemented!()
660 }
661
662 fn deserialize_i16<V>(self, visitor: V) -> Result<<V as Visitor<'de>>::Value, Self::Error> where
663 V: Visitor<'de> {
664 unimplemented!()
665 }
666
667 fn deserialize_i32<V>(self, visitor: V) -> Result<<V as Visitor<'de>>::Value, Self::Error> where
668 V: Visitor<'de> {
669
670 let value = i32::from_be_bytes(self.buf[self.read_idx..self.read_idx + 4].try_into().unwrap());
671 self.read_idx += 4;
672 visitor.visit_i32(value)
673 }
674
675 fn deserialize_i64<V>(self, visitor: V) -> Result<<V as Visitor<'de>>::Value, Self::Error> where
676 V: Visitor<'de> {
677 unimplemented!()
678 }
679
680 fn deserialize_u8<V>(self, visitor: V) -> Result<<V as Visitor<'de>>::Value, Self::Error> where
681 V: Visitor<'de> {
682 unimplemented!()
683 }
684
685 fn deserialize_u16<V>(self, visitor: V) -> Result<<V as Visitor<'de>>::Value, Self::Error> where
686 V: Visitor<'de> {
687 unimplemented!()
688 }
689
690 fn deserialize_u32<V>(self, visitor: V) -> Result<<V as Visitor<'de>>::Value, Self::Error> where
691 V: Visitor<'de> {
692 unimplemented!()
693 }
694
695 fn deserialize_u64<V>(self, visitor: V) -> Result<<V as Visitor<'de>>::Value, Self::Error> where
696 V: Visitor<'de> {
697 unimplemented!()
698 }
699
700 fn deserialize_f32<V>(self, visitor: V) -> Result<<V as Visitor<'de>>::Value, Self::Error> where
701 V: Visitor<'de> {
702 unimplemented!()
703 }
704
705 fn deserialize_f64<V>(self, visitor: V) -> Result<<V as Visitor<'de>>::Value, Self::Error> where
706 V: Visitor<'de> {
707 unimplemented!()
708 }
709
710 fn deserialize_char<V>(self, visitor: V) -> Result<<V as Visitor<'de>>::Value, Self::Error> where
711 V: Visitor<'de> {
712 unimplemented!()
713 }
714
715 fn deserialize_str<V>(self, visitor: V) -> Result<<V as Visitor<'de>>::Value, Self::Error> where
716 V: Visitor<'de> {
717 unimplemented!()
718 }
719
720 fn deserialize_string<V>(self, visitor: V) -> Result<<V as Visitor<'de>>::Value, Self::Error> where
721 V: Visitor<'de> {
722 self.read_idx += 1;
723 let string_len = i16::from_be_bytes(self.buf[self.read_idx..self.read_idx+2].try_into().unwrap()) as usize;
724 self.read_idx += 2;
725 let string_value = String::from_utf8_lossy(self.buf[self.read_idx..self.read_idx + string_len].try_into().unwrap());
726 self.read_idx += string_len;
727
728 visitor.visit_string(string_value.to_string())
729 }
730
731 fn deserialize_bytes<V>(self, visitor: V) -> Result<<V as Visitor<'de>>::Value, Self::Error> where
732 V: Visitor<'de> {
733 unimplemented!()
734 }
735
736 fn deserialize_byte_buf<V>(self, visitor: V) -> Result<<V as Visitor<'de>>::Value, Self::Error> where
737 V: Visitor<'de> {
738 unimplemented!()
739 }
740
741 fn deserialize_option<V>(self, visitor: V) -> Result<<V as Visitor<'de>>::Value, Self::Error> where
742 V: Visitor<'de> {
743 unimplemented!()
744 }
745
746 fn deserialize_unit<V>(self, visitor: V) -> Result<<V as Visitor<'de>>::Value, Self::Error> where
747 V: Visitor<'de> {
748 unimplemented!()
749 }
750
751 fn deserialize_unit_struct<V>(self, name: &'static str, visitor: V) -> Result<<V as Visitor<'de>>::Value, Self::Error> where
752 V: Visitor<'de> {
753 unimplemented!()
754 }
755
756 fn deserialize_newtype_struct<V>(self, name: &'static str, visitor: V) -> Result<<V as Visitor<'de>>::Value, Self::Error> where
757 V: Visitor<'de> {
758 unimplemented!()
759 }
760
761 fn deserialize_seq<V>(self, visitor: V) -> Result<<V as Visitor<'de>>::Value, Self::Error> where
762 V: Visitor<'de> {
763 unimplemented!()
764 }
765
766 fn deserialize_tuple<V>(self, len: usize, visitor: V) -> Result<<V as Visitor<'de>>::Value, Self::Error> where
767 V: Visitor<'de> {
768
769 struct Access<'a> {
770 deserializer: &'a mut JvmSerializer,
771 len: usize,
772 }
773
774 impl<'de, 'a> serde::de::SeqAccess<'de> for Access<'a> {
775 type Error = Error;
776
777 fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Error>
778 where T: serde::de::DeserializeSeed<'de>, {
779 if self.len > 0 {
780 self.len -= 1;
781 let value =
782 serde::de::DeserializeSeed::deserialize(seed, &mut *self.deserializer)?;
783 Ok(Some(value))
784 } else {
785 Ok(None)
786 }
787 }
788
789 fn size_hint(&self) -> Option<usize> {
790 Some(self.len)
791 }
792 }
793
794 visitor.visit_seq(Access {
795 deserializer: self,
796 len,
797 })
798
799 }
800
801 fn deserialize_tuple_struct<V>(self, name: &'static str, len: usize, visitor: V) -> Result<<V as Visitor<'de>>::Value, Self::Error> where
802 V: Visitor<'de> {
803 unimplemented!()
804 }
805
806 fn deserialize_map<V>(self, visitor: V) -> Result<<V as Visitor<'de>>::Value, Self::Error> where
807 V: Visitor<'de> {
808 unimplemented!()
809 }
810
811 fn deserialize_struct<V>(self, name: &'static str, fields: &'static [&'static str], visitor: V) -> Result<<V as Visitor<'de>>::Value, Self::Error> where
812 V: Visitor<'de> {
813
814 let inner_type_code = self.buf[self.read_idx];
815 if inner_type_code == 115 { self.read_idx +=2;
818 let string_len = i16::from_be_bytes(self.buf[self.read_idx..self.read_idx+2].try_into().unwrap()) as usize;
819 self.read_idx += 2;
820 let _string_value = String::from_utf8_lossy(self.buf[self.read_idx..self.read_idx + string_len].try_into().unwrap());
821 self.read_idx += string_len;
822 let _uuid = i64::from_be_bytes(self.buf[self.read_idx..self.read_idx+8].try_into().unwrap());
823 self.read_idx += 8;
824 self.read_idx += 3;
825
826 for _f in fields {
827 let _code = self.buf[self.read_idx];
828 self.read_idx += 1;
829 let string_len = i16::from_be_bytes(self.buf[self.read_idx..self.read_idx+2].try_into().unwrap()) as usize;
830 self.read_idx += 2;
831 let _string_value = String::from_utf8_lossy(self.buf[self.read_idx..self.read_idx + string_len].try_into().unwrap());
832 self.read_idx += string_len;
833 }
834 self.read_idx += 7;
835
836 self.inner = true;
837 }
838
839 self.deserialize_tuple(fields.len(), visitor)
840 }
841
842 fn deserialize_enum<V>(self, name: &'static str, variants: &'static [&'static str], visitor: V) -> Result<<V as Visitor<'de>>::Value, Self::Error> where
843 V: Visitor<'de> {
844 unimplemented!()
845 }
846
847 fn deserialize_identifier<V>(self, visitor: V) -> Result<<V as Visitor<'de>>::Value, Self::Error> where
848 V: Visitor<'de> {
849 unimplemented!()
850 }
851
852 fn deserialize_ignored_any<V>(self, visitor: V) -> Result<<V as Visitor<'de>>::Value, Self::Error> where
853 V: Visitor<'de> {
854 unimplemented!()
855 }
856 }
857
858
859
860
861
862
863 #[derive(Debug)]
864 pub struct Error {
865 err: Box<ErrorImpl>,
866 }
867
868 #[derive(Debug)]
869 struct ErrorImpl {
870 line: usize,
871 column: usize,
872 }
873
874 impl Display for ErrorImpl {
875 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
876 write!(f, "Error at line {} column {}", self.line, self.column)
880 }
882 }
883
884 impl Display for Error {
885 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
886 Display::fmt(&*self.err, f)
887 }
888 }
889
890 impl serde::ser::StdError for Error {
891
892 }
893
894 impl serde::ser::Error for Error {
895
896 fn custom<T>(msg: T) -> Self where
897 T: Display {
898 unimplemented!()
899 }
900 }
901
902 impl serde::de::Error for Error {
903
904 fn custom<T>(msg: T) -> Self where
905 T: Display {
906 unimplemented!()
907 }
908 }
909
910 }
911}
912