use std::borrow::Cow;
use serde::{
ser::{Error, Impossible, StdError},
Serialize, Serializer,
};
use crate::ser::SourceError;
#[derive(Debug, Serialize)]
#[serde(untagged)]
pub enum StringLike {
Empty,
Bool(bool),
I8(i8),
I16(i16),
I32(i32),
I64(i64),
U8(u8),
U16(u16),
U32(u32),
U64(u64),
F32(f32),
F64(f64),
Char(char),
String(String),
Ident(&'static str),
}
impl From<StringLike> for Cow<'static, str> {
fn from(source: StringLike) -> Self {
match source {
StringLike::String(string) => Cow::Owned(string),
StringLike::Ident(ident) => Cow::Borrowed(ident),
_ => Cow::Owned(source.to_string()),
}
}
}
impl std::fmt::Display for StringLike {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Self::Empty => Ok(()),
Self::Bool(v) => write!(f, "{v}"),
Self::I8(v) => write!(f, "{v}"),
Self::I16(v) => write!(f, "{v}"),
Self::I32(v) => write!(f, "{v}"),
Self::I64(v) => write!(f, "{v}"),
Self::U8(v) => write!(f, "{v}"),
Self::U16(v) => write!(f, "{v}"),
Self::U32(v) => write!(f, "{v}"),
Self::U64(v) => write!(f, "{v}"),
Self::F32(v) => write!(f, "{v}"),
Self::F64(v) => write!(f, "{v}"),
Self::Char(v) => write!(f, "{v}"),
Self::String(v) => write!(f, "{v}"),
Self::Ident(v) => write!(f, "{v}"),
}
}
}
pub struct Stringifier;
impl Serializer for Stringifier {
type Ok = StringLike;
type Error = StringifyError;
type SerializeSeq = Impossible<Self::Ok, Self::Error>;
type SerializeTuple = Impossible<Self::Ok, Self::Error>;
type SerializeTupleStruct = Impossible<Self::Ok, Self::Error>;
type SerializeTupleVariant = Impossible<Self::Ok, Self::Error>;
type SerializeMap = Impossible<Self::Ok, Self::Error>;
type SerializeStruct = Impossible<Self::Ok, Self::Error>;
type SerializeStructVariant = Impossible<Self::Ok, Self::Error>;
fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error> {
Ok(StringLike::Bool(v))
}
fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error> {
Ok(StringLike::I8(v))
}
fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error> {
Ok(StringLike::I16(v))
}
fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error> {
Ok(StringLike::I32(v))
}
fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> {
Ok(StringLike::I64(v))
}
fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> {
Ok(StringLike::U8(v))
}
fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error> {
Ok(StringLike::U16(v))
}
fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error> {
Ok(StringLike::U32(v))
}
fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error> {
Ok(StringLike::U64(v))
}
fn serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error> {
Ok(StringLike::F32(v))
}
fn serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error> {
Ok(StringLike::F64(v))
}
fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error> {
Ok(StringLike::Char(v))
}
fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {
Ok(StringLike::String(v.to_owned()))
}
fn serialize_bytes(self, _v: &[u8]) -> Result<Self::Ok, Self::Error> {
Err(StringifyError::Nested)
}
fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
Err(StringifyError::Empty)
}
fn serialize_some<T: ?Sized + Serialize>(self, value: &T) -> Result<Self::Ok, Self::Error> {
value.serialize(self)
}
fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
Err(StringifyError::Empty)
}
fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> {
Err(StringifyError::Empty)
}
fn serialize_unit_variant(
self,
_name: &'static str,
_variant_index: u32,
variant: &'static str,
) -> Result<Self::Ok, Self::Error> {
Ok(StringLike::Ident(variant))
}
fn serialize_newtype_struct<T: ?Sized + Serialize>(
self,
_name: &'static str,
value: &T,
) -> Result<Self::Ok, Self::Error> {
value.serialize(self)
}
fn serialize_newtype_variant<T: ?Sized + Serialize>(
self,
_name: &'static str,
_variant_index: u32,
_variant: &'static str,
_value: &T,
) -> Result<Self::Ok, Self::Error> {
Err(StringifyError::Nested)
}
fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
Err(StringifyError::Nested)
}
fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, Self::Error> {
Err(StringifyError::Nested)
}
fn serialize_tuple_struct(
self,
_name: &'static str,
_len: usize,
) -> Result<Self::SerializeTupleStruct, Self::Error> {
Err(StringifyError::Nested)
}
fn serialize_tuple_variant(
self,
_name: &'static str,
_variant_index: u32,
_variant: &'static str,
_len: usize,
) -> Result<Self::SerializeTupleVariant, Self::Error> {
Err(StringifyError::Nested)
}
fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
Err(StringifyError::Nested)
}
fn serialize_struct(
self,
_name: &'static str,
_len: usize,
) -> Result<Self::SerializeStruct, Self::Error> {
Err(StringifyError::Nested)
}
fn serialize_struct_variant(
self,
_name: &'static str,
_variant_index: u32,
_variant: &'static str,
_len: usize,
) -> Result<Self::SerializeStructVariant, Self::Error> {
Err(StringifyError::Nested)
}
}
#[derive(Debug)]
pub enum StringifyError {
Empty,
Nested,
Source(SourceError),
}
impl std::fmt::Display for StringifyError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Self::Empty => f.write_str("means empty"),
Self::Nested => f.write_str("nested hierarchy"),
Self::Source(_) => f.write_str("upstream serialize impl caused"),
}
}
}
impl StdError for StringifyError {
fn source(&self) -> Option<&(dyn StdError + 'static)> {
match self {
Self::Source(e) => Some(e),
_ => None,
}
}
}
impl Error for StringifyError {
fn custom<T: std::fmt::Display>(msg: T) -> Self {
Self::Source(msg.to_string().into())
}
}