use std::collections::BTreeMap;
use serde::{Deserialize, Serialize};
use super::validate::{Validate, Validator};
#[cfg_attr(feature = "cpo", doc = "```rust")]
#[cfg_attr(not(feature = "cpo"), doc = "```rust,ignore")]
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
#[serde(transparent)]
pub struct Extensions(BTreeMap<String, serde_json::Value>);
impl Extensions {
#[must_use]
pub fn new() -> Self {
Self::default()
}
#[must_use]
pub fn is_empty(&self) -> bool {
self.0.is_empty()
}
#[must_use]
pub fn len(&self) -> usize {
self.0.len()
}
#[must_use]
pub fn get_raw(&self, key: &str) -> Option<&serde_json::Value> {
self.0.get(key)
}
pub fn get<T: serde::de::DeserializeOwned>(&self, key: &str) -> Result<Option<T>, serde_json::Error> {
self.0.get(key).map(|v| serde_json::from_value(v.clone())).transpose()
}
#[must_use]
pub fn contains_key(&self, key: &str) -> bool {
self.0.contains_key(key)
}
pub fn insert<T: Serialize>(
&mut self,
key: impl Into<String>,
value: T,
) -> Result<(), serde_json::Error> {
self.0.insert(key.into(), serde_json::to_value(value)?);
Ok(())
}
pub fn remove(&mut self, key: &str) -> Option<serde_json::Value> {
self.0.remove(key)
}
pub fn keys(&self) -> impl Iterator<Item = &str> {
self.0.keys().map(String::as_str)
}
pub fn iter(&self) -> impl Iterator<Item = (&str, &serde_json::Value)> {
self.0.iter().map(|(k, v)| (k.as_str(), v))
}
}
impl Validate for Extensions {
fn validate_in(&self, _v: &mut Validator) {}
}
impl FromIterator<(String, serde_json::Value)> for Extensions {
fn from_iter<I: IntoIterator<Item = (String, serde_json::Value)>>(iter: I) -> Self {
Self(iter.into_iter().collect())
}
}
#[cfg(feature = "schema")]
impl schemars::JsonSchema for Extensions {
fn schema_name() -> std::borrow::Cow<'static, str> {
"Extensions".into()
}
fn json_schema(_g: &mut schemars::SchemaGenerator) -> schemars::Schema {
schemars::json_schema!({ "type": "object", "additionalProperties": true })
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn unknown_fields_survive_a_round_trip_in_sorted_order() {
let json = r#"{"a_first":1,"z_last":"text"}"#;
let ext: Extensions = serde_json::from_str(json).unwrap();
assert_eq!(ext.len(), 2);
assert_eq!(serde_json::to_string(&ext).unwrap(), json);
}
#[test]
fn typed_access_reports_a_mismatch_rather_than_guessing() {
let ext: Extensions = serde_json::from_str(r#"{"n":3,"s":"x"}"#).unwrap();
assert_eq!(ext.get::<u32>("n").unwrap(), Some(3));
assert_eq!(ext.get::<u32>("missing").unwrap(), None);
assert!(ext.get::<u32>("s").is_err());
}
}