use core::marker::PhantomData;
use serde::de::{DeserializeSeed, Deserializer};
use serde::{Deserialize, Serialize, Serializer};
#[doc(hidden)]
#[derive(Debug, thiserror::Error)]
#[non_exhaustive]
pub enum ViewJsonErrorReason {
#[error("protobuf JSON serialization of this view is disabled")]
Denied,
}
pub trait ProtoBytesJson: crate::ProtoBytes {
fn serialize_json<S: Serializer>(bytes: &[u8], serializer: S) -> Result<S::Ok, S::Error>;
fn deserialize_json<'de, D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>;
}
pub trait ProtoStringJson: crate::ProtoString {
fn serialize_json<S: Serializer>(text: &str, serializer: S) -> Result<S::Ok, S::Error>;
fn deserialize_json<'de, D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>;
}
macro_rules! policy_plumbing {
(
trait: $trait:ident,
borrowed: $borrowed:ty,
owned: $owned:ident,
singular: $singular:ident,
optional: $optional:ident,
adapter: $adapter:ident,
seq_adapter: $seq_adapter:ident,
seed: $seed:ident,
$(,)?
) => {
struct $owned<T>(T);
impl<'de, T: $trait> Deserialize<'de> for $owned<T> {
fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
T::deserialize_json(d).map($owned)
}
}
#[doc(hidden)]
pub mod $singular {
use super::$trait;
use serde::{Deserializer, Serializer};
pub fn serialize<T: $trait, S: Serializer>(value: &T, s: S) -> Result<S::Ok, S::Error> {
T::serialize_json(value.as_ref(), s)
}
pub fn deserialize<'de, T: $trait, D: Deserializer<'de>>(d: D) -> Result<T, D::Error> {
<Option<super::$owned<T>> as serde::Deserialize>::deserialize(d)
.map(|value| value.map(|owned| owned.0).unwrap_or_default())
}
}
#[doc(hidden)]
pub mod $optional {
use super::$trait;
use serde::{Deserializer, Serializer};
pub fn serialize<T: $trait, S: Serializer>(
value: &Option<T>,
s: S,
) -> Result<S::Ok, S::Error> {
match value {
Some(v) => T::serialize_json(v.as_ref(), s),
None => s.serialize_none(),
}
}
pub fn deserialize<'de, T: $trait, D: Deserializer<'de>>(
d: D,
) -> Result<Option<T>, D::Error> {
<Option<super::$owned<T>> as serde::Deserialize>::deserialize(d)
.map(|value| value.map(|owned| owned.0))
}
}
#[doc(hidden)]
pub struct $adapter<'a, T: ?Sized>(&'a $borrowed, PhantomData<fn() -> T>);
impl<'a, T: $trait> $adapter<'a, T> {
pub fn new(value: &'a $borrowed) -> Self {
Self(value, PhantomData)
}
}
impl<T: $trait> Serialize for $adapter<'_, T> {
fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
T::serialize_json(self.0, s)
}
}
#[doc(hidden)]
pub struct $seq_adapter<'a, T: ?Sized>(&'a [&'a $borrowed], PhantomData<fn() -> T>);
impl<'a, T: $trait> $seq_adapter<'a, T> {
pub fn new(elements: &'a [&'a $borrowed]) -> Self {
Self(elements, PhantomData)
}
}
impl<T: $trait> Serialize for $seq_adapter<'_, T> {
fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeSeq as _;
let mut seq = s.serialize_seq(Some(self.0.len()))?;
for element in self.0 {
seq.serialize_element(&$adapter::<T>::new(element))?;
}
seq.end()
}
}
#[doc(hidden)]
pub struct $seed<T>(PhantomData<fn() -> T>);
impl<T> $seed<T> {
pub fn new() -> Self {
Self(PhantomData)
}
}
impl<T> Default for $seed<T> {
fn default() -> Self {
Self::new()
}
}
impl<'de, T: $trait> DeserializeSeed<'de> for $seed<T> {
type Value = T;
fn deserialize<D: Deserializer<'de>>(self, d: D) -> Result<T, D::Error> {
T::deserialize_json(d)
}
}
};
}
policy_plumbing! {
trait: ProtoBytesJson,
borrowed: [u8],
owned: OwnedBytes,
singular: bytes_policy,
optional: opt_bytes_policy,
adapter: BytesPolicyJson,
seq_adapter: BytesPolicySeqJson,
seed: BytesPolicySeed,
}
policy_plumbing! {
trait: ProtoStringJson,
borrowed: str,
owned: OwnedString,
singular: string_policy,
optional: opt_string_policy,
adapter: StringPolicyJson,
seq_adapter: StringPolicySeqJson,
seed: StringPolicySeed,
}
#[doc(hidden)]
pub mod policy_str_key_map {
use super::{ProtoStringJson, StringPolicyJson, StringPolicySeed};
use crate::json_helpers::{ProtoElemJson, ProtoElemSeed, ProtoJson};
use crate::map_codec::MapStorage;
use serde::{Deserializer, Serializer};
pub fn serialize<C, S>(m: &C, s: S) -> Result<S::Ok, S::Error>
where
C: MapStorage,
C::Key: ProtoStringJson,
C::Value: ProtoElemJson,
S: Serializer,
{
use serde::ser::SerializeMap;
let mut map = s.serialize_map(Some(m.storage_len()))?;
for (k, v) in m.storage_iter() {
map.serialize_entry(&StringPolicyJson::<C::Key>::new(k.as_ref()), &ProtoJson(v))?;
}
map.end()
}
pub fn deserialize<'de, C, D>(d: D) -> Result<C, D::Error>
where
C: MapStorage + Default,
C::Key: ProtoStringJson,
C::Value: ProtoElemJson,
D: Deserializer<'de>,
{
struct Vis<C>(core::marker::PhantomData<C>);
impl<'de, C> serde::de::Visitor<'de> for Vis<C>
where
C: MapStorage + Default,
C::Key: ProtoStringJson,
C::Value: ProtoElemJson,
{
type Value = C;
fn expecting(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
f.write_str("a JSON object with string keys, or null")
}
fn visit_unit<E>(self) -> Result<Self::Value, E> {
Ok(C::default())
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
mut map: A,
) -> Result<Self::Value, A::Error> {
let mut out = C::default();
while let Some(k) = map.next_key_seed(StringPolicySeed::<C::Key>::new())? {
let k = crate::erasing::Erasing::new(k, C::storage_erase_key);
let v =
map.next_value_seed(ProtoElemSeed::<C::Value>(core::marker::PhantomData))?;
out.storage_insert(k.into_inner(), v);
}
Ok(out)
}
}
d.deserialize_any(Vis::<C>(core::marker::PhantomData))
}
}
#[cfg(test)]
mod tests;