hexga_encoding 0.0.11-beta.53

Encoding and I/O abstraction for loading, saving, and converting data with custom extensions and media types, with optional Serde integration.
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

use super::*;

// Todo: add a cfg flag to determine the SerializerPrefered
pub type SerializerPrefered<'se> = SerializerRon<'se>;

pub type SerializerRon<'se> = ron::ser::Serializer<VecWrite<'se>>;
pub type SerializerJson<'se> = serde_json::Serializer<&'se mut Vec<u8>>;
pub type SerializerXml<'se> = serde_xml_rs::Serializer<&'se mut Vec<u8>>;

// pub type SerializerAny<'se> = Markup<SerializerRon<'se>,SerializerJson<'se>>;
// pub enum SerializerAny<'se>
// {
//     Ron(SerializerRon<'se>),
//     Json(SerializerJson<'se>),
// }
// impl<'de> std::fmt::Debug for SerializerAny<'de>
// {
//     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
//         match self {
//             Self::Ron(_) => f.write_str(Io::RON),
//             Self::Json(_) => f.write_str(Io::JSON),
//         }
//     }
// }

pub trait MarkupSerializer<'se>
{
    const EXTENSION: &'static str;
    fn new_serializer(src: &'se mut Vec<u8>) -> Self;
}

impl<'se> MarkupSerializer<'se> for SerializerRon<'se>
{
    const EXTENSION: &'static str = Extension::RON;

    fn new_serializer(src: &'se mut Vec<u8>) -> Self
    {
        SerializerRon::new(VecWrite(src), Some(Default::default())).unwrap()
    }
}
impl<'se> MarkupSerializer<'se> for SerializerJson<'se>
{
    const EXTENSION: &'static str = Extension::JSON;

    fn new_serializer(src: &'se mut Vec<u8>) -> Self { SerializerJson::new(src) }
}
impl<'se> MarkupSerializer<'se> for SerializerXml<'se>
{
    const EXTENSION: &'static str = Extension::XML;

    fn new_serializer(src: &'se mut Vec<u8>) -> Self { SerializerXml::new_from_writer(src) }
}

#[doc(hidden)]
pub struct VecWrite<'a>(&'a mut Vec<u8>);

impl<'a> std::fmt::Write for VecWrite<'a>
{
    fn write_str(&mut self, s: &str) -> std::fmt::Result
    {
        self.0.extend_from_slice(s.as_bytes());
        Ok(())
    }
}