lenso_process_protocol/
strict_json.rs1use std::collections::HashSet;
2
3use serde::{Deserialize, Serialize, de::DeserializeOwned};
4
5use super::ProtocolError;
6
7pub fn decode_strict<T: DeserializeOwned>(wire: &[u8]) -> Result<T, ProtocolError> {
9 serde_json::from_slice::<StrictValue>(wire)
10 .map_err(|error| ProtocolError::new(format!("invalid strict JSON: {error}")))?;
11 serde_json::from_slice(wire)
12 .map_err(|error| ProtocolError::new(format!("invalid protocol document: {error}")))
13}
14
15pub fn encode_compact<T: Serialize>(value: &T) -> Result<Vec<u8>, ProtocolError> {
17 serde_json::to_vec(value)
18 .map_err(|error| ProtocolError::new(format!("cannot encode protocol document: {error}")))
19}
20
21#[derive(Clone, Debug)]
22struct StrictValue;
23
24impl<'de> Deserialize<'de> for StrictValue {
25 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
26 where
27 D: serde::Deserializer<'de>,
28 {
29 deserializer.deserialize_any(StrictValueVisitor)
30 }
31}
32
33struct StrictValueVisitor;
34
35impl<'de> serde::de::Visitor<'de> for StrictValueVisitor {
36 type Value = StrictValue;
37
38 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
39 formatter.write_str("strict JSON without duplicate object keys")
40 }
41
42 fn visit_bool<E>(self, _value: bool) -> Result<Self::Value, E> {
43 Ok(StrictValue)
44 }
45 fn visit_i64<E>(self, _value: i64) -> Result<Self::Value, E> {
46 Ok(StrictValue)
47 }
48 fn visit_u64<E>(self, _value: u64) -> Result<Self::Value, E> {
49 Ok(StrictValue)
50 }
51 fn visit_f64<E>(self, _value: f64) -> Result<Self::Value, E> {
52 Ok(StrictValue)
53 }
54 fn visit_str<E>(self, _value: &str) -> Result<Self::Value, E> {
55 Ok(StrictValue)
56 }
57 fn visit_string<E>(self, _value: String) -> Result<Self::Value, E> {
58 Ok(StrictValue)
59 }
60 fn visit_none<E>(self) -> Result<Self::Value, E> {
61 Ok(StrictValue)
62 }
63 fn visit_unit<E>(self) -> Result<Self::Value, E> {
64 Ok(StrictValue)
65 }
66
67 fn visit_seq<A>(self, mut sequence: A) -> Result<Self::Value, A::Error>
68 where
69 A: serde::de::SeqAccess<'de>,
70 {
71 while sequence.next_element::<StrictValue>()?.is_some() {}
72 Ok(StrictValue)
73 }
74
75 fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
76 where
77 A: serde::de::MapAccess<'de>,
78 {
79 let mut keys = HashSet::new();
80 while let Some(key) = map.next_key::<String>()? {
81 if !keys.insert(key.clone()) {
82 return Err(serde::de::Error::custom(format!(
83 "duplicate object key {key:?}"
84 )));
85 }
86 map.next_value::<StrictValue>()?;
87 }
88 Ok(StrictValue)
89 }
90}