gltf-reader 0.1.0

//! JSON types that show up in the parsed glTF structure.

use core::fmt;

use alloc::borrow::Cow;
use alloc::collections::btree_map::BTreeMap;
use alloc::string::String;
use alloc::vec::Vec;
use serde::Deserialize;
use serde::de::{MapAccess, SeqAccess, Visitor};
use serde_json::Number;

/// A JSON object (i.e. a map from strings to [`Value`]s).
#[derive(Debug, Clone, PartialEq, Eq, Default, Deserialize)]
#[serde(transparent)]
pub struct Object<'a>(#[serde(borrow)] pub BTreeMap<Cow<'a, str>, Value<'a>>);

impl Object<'_> {
    pub fn into_owned(self) -> Object<'static> {
        Object(
            self.0
                .into_iter()
                .map(|(k, v)| (Cow::Owned(k.into_owned()), v.into_owned()))
                .collect(),
        )
    }
}

impl ownable::traits::IntoOwned for Object<'_> {
    type Owned = Object<'static>;

    fn into_owned(self) -> Self::Owned {
        self.into_owned()
    }
}

/// A JSON value. Unlike [`serde_json`]s `Value` type, this type can borrow from the input data
/// instead of always copying, reducing memory usage in multiple cases.
#[derive(Clone, PartialEq, Eq)]
pub enum Value<'a> {
    Null,
    Bool(bool),
    Number(Number),
    String(Cow<'a, str>),
    Array(Vec<Value<'a>>),
    Object(Object<'a>),
}

impl fmt::Debug for Value<'_> {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        match self {
            Self::Null => write!(f, "null"),
            Self::Bool(b) => b.fmt(f),
            Self::Number(n) => n.fmt(f),
            Self::String(s) => s.fmt(f),
            Self::Array(a) => a.fmt(f),
            Self::Object(o) => o.fmt(f),
        }
    }
}

impl Value<'_> {
    pub fn into_owned(self) -> Value<'static> {
        match self {
            Self::Null => Value::Null,
            Self::Bool(b) => Value::Bool(b),
            Self::Number(n) => Value::Number(n),
            Self::String(s) => Value::String(Cow::Owned(s.into_owned())),
            Self::Array(a) => Value::Array(a.into_iter().map(|v| v.into_owned()).collect()),
            Self::Object(o) => Value::Object(o.into_owned()),
        }
    }
}

impl ownable::traits::IntoOwned for Value<'_> {
    type Owned = Value<'static>;

    fn into_owned(self) -> Self::Owned {
        self.into_owned()
    }
}

impl<'a, 'de> serde::Deserialize<'de> for Value<'a>
where
    'de: 'a,
{
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        struct ValueVisitor;

        impl<'de> Visitor<'de> for ValueVisitor {
            type Value = Value<'de>;

            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
                formatter.write_str("any valid JSON value")
            }

            fn visit_bool<E>(self, value: bool) -> Result<Value<'de>, E> {
                Ok(Value::Bool(value))
            }

            fn visit_i64<E>(self, value: i64) -> Result<Value<'de>, E> {
                Ok(Value::Number(value.into()))
            }

            fn visit_i128<E>(self, value: i128) -> Result<Value<'de>, E>
            where
                E: serde::de::Error,
            {
                let de = serde::de::value::I128Deserializer::new(value);
                Number::deserialize(de).map(Value::Number)
            }

            fn visit_u64<E>(self, value: u64) -> Result<Value<'de>, E> {
                Ok(Value::Number(value.into()))
            }

            fn visit_u128<E>(self, value: u128) -> Result<Value<'de>, E>
            where
                E: serde::de::Error,
            {
                let de = serde::de::value::U128Deserializer::new(value);
                Number::deserialize(de).map(Value::Number)
            }

            fn visit_f64<E>(self, value: f64) -> Result<Value<'de>, E> {
                Ok(Number::from_f64(value).map_or(Value::Null, Value::Number))
            }

            fn visit_str<E>(self, value: &str) -> Result<Value<'de>, E>
            where
                E: serde::de::Error,
            {
                self.visit_string(String::from(value))
            }

            fn visit_borrowed_str<E>(self, value: &'de str) -> Result<Self::Value, E>
            where
                E: serde::de::Error,
            {
                Ok(Value::String(Cow::Borrowed(value)))
            }

            fn visit_string<E>(self, value: String) -> Result<Value<'de>, E> {
                Ok(Value::String(Cow::Owned(value)))
            }

            fn visit_none<E>(self) -> Result<Value<'de>, E> {
                Ok(Value::Null)
            }

            fn visit_some<D>(self, deserializer: D) -> Result<Value<'de>, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                Deserialize::deserialize(deserializer)
            }

            fn visit_unit<E>(self) -> Result<Value<'de>, E> {
                Ok(Value::Null)
            }

            fn visit_seq<V>(self, mut visitor: V) -> Result<Value<'de>, V::Error>
            where
                V: SeqAccess<'de>,
            {
                let mut vec = Vec::new();
                while let Some(elem) = visitor.next_element()? {
                    vec.push(elem);
                }

                Ok(Value::Array(vec))
            }

            fn visit_map<V>(self, mut visitor: V) -> Result<Value<'de>, V::Error>
            where
                V: MapAccess<'de>,
            {
                let mut values = BTreeMap::new();
                while let Some((key, value)) = visitor.next_entry()? {
                    values.insert(key, value);
                }

                Ok(Value::Object(Object(values)))
            }
        }

        deserializer.deserialize_any(ValueVisitor)
    }
}