object-rainbow-json 0.0.0-a.24

serde_json for object-rainbow
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
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
98
99
100
101
102
103
104
105
106
107

#![forbid(unsafe_code)]
#![cfg_attr(docsrs, feature(doc_cfg))]
#![cfg_attr(docsrs, doc(cfg_hide(doc)))]

use std::{ops::Deref, sync::Arc};

use object_rainbow::{
    InlineOutput, ListHashes, MaybeHasNiche, Output, Parse, ParseInput, Size, SomeNiche, Tagged,
    ToOutput, Topological, TryDefault, ZeroNiche,
};
use serde::{Serialize, de::DeserializeOwned};

#[cfg(feature = "distributed")]
pub use self::distributed::{Distributed, DistributedParseError};

#[cfg(feature = "distributed")]
mod distributed;

#[derive(Debug)]
struct JsonInner<T> {
    value: T,
    data: Vec<u8>,
}

impl<T> PartialEq for JsonInner<T> {
    fn eq(&self, other: &Self) -> bool {
        self.data == other.data
    }
}

impl<T> Eq for JsonInner<T> {}

impl<T> std::hash::Hash for JsonInner<T> {
    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
        self.data.hash(state);
    }
}

#[derive(Debug, PartialEq, Eq, Hash)]
pub struct Json<T> {
    inner: Arc<JsonInner<T>>,
}

impl<T> Deref for Json<T> {
    type Target = T;

    fn deref(&self) -> &Self::Target {
        &self.inner.value
    }
}

impl<T> Clone for Json<T> {
    fn clone(&self) -> Self {
        Self {
            inner: self.inner.clone(),
        }
    }
}

impl<T: Serialize> Json<T> {
    pub fn new(value: T) -> object_rainbow::Result<Self> {
        let data = serde_json::to_vec(&value).map_err(object_rainbow::Error::parse)?;
        Ok(Self {
            inner: Arc::new(JsonInner { value, data }),
        })
    }
}

impl<T: Serialize + Default> TryDefault for Json<T> {
    fn try_default() -> object_rainbow::Result<Self> {
        Self::new(Default::default())
    }
}

impl<T> ToOutput for Json<T> {
    fn to_output(&self, output: &mut impl Output) {
        self.inner.data.to_output(output);
    }
}

impl<T: DeserializeOwned + Serialize, I: ParseInput> Parse<I> for Json<T> {
    fn parse(input: I) -> object_rainbow::Result<Self> {
        let data = input.parse_all()?;
        let json = serde_json::from_slice(&data)
            .map_err(object_rainbow::Error::parse)
            .and_then(Self::new)?;
        if *data == json.vec() {
            Ok(json)
        } else {
            Err(object_rainbow::error_parse!("inconsistent serialization"))
        }
    }
}

impl<T> ListHashes for Json<T> {}
impl<T> Topological for Json<T> {}
impl<T> Tagged for Json<T> {}

impl InlineOutput for Json<()> {}

impl Size for Json<()> {
    type Size = object_rainbow::typenum::consts::U4;
}

impl MaybeHasNiche for Json<()> {
    type MnArray = SomeNiche<ZeroNiche<<Self as Size>::Size>>;
}