use crate::error::Error;
use crate::lib::*;
use serde::de::value::BorrowedStrDeserializer;
use serde::de::{
self, Deserialize, DeserializeSeed, Deserializer, IntoDeserializer, MapAccess, Unexpected,
Visitor,
};
use serde::forward_to_deserialize_any;
use serde::ser::{Serialize, SerializeStruct, Serializer};
#[repr(C)]
pub struct RawValue {
json: str,
}
impl RawValue {
fn from_borrowed(json: &str) -> &Self {
unsafe { mem::transmute::<&str, &RawValue>(json) }
}
fn from_owned(json: Box<str>) -> Box<Self> {
unsafe { mem::transmute::<Box<str>, Box<RawValue>>(json) }
}
}
impl Clone for Box<RawValue> {
fn clone(&self) -> Self {
(**self).to_owned()
}
}
impl ToOwned for RawValue {
type Owned = Box<RawValue>;
fn to_owned(&self) -> Self::Owned {
RawValue::from_owned(self.json.to_owned().into_boxed_str())
}
}
impl Default for Box<RawValue> {
fn default() -> Self {
RawValue::from_borrowed("null").to_owned()
}
}
impl Debug for RawValue {
fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
formatter
.debug_tuple("RawValue")
.field(&format_args!("{}", &self.json))
.finish()
}
}
impl Display for RawValue {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.write_str(&self.json)
}
}
impl RawValue {
pub fn from_string(json: String) -> Result<Box<Self>, Error> {
{
let borrowed = crate::from_str::<&Self>(&json)?;
if borrowed.json.len() < json.len() {
return Ok(borrowed.to_owned());
}
}
Ok(Self::from_owned(json.into_boxed_str()))
}
pub fn get(&self) -> &str {
&self.json
}
}
pub fn to_raw_value<T>(value: &T) -> Result<Box<RawValue>, Error>
where
T: Serialize,
{
let json_string = crate::to_string(value)?;
Ok(RawValue::from_owned(json_string.into_boxed_str()))
}
pub const TOKEN: &str = "$serde_json::private::RawValue";
impl Serialize for RawValue {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
let mut s = serializer.serialize_struct(TOKEN, 1)?;
s.serialize_field(TOKEN, &self.json)?;
s.end()
}
}
impl<'de: 'a, 'a> Deserialize<'de> for &'a RawValue {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
struct ReferenceVisitor;
impl<'de> Visitor<'de> for ReferenceVisitor {
type Value = &'de RawValue;
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
write!(formatter, "any valid JSON value")
}
fn visit_map<V>(self, mut visitor: V) -> Result<Self::Value, V::Error>
where
V: MapAccess<'de>,
{
let value = visitor.next_key::<RawKey>()?;
if value.is_none() {
return Err(de::Error::invalid_type(Unexpected::Map, &self));
}
visitor.next_value_seed(ReferenceFromString)
}
}
deserializer.deserialize_newtype_struct(TOKEN, ReferenceVisitor)
}
}
impl<'de> Deserialize<'de> for Box<RawValue> {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
struct BoxedVisitor;
impl<'de> Visitor<'de> for BoxedVisitor {
type Value = Box<RawValue>;
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
write!(formatter, "any valid JSON value")
}
fn visit_map<V>(self, mut visitor: V) -> Result<Self::Value, V::Error>
where
V: MapAccess<'de>,
{
let value = visitor.next_key::<RawKey>()?;
if value.is_none() {
return Err(de::Error::invalid_type(Unexpected::Map, &self));
}
visitor.next_value_seed(BoxedFromString)
}
}
deserializer.deserialize_newtype_struct(TOKEN, BoxedVisitor)
}
}
struct RawKey;
impl<'de> Deserialize<'de> for RawKey {
fn deserialize<D>(deserializer: D) -> Result<RawKey, D::Error>
where
D: Deserializer<'de>,
{
struct FieldVisitor;
impl<'de> Visitor<'de> for FieldVisitor {
type Value = ();
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
formatter.write_str("raw value")
}
fn visit_str<E>(self, s: &str) -> Result<(), E>
where
E: de::Error,
{
if s == TOKEN {
Ok(())
} else {
Err(de::Error::custom("unexpected raw value"))
}
}
}
deserializer.deserialize_identifier(FieldVisitor)?;
Ok(RawKey)
}
}
pub struct ReferenceFromString;
impl<'de> DeserializeSeed<'de> for ReferenceFromString {
type Value = &'de RawValue;
fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
where
D: Deserializer<'de>,
{
deserializer.deserialize_str(self)
}
}
impl<'de> Visitor<'de> for ReferenceFromString {
type Value = &'de RawValue;
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
formatter.write_str("raw value")
}
fn visit_borrowed_str<E>(self, s: &'de str) -> Result<Self::Value, E>
where
E: de::Error,
{
Ok(RawValue::from_borrowed(s))
}
}
pub struct BoxedFromString;
impl<'de> DeserializeSeed<'de> for BoxedFromString {
type Value = Box<RawValue>;
fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
where
D: Deserializer<'de>,
{
deserializer.deserialize_str(self)
}
}
impl<'de> Visitor<'de> for BoxedFromString {
type Value = Box<RawValue>;
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
formatter.write_str("raw value")
}
fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
where
E: de::Error,
{
self.visit_string(s.to_owned())
}
fn visit_string<E>(self, s: String) -> Result<Self::Value, E>
where
E: de::Error,
{
Ok(RawValue::from_owned(s.into_boxed_str()))
}
}
struct RawKeyDeserializer;
impl<'de> Deserializer<'de> for RawKeyDeserializer {
type Error = Error;
fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
where
V: de::Visitor<'de>,
{
visitor.visit_borrowed_str(TOKEN)
}
forward_to_deserialize_any! {
bool u8 u16 u32 u64 u128 i8 i16 i32 i64 i128 f32 f64 char str string seq
bytes byte_buf map struct option unit newtype_struct ignored_any
unit_struct tuple_struct tuple enum identifier
}
}
pub struct OwnedRawDeserializer {
pub raw_value: Option<String>,
}
impl<'de> MapAccess<'de> for OwnedRawDeserializer {
type Error = Error;
fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Error>
where
K: de::DeserializeSeed<'de>,
{
if self.raw_value.is_none() {
return Ok(None);
}
seed.deserialize(RawKeyDeserializer).map(Some)
}
fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Error>
where
V: de::DeserializeSeed<'de>,
{
seed.deserialize(self.raw_value.take().unwrap().into_deserializer())
}
}
pub struct BorrowedRawDeserializer<'de> {
pub raw_value: Option<&'de str>,
}
impl<'de> MapAccess<'de> for BorrowedRawDeserializer<'de> {
type Error = Error;
fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Error>
where
K: de::DeserializeSeed<'de>,
{
if self.raw_value.is_none() {
return Ok(None);
}
seed.deserialize(RawKeyDeserializer).map(Some)
}
fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Error>
where
V: de::DeserializeSeed<'de>,
{
seed.deserialize(BorrowedStrDeserializer::new(self.raw_value.take().unwrap()))
}
}