tuwunel_core/utils/
json.rs1use std::{borrow::Cow, fmt, io, marker::PhantomData, str::FromStr};
9
10use ruma::{
11 CanonicalJsonError, CanonicalJsonObject, canonical_json::try_from_json_map, serde::Raw,
12};
13use serde::{Deserialize, Deserializer, de::IgnoredAny};
14
15use crate::Result;
16
17#[derive(Default)]
19struct Counter(usize);
20
21#[derive(Deserialize)]
23#[serde(untagged)]
24enum LenientBool<'a> {
25 Bool(bool),
26 Str(#[serde(borrow)] Cow<'a, str>),
27 Other(IgnoredAny),
28}
29
30pub fn to_raw<T: serde::Serialize, U>(input: T) -> Result<Raw<U>> {
36 Ok(serde_json::from_value(serde_json::to_value(input)?)?)
37}
38
39pub fn to_canonical_object<T: serde::Serialize>(
45 value: T,
46) -> Result<CanonicalJsonObject, CanonicalJsonError> {
47 use CanonicalJsonError::SerDe;
48 use serde::ser::Error;
49
50 match serde_json::to_value(value).map_err(SerDe)? {
51 | serde_json::Value::Object(map) => try_from_json_map(map),
52 | _ => Err(SerDe(serde_json::Error::custom("Value must be an object"))),
53 }
54}
55
56pub fn serialized_len<T: serde::Serialize>(value: &T) -> Result<usize> {
61 let mut counter = Counter::default();
62
63 serde_json::to_writer(&mut counter, value)?;
64
65 Ok(counter.0)
66}
67
68impl io::Write for Counter {
69 fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
70 self.0 = self.0.saturating_add(buf.len());
71
72 Ok(buf.len())
73 }
74
75 fn flush(&mut self) -> io::Result<()> { Ok(()) }
76}
77
78pub fn deserialize_from_str<'de, D, T, E>(deserializer: D) -> Result<T, D::Error>
83where
84 D: Deserializer<'de>,
85 T: FromStr<Err = E>,
86 E: fmt::Display,
87{
88 struct Visitor<T: FromStr<Err = E>, E>(PhantomData<T>);
89
90 impl<T, Err> serde::de::Visitor<'_> for Visitor<T, Err>
91 where
92 T: FromStr<Err = Err>,
93 Err: fmt::Display,
94 {
95 type Value = T;
96
97 fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
98 write!(formatter, "a parsable string")
99 }
100
101 fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
102 where
103 E: serde::de::Error,
104 {
105 v.parse().map_err(serde::de::Error::custom)
106 }
107 }
108
109 deserializer.deserialize_str(Visitor(PhantomData))
110}
111
112pub fn deserialize_lenient_bool<'de, D>(deserializer: D) -> Result<Option<bool>, D::Error>
118where
119 D: Deserializer<'de>,
120{
121 Deserialize::deserialize(deserializer)
122 .map(|value: Option<LenientBool<'_>>| value.map(bool::from))
123}
124
125impl From<LenientBool<'_>> for bool {
126 fn from(value: LenientBool<'_>) -> Self {
127 match value {
128 | LenientBool::Bool(value) => value,
129 | LenientBool::Str(value) => value.eq_ignore_ascii_case("true"),
130 | LenientBool::Other(_) => false,
131 }
132 }
133}