object-rainbow-json 0.0.0-a.22

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
108
109
110
111
112
113
114
115
116

use std::collections::BTreeMap;

use futures_util::future::try_join_all;
use object_rainbow::{
    Enum, Fetch, InlineOutput, ListHashes, MaybeHasNiche, NicheForUnsized, NoNiche, Parse,
    ParseInline, Tagged, ToOutput, Topological, length_prefixed::LpString, numeric::Le,
};
use object_rainbow_point::{IntoPoint, Point};
use serde::{Deserialize, Serialize};

#[derive(
    Enum,
    ToOutput,
    InlineOutput,
    ListHashes,
    Topological,
    Parse,
    ParseInline,
    Clone,
    Default,
    Serialize,
    Deserialize,
)]
#[serde(untagged)]
#[topology(recursive)]
pub enum Distributed {
    #[default]
    Null,
    Bool(bool),
    I64(Le<i64>),
    U64(Le<u64>),
    F64(Le<f64>),
    String(Point<String>),
    Array(#[parse(unchecked)] Point<Vec<Self>>),
    Object(#[parse(unchecked)] Point<BTreeMap<LpString, Self>>),
}

impl Tagged for Distributed {}
impl MaybeHasNiche for Distributed {
    type MnArray = NoNiche<NicheForUnsized>;
}

impl Distributed {
    pub async fn to_value(&self) -> object_rainbow::Result<serde_json::Value> {
        Ok(match *self {
            Distributed::Null => serde_json::Value::Null,
            Distributed::Bool(x) => x.into(),
            Distributed::I64(x) => x.0.into(),
            Distributed::U64(x) => x.0.into(),
            Distributed::F64(x) => x.0.into(),
            Distributed::String(ref point) => point.fetch().await?.into(),
            Distributed::Array(ref point) => try_join_all(
                point
                    .fetch()
                    .await?
                    .into_iter()
                    .map(async |x| x.to_value().await),
            )
            .await?
            .into(),
            Distributed::Object(ref point) => {
                try_join_all(
                    point.fetch().await?.into_iter().map(async |(k, x)| {
                        Ok::<_, object_rainbow::Error>((k.0, x.to_value().await?))
                    }),
                )
                .await?
                .into_iter()
                .collect::<serde_json::Map<_, _>>()
                .into()
            }
        })
    }
}

#[derive(Debug, thiserror::Error)]
#[non_exhaustive]
pub enum DistributedParseError {
    #[error("invalid number")]
    InvalidNumber,
}

impl TryFrom<serde_json::Value> for Distributed {
    type Error = DistributedParseError;

    fn try_from(value: serde_json::Value) -> Result<Self, Self::Error> {
        Ok(match value {
            serde_json::Value::Null => Self::Null,
            serde_json::Value::Bool(x) => Self::Bool(x),
            serde_json::Value::Number(x) => {
                if let Some(x) = x.as_u64() {
                    Self::U64(x.into())
                } else if let Some(x) = x.as_i64() {
                    Self::I64(x.into())
                } else if let Some(x) = x.as_f64() {
                    Self::F64(x.into())
                } else {
                    return Err(DistributedParseError::InvalidNumber);
                }
            }
            serde_json::Value::String(x) => Self::String(x.point()),
            serde_json::Value::Array(vec) => Self::Array(
                vec.into_iter()
                    .map(Self::try_from)
                    .collect::<Result<Vec<_>, _>>()?
                    .point(),
            ),
            serde_json::Value::Object(map) => Self::Object(
                map.into_iter()
                    .map(|(k, v)| Ok((LpString(k), Self::try_from(v)?)))
                    .collect::<Result<BTreeMap<_, _>, _>>()?
                    .point(),
            ),
        })
    }
}