1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94


pub mod adapter;
mod ser;
mod de;

#[cfg(test)]
mod tests;

pub use ser::{ Serializer, SerializerContext };
pub use de::{ Deserializer, DeserializerContext, DeserializeSeed };

use std::fmt::Display;
use std::io::{ Read, Write, Cursor };

use serde::de::{ Expected, Unexpected };
use serde::{ Serialize, Deserialize };

use crate::{ HaxeError, Result, StreamDeserializer, StreamSerializer };

impl serde::de::Error for HaxeError {
    fn custom<T: Display>(msg: T) -> Self {
        HaxeError::custom(msg)
    }

    fn invalid_type(unexp: Unexpected, exp: &dyn Expected) -> Self {
        HaxeError::unexpected_input(exp, unexp)
    }

    fn invalid_value(unexp: Unexpected, exp: &dyn Expected) -> Self {
        HaxeError::unexpected_input(exp, unexp)
    }
}

impl serde::ser::Error for HaxeError {
    fn custom<T: Display>(msg: T) -> Self {
        HaxeError::custom(msg)
    }
}



pub fn from_reader_with<'de, R: Read, T: Deserialize<'de>>(reader: R, ctx: DeserializerContext) -> Result<T> {
    let mut de = StreamDeserializer::new(reader, ctx);
    let value = de.deserialize()?;
    de.end()?;
    Ok(value)
}

pub fn from_reader<'de, R: Read, T: Deserialize<'de>>(reader: R) -> Result<T> {
   from_reader_with(reader, DeserializerContext::new()) 
}

pub fn from_slice_with<'de, T: Deserialize<'de>>(bytes: &[u8], ctx: DeserializerContext) -> Result<T> {
    from_reader_with(Cursor::new(&bytes), ctx)
}

pub fn from_slice<'de, T: Deserialize<'de>>(bytes: &[u8]) -> Result<T> {
    from_reader(Cursor::new(&bytes))
}

pub fn from_str_with<'de, T: Deserialize<'de>>(string: &str, ctx: DeserializerContext) -> Result<T> {
    from_reader_with(Cursor::new(&string), ctx)
}

pub fn from_str<'de, T: Deserialize<'de>>(string: &str) -> Result<T> {
    from_reader(Cursor::new(&string))
}

pub fn to_writer_with<W: Write, T: Serialize>(value: &T, writer: W, ctx: SerializerContext) -> Result<()> {
    StreamSerializer::new(writer, ctx).serialize(value)
}

pub fn to_writer<W: Write, T: Serialize>(value: &T, writer: W) -> Result<()> {
    to_writer_with(value, writer, SerializerContext::new())
}

pub fn to_vec_with<T: Serialize>(value: &T, ctx: SerializerContext) -> Result<Vec<u8>> {
    let mut ser = StreamSerializer::new(Cursor::new(Vec::new()), ctx);
    ser.serialize(value)?;
    Ok(ser.into_inner().into_inner())
}

pub fn to_vec<T: Serialize>(value: &T) -> Result<Vec<u8>> {
    to_vec_with(value, SerializerContext::new())
}

pub fn to_string_with<T: Serialize>(value: &T, ctx: SerializerContext) -> Result<String> {
    let vec = to_vec_with(value, ctx)?;
    Ok(String::from_utf8(vec).expect("invalid utf8 data"))
}

pub fn to_string<T: Serialize>(value: &T) -> Result<String> {
    to_string_with(value, SerializerContext::new())
}