jvm_serializable/
lib.rs

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); //TC_OBJECT
217                            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); // flagi
223                            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                                    //field type - String
241                                    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); //TC_ENDBLOCKDATA
271                    self.ser.buf.push(112); //TC_NULL
272                    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                                //simple name, (full name, serialuid, num of fields)
301            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                //ignore first 7 bytes
332                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                //serialVersionUID
338                self.read_idx += 8;
339                //class flags
340                self.read_idx += 1;
341                //fields len
342                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                //fields
345                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;//TC_ENDBLOCKDATA, TC_NULL
363            }
364
365            #[inline]
366            pub fn write_head<SER>(&mut self, ob : &SER)
367            where SER: Serializable {
368
369                self.buf.push(0); // flaga
370                self.buf.extend_from_slice(&(-21267 as i16).to_be_bytes()); //STREAM_MAGIC
371                self.buf.extend_from_slice(&(5 as i16).to_be_bytes()); //STREAM_MAGIC
372                self.buf.push(115); //TC_OBJECT
373                self.buf.push(114); //TC_CLASSDESC
374                // class_name
375                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                //serialVersionUID
378                self.buf.extend_from_slice(&ob.serial_version_uid().to_be_bytes());
379                //class flags
380                self.buf.push(0|2);
381                //fields len
382                let fields = ob.get_fields();
383                self.buf.extend_from_slice(&(fields.len() as i16).to_be_bytes());
384
385                //fields
386                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); //TC_STRING
438                        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); //TC_ENDBLOCKDATA
444                    self.buf.push(112); // TC_NULL
445                }
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);//TC_STRING
547                    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);//TC_STRING
551                    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 { //TC_OBJECT
816                    // consume inner object header
817                    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                // if self.line == 0 {
877                //     Display::fmt(&self.code, f)
878                // } else {
879                    write!(f, "Error at line {} column {}", self.line, self.column)
880                // }
881            }
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