tycho 0.1.2

A minimal, self-describing and traversable binary data format designed around rust and the serde data model.
Documentation 
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

use serde::ser::{SerializeStruct, SerializeStructVariant, SerializeTupleVariant};
use serde::Serialize;

use crate::Element;
use crate::error::TychoError;
use crate::serde::ser::seq::SeqSerializer;
use crate::serde::ser::struct_::StructSerializer;

pub struct VariantSeqSerializer {
    name: String,
    seq: SeqSerializer
}

impl VariantSeqSerializer {
    pub fn new(name: &str, seq: SeqSerializer) -> Self {
        Self {
            name: name.to_string(),
            seq
        }
    }
}

impl SerializeTupleVariant for VariantSeqSerializer {
    type Ok = Element;
    type Error = TychoError;

    fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error> where
        T: Serialize {
        self.seq.element(value)
    }

    fn end(self) -> Result<Self::Ok, Self::Error> {
        Ok(Element::Variant(self.name, Box::from(self.seq.finish()?)))
    }
}

pub struct VariantStructSerializer {
    name: String,
    inner: StructSerializer
}

impl VariantStructSerializer {
    pub fn new(s: &str, inner: StructSerializer) -> Self {
        Self {
            name: s.to_string(),
            inner
        }
    }
}

impl SerializeStructVariant for VariantStructSerializer {
    type Ok = Element;
    type Error = TychoError;

    fn serialize_field<T: ?Sized>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error> where
        T: Serialize {
        self.inner.serialize_field(key, value)
    }

    fn end(self) -> Result<Self::Ok, Self::Error> {
        Ok(Element::Variant(self.name, Box::from(self.inner.end()?)))
    }
}