192 lines
3.9 KiB
Rust
192 lines
3.9 KiB
Rust
mod real;
|
|
|
|
use core::marker::PhantomData;
|
|
|
|
use super::{
|
|
Write,
|
|
Serialize,
|
|
Serializer
|
|
};
|
|
|
|
use self::real::{
|
|
RealSerializer,
|
|
PrimitiveRealSerializer,
|
|
FastRealSerializer
|
|
};
|
|
|
|
use crate::grammar::*;
|
|
|
|
pub trait Config {
|
|
type RealSerializer: RealSerializer;
|
|
}
|
|
|
|
pub struct DefaultConfig {}
|
|
|
|
impl Config for DefaultConfig {
|
|
type RealSerializer = FastRealSerializer;
|
|
}
|
|
|
|
pub struct BaseSerializer<C: Config, W: Write> {
|
|
out: W,
|
|
cfg: PhantomData<C>
|
|
}
|
|
|
|
impl<C, W> BaseSerializer<C, W>
|
|
where
|
|
C: Config,
|
|
W: Write
|
|
{
|
|
pub fn new(out: W) -> Self {
|
|
Self { out, cfg: PhantomData }
|
|
}
|
|
|
|
pub fn into_inner(self) -> W {
|
|
self.out
|
|
}
|
|
|
|
#[inline]
|
|
pub fn serialize_real<R>(&mut self, r: R) -> Result<(), W::Error>
|
|
where
|
|
C::RealSerializer: PrimitiveRealSerializer<R>
|
|
{
|
|
C::RealSerializer::serialize_real::<W>(&mut self.out, r)
|
|
}
|
|
|
|
#[inline]
|
|
fn write_delim(&mut self, delim: u8) -> Result<(), W::Error> {
|
|
self.out.write(&[delim])
|
|
}
|
|
|
|
#[inline]
|
|
fn write_utf8(&mut self, s: &str) -> Result<(), W::Error> {
|
|
self.out.write(s.as_bytes())
|
|
}
|
|
}
|
|
|
|
impl<C: Config, W: Write> Serializer for &mut BaseSerializer<C, W> {
|
|
type Error = W::Error;
|
|
|
|
#[inline]
|
|
fn serialize_real_u8(self, real: u8) -> Result<(), Self::Error> {
|
|
self.serialize_real::<u8>(real)
|
|
}
|
|
|
|
#[inline]
|
|
fn serialize_real_u16(self, real: u16) -> Result<(), Self::Error> {
|
|
self.serialize_real::<u16>(real)
|
|
}
|
|
|
|
#[inline]
|
|
fn serialize_real_u32(self, real: u32) -> Result<(), Self::Error> {
|
|
self.serialize_real::<u32>(real)
|
|
}
|
|
|
|
#[inline]
|
|
fn serialize_real_u64(self, real: u64) -> Result<(), Self::Error> {
|
|
self.serialize_real::<u64>(real)
|
|
}
|
|
|
|
#[inline]
|
|
fn serialize_real_i8(self, real: i8) -> Result<(), Self::Error> {
|
|
self.serialize_real::<i8>(real)
|
|
}
|
|
|
|
#[inline]
|
|
fn serialize_real_i16(self, real: i16) -> Result<(), Self::Error> {
|
|
self.serialize_real::<i16>(real)
|
|
}
|
|
|
|
#[inline]
|
|
fn serialize_real_i32(self, real: i32) -> Result<(), Self::Error> {
|
|
self.serialize_real::<i32>(real)
|
|
}
|
|
|
|
#[inline]
|
|
fn serialize_real_i64(self, real: i64) -> Result<(), Self::Error> {
|
|
self.serialize_real::<i64>(real)
|
|
}
|
|
|
|
#[inline]
|
|
fn serialize_real_f32(self, real: f32) -> Result<(), Self::Error> {
|
|
self.serialize_real::<f32>(real)
|
|
}
|
|
|
|
#[inline]
|
|
fn serialize_real_f64(self, real: f64) -> Result<(), Self::Error> {
|
|
self.serialize_real::<f64>(real)
|
|
}
|
|
|
|
#[inline]
|
|
fn serialize_unit<'a, V>(self, name: &'a str, value: V) -> Result<(), Self::Error>
|
|
where V: Serialize
|
|
{
|
|
self.serialize_atom(name)?;
|
|
self.write_delim(GRAMMAR_PAREN_OPEN)?;
|
|
self.serialize_any(value)?;
|
|
self.write_delim(GRAMMAR_PAREN_CLOSE)
|
|
}
|
|
|
|
#[inline]
|
|
fn serialize_atom<'a>(self, atom: &'a str) -> Result<(), Self::Error> {
|
|
self.write_utf8(atom)
|
|
}
|
|
|
|
#[inline]
|
|
fn serialize_text<'a>(self, text: &'a str) -> Result<(), Self::Error> {
|
|
self.write_delim(GRAMMAR_QUOTE)?;
|
|
self.write_utf8(text)?;
|
|
self.write_delim(GRAMMAR_QUOTE)
|
|
}
|
|
|
|
#[inline]
|
|
fn serialize_multiline_text<'a, M>(self, lines: M) -> Result<(), Self::Error>
|
|
where M: IntoIterator<Item = &'a str>
|
|
{
|
|
self.write_delim(GRAMMAR_BTICK)?;
|
|
for line in lines.into_iter() {
|
|
self.serialize_text(line)?;
|
|
}
|
|
self.write_delim(GRAMMAR_BTICK)
|
|
}
|
|
|
|
#[inline]
|
|
fn serialize_dict<K, V, D>(self, dict: D) -> Result<(), Self::Error>
|
|
where
|
|
K: Serialize,
|
|
V: Serialize,
|
|
D: IntoIterator<Item = (K, V)>
|
|
{
|
|
self.write_delim(GRAMMAR_BRACE_OPEN)?;
|
|
let mut first = true;
|
|
for (k, v) in dict.into_iter() {
|
|
if first {
|
|
first = false;
|
|
} else {
|
|
self.write_delim(GRAMMAR_COMMA)?;
|
|
}
|
|
self.serialize_any(&k)?;
|
|
self.write_delim(GRAMMAR_COLON)?;
|
|
self.serialize_any(&v)?;
|
|
}
|
|
self.write_delim(GRAMMAR_BRACE_CLOSE)
|
|
}
|
|
|
|
#[inline]
|
|
fn serialize_list<T, L>(self, list: L) -> Result<(), Self::Error>
|
|
where
|
|
T: Serialize,
|
|
L: IntoIterator<Item = T>
|
|
{
|
|
self.write_delim(GRAMMAR_BRKET_OPEN)?;
|
|
let mut first = true;
|
|
for v in list.into_iter() {
|
|
if first {
|
|
first = false;
|
|
} else {
|
|
self.write_delim(GRAMMAR_COMMA)?;
|
|
}
|
|
self.serialize_any(&v)?;
|
|
}
|
|
self.write_delim(GRAMMAR_BRKET_CLOSE)
|
|
}
|
|
} |