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
95
96
97

//! Rust implementation of the [Haxe serialization format](https://haxe.org/manual/std-serialization.html),
//! with serde support.
//!
//! # Usage
//!
//! ```rust
//! use serde::{ Serialize, Deserialize };
//!
//! #[derive(Debug, Eq, PartialEq, Serialize, Deserialize)]
//! struct Person {
//!     name: String,
//!     surname: String,
//!     age: u32,
//! }
//!
//! let person = Person { name: "John".to_owned(), surname: "Doe".to_owned(), age: 42 };
//! let serialized = "oy4:namey4:Johny7:surnamey3:Doey3:agei42g";
//!
//! assert_eq!(haxeformat::from_str::<Person>(serialized).unwrap(), person);
//! assert_eq!(haxeformat::to_string::<Person>(&person).unwrap(), serialized);
//! ```

pub mod raw;
pub mod serde;
pub mod value;

pub use crate::serde::*;
pub use raw::{HaxeDate, HaxeError, Result};

use std::io::{Read, Write};

pub struct StreamSerializer<W, C> {
    ser: raw::WriteSerializer<W>,
    ctx: C,
}

impl<W: Write, C> StreamSerializer<W, C> {
    pub fn new(writer: W, ctx: C) -> Self {
        let ser = raw::WriteSerializer::new(writer);
        Self { ser, ctx }
    }

    pub fn serialize<'a, 'ser, T>(&'a mut self, value: &'ser T) -> Result<()>
    where
        T: raw::HaxeSerialize<'ser, &'a mut C>,
    {
        value.serialize(&mut self.ctx, &mut self.ser)
    }

    pub fn serialize_with<'a, 'ser, T, S, F>(&'a mut self, value: &'ser T, state: F) -> Result<()>
    where
        T: raw::HaxeSerialize<'ser, S>,
        F: FnOnce(&'a mut C) -> S,
    {
        value.serialize(state(&mut self.ctx), &mut self.ser)
    }

    pub fn into_inner(self) -> W {
        self.ser.into_inner()
    }
}

pub struct StreamDeserializer<R, C> {
    de: raw::ReadDeserializer<R>,
    ctx: C,
}

impl<R: Read, C> StreamDeserializer<R, C> {
    pub fn new(reader: R, ctx: C) -> Self {
        let de = raw::ReadDeserializer::new(reader);
        Self { de, ctx }
    }

    pub fn deserialize<'a, 'de, T>(&'a mut self) -> Result<T>
    where
        T: raw::HaxeDeserialize<'de, &'a mut C>,
    {
        self.deserialize_with(|ctx| ctx)
    }

    pub fn deserialize_with<'a, 'de, T, S, F>(&'a mut self, state: F) -> Result<T>
    where
        T: raw::HaxeDeserialize<'de, S>,
        F: FnOnce(&'a mut C) -> S,
    {
        T::deserialize(state(&mut self.ctx), &mut self.de)
    }

    pub fn has_next(&mut self) -> bool {
        self.de.has_next()
    }

    pub fn end(mut self) -> Result<C> {
        self.de.end()?;
        Ok(self.ctx)
    }
}