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

pub use lazy_static::lazy_static;

pub use preserves::value::Reader;
pub use preserves::value::boundary as B;

use preserves::value::ArcValue;
use preserves::value::Domain;
use preserves::value::Embeddable;
use preserves::value::IOValue;
use preserves::value::NestedValue;
use preserves::value::NoEmbeddedDomainCodec;
use preserves::value::Value;

use std::convert::From;
use std::convert::TryFrom;
use std::io;
use std::sync::Arc;

use thiserror::Error;

pub trait Deserialize<'de, D: Embeddable, N: NestedValue<D>, R: Reader<'de, D, N>>
where
    Self: Sized
{
    fn deserialize(r: &mut R) -> Result<Self, ParseError>;
}

pub fn decode_lit<D: Embeddable, N: NestedValue<D>>(bs: &[u8]) -> io::Result<N> {
    preserves::value::packed::from_bytes(bs, NoEmbeddedDomainCodec)
}

pub fn decode_embedded<D: Domain>(
    v: &IOValue,
) -> Result<ArcValue<Arc<D>>, ParseError>
where
    for<'a> D: TryFrom<&'a IOValue, Error = ParseError>
{
    v.copy_via(&mut |d| Ok(Value::Embedded(Arc::new(D::try_from(d)?))))
}

pub fn encode_embedded<D: Domain>(
    v: &ArcValue<Arc<D>>,
) -> IOValue
where
    for<'a> IOValue: From<&'a D>
{
    v.copy_via::<_, _, _, std::convert::Infallible>(
        &mut |d| Ok(Value::Embedded(IOValue::from(d)))).unwrap()
}

#[derive(Error, Debug)]
pub enum ParseError {
    #[error("Input not conformant with Schema: {0}")]
    ConformanceError(&'static str),
    #[error(transparent)]
    Preserves(preserves::error::Error),
}

impl From<preserves::error::Error> for ParseError {
    fn from(v: preserves::error::Error) -> Self {
        match v {
            preserves::error::Error::Expected(_, _) =>
                ParseError::ConformanceError("preserves::error::Error::Expected"),
            _ =>
                ParseError::Preserves(v),
        }
    }
}

impl From<io::Error> for ParseError {
    fn from(v: io::Error) -> Self {
        preserves::error::Error::from(v).into()
    }
}

impl From<ParseError> for io::Error {
    fn from(v: ParseError) -> Self {
        match v {
            ParseError::ConformanceError(_) => io::Error::new(io::ErrorKind::InvalidData, v),
            ParseError::Preserves(e) => e.into(),
        }
    }
}

impl ParseError {
    pub fn conformance_error(context: &'static str) -> Self {
        ParseError::ConformanceError(context)
    }

    pub fn is_conformance_error(&self) -> bool {
        return if let ParseError::ConformanceError(_) = self { true } else { false }
    }
}