use serde::{Deserialize, Serialize, de};
use std::fmt::{self, Display, Formatter};
use std::str::{self, Utf8Error};
#[derive(Clone, Debug, PartialEq)]
#[doc(hidden)]
pub struct Raw {
s: Result<String, (Vec<u8>, Utf8Error)>,
}
impl Raw {
#[inline]
pub fn new(v: String) -> Self {
Self { s: Ok(v) }
}
#[inline]
pub fn is_str(&self) -> bool {
self.s.is_ok()
}
#[inline]
pub fn is_err(&self) -> bool {
self.s.is_err()
}
#[inline]
pub fn as_str(&self) -> Option<&str> {
match self.s {
Ok(ref s) => Some(s.as_str()),
Err(..) => None,
}
}
#[inline]
pub fn as_err(&self) -> Option<&Utf8Error> {
match self.s {
Ok(..) => None,
Err((_, ref err)) => Some(err),
}
}
#[inline]
pub fn as_bytes(&self) -> &[u8] {
match self.s {
Ok(ref s) => s.as_bytes(),
Err(ref err) => &err.0[..],
}
}
#[inline]
pub fn into_str(self) -> Option<String> {
self.s.ok()
}
#[inline]
pub fn into_bytes(self) -> Vec<u8> {
match self.s {
Ok(s) => s.into_bytes(),
Err(err) => err.0,
}
}
}
impl Serialize for Raw {
fn serialize<S>(&self, se: S) -> Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
match self.s {
Ok(ref s) => se.serialize_str(s),
Err((ref b, ..)) => se.serialize_bytes(b),
}
}
}
struct RawVisitor;
impl de::Visitor<'_> for RawVisitor {
type Value = Raw;
#[cold]
fn expecting(&self, fmt: &mut Formatter<'_>) -> Result<(), fmt::Error> {
"string or bytes".fmt(fmt)
}
#[inline]
fn visit_string<E>(self, v: String) -> Result<Self::Value, E> {
Ok(Raw { s: Ok(v) })
}
#[inline]
fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
where
E: de::Error,
{
Ok(Raw { s: Ok(v.into()) })
}
#[inline]
fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
where
E: de::Error,
{
let s = match str::from_utf8(v) {
Ok(s) => Ok(s.into()),
Err(err) => Err((v.into(), err)),
};
Ok(Raw { s })
}
#[inline]
fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
where
E: de::Error,
{
let s = match String::from_utf8(v) {
Ok(s) => Ok(s),
Err(err) => {
let e = err.utf8_error();
Err((err.into_bytes(), e))
}
};
Ok(Raw { s })
}
}
impl<'de> Deserialize<'de> for Raw {
#[inline]
fn deserialize<D>(de: D) -> Result<Self, D::Error>
where
D: de::Deserializer<'de>,
{
de.deserialize_any(RawVisitor)
}
}
#[derive(Clone, Copy, Debug, PartialEq)]
#[doc(hidden)]
pub struct RawRef<'a> {
s: Result<&'a str, (&'a [u8], Utf8Error)>,
}
impl<'a> RawRef<'a> {
#[inline]
pub fn new(v: &'a str) -> Self {
Self { s: Ok(v) }
}
#[inline]
pub fn is_str(&self) -> bool {
self.s.is_ok()
}
#[inline]
pub fn is_err(&self) -> bool {
self.s.is_err()
}
#[inline]
pub fn as_str(&self) -> Option<&str> {
self.s.ok()
}
#[inline]
pub fn as_err(&self) -> Option<&Utf8Error> {
match self.s {
Ok(..) => None,
Err((_, ref err)) => Some(err),
}
}
#[inline]
pub fn as_bytes(&self) -> &[u8] {
match self.s {
Ok(s) => s.as_bytes(),
Err((bytes, _err)) => bytes,
}
}
}
impl Serialize for RawRef<'_> {
fn serialize<S>(&self, se: S) -> Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
match self.s {
Ok(s) => se.serialize_str(s),
Err((b, ..)) => se.serialize_bytes(b),
}
}
}
struct RawRefVisitor;
impl<'de> de::Visitor<'de> for RawRefVisitor {
type Value = RawRef<'de>;
#[cold]
fn expecting(&self, fmt: &mut Formatter<'_>) -> Result<(), fmt::Error> {
"string or bytes".fmt(fmt)
}
#[inline]
fn visit_borrowed_str<E>(self, v: &'de str) -> Result<Self::Value, E>
where
E: de::Error,
{
Ok(RawRef { s: Ok(v) })
}
#[inline]
fn visit_borrowed_bytes<E>(self, v: &'de [u8]) -> Result<Self::Value, E>
where
E: de::Error,
{
let s = match str::from_utf8(v) {
Ok(s) => Ok(s),
Err(err) => Err((v, err)),
};
Ok(RawRef { s })
}
}
impl<'de> Deserialize<'de> for RawRef<'de> {
#[inline]
fn deserialize<D>(de: D) -> Result<Self, D::Error>
where
D: de::Deserializer<'de>,
{
de.deserialize_any(RawRefVisitor)
}
}