haxeformat/
lib.rs

1//! Rust implementation of the [Haxe serialization format](https://haxe.org/manual/std-serialization.html),
2//! with serde support.
3//!
4//! # Usage
5//!
6//! ```rust
7//! use serde::{ Serialize, Deserialize };
8//!
9//! #[derive(Debug, Eq, PartialEq, Serialize, Deserialize)]
10//! struct Person {
11//!     name: String,
12//!     surname: String,
13//!     age: u32,
14//! }
15//!
16//! let person = Person { name: "John".to_owned(), surname: "Doe".to_owned(), age: 42 };
17//! let serialized = "oy4:namey4:Johny7:surnamey3:Doey3:agei42g";
18//!
19//! assert_eq!(haxeformat::from_str::<Person>(serialized).unwrap(), person);
20//! assert_eq!(haxeformat::to_string::<Person>(&person).unwrap(), serialized);
21//! ```
22
23pub mod raw;
24pub mod serde;
25pub mod value;
26
27pub use crate::serde::*;
28pub use raw::{HaxeDate, HaxeError, Result};
29
30use std::io::{Read, Write};
31
32pub struct StreamSerializer<W, C> {
33    ser: raw::WriteSerializer<W>,
34    ctx: C,
35}
36
37impl<W: Write, C> StreamSerializer<W, C> {
38    pub fn new(writer: W, ctx: C) -> Self {
39        let ser = raw::WriteSerializer::new(writer);
40        Self { ser, ctx }
41    }
42
43    pub fn serialize<'a, 'ser, T>(&'a mut self, value: &'ser T) -> Result<()>
44    where
45        T: raw::HaxeSerialize<'ser, &'a mut C>,
46    {
47        value.serialize(&mut self.ctx, &mut self.ser)
48    }
49
50    pub fn serialize_with<'a, 'ser, T, S, F>(&'a mut self, value: &'ser T, state: F) -> Result<()>
51    where
52        T: raw::HaxeSerialize<'ser, S>,
53        F: FnOnce(&'a mut C) -> S,
54    {
55        value.serialize(state(&mut self.ctx), &mut self.ser)
56    }
57
58    pub fn into_inner(self) -> W {
59        self.ser.into_inner()
60    }
61}
62
63pub struct StreamDeserializer<R, C> {
64    de: raw::ReadDeserializer<R>,
65    ctx: C,
66}
67
68impl<R: Read, C> StreamDeserializer<R, C> {
69    pub fn new(reader: R, ctx: C) -> Self {
70        let de = raw::ReadDeserializer::new(reader);
71        Self { de, ctx }
72    }
73
74    pub fn deserialize<'a, 'de, T>(&'a mut self) -> Result<T>
75    where
76        T: raw::HaxeDeserialize<'de, &'a mut C>,
77    {
78        self.deserialize_with(|ctx| ctx)
79    }
80
81    pub fn deserialize_with<'a, 'de, T, S, F>(&'a mut self, state: F) -> Result<T>
82    where
83        T: raw::HaxeDeserialize<'de, S>,
84        F: FnOnce(&'a mut C) -> S,
85    {
86        T::deserialize(state(&mut self.ctx), &mut self.de)
87    }
88
89    pub fn has_next(&mut self) -> bool {
90        self.de.has_next()
91    }
92
93    pub fn end(mut self) -> Result<C> {
94        self.de.end()?;
95        Ok(self.ctx)
96    }
97}
haxeformat/lib.rs

haxeformat/
lib.rs
