From 60f5a8e05a1732a29c1dae2c82722fbb95b46755 Mon Sep 17 00:00:00 2001 From: avitex Date: Tue, 22 Jan 2019 17:04:44 +1100 Subject: [PATCH] Start playing around with real serialization --- sehn/TODO.md | 4 ++- sehn/src/se/base/mod.rs | 72 ++++++++++++++++++++++++++++++++------- sehn/src/se/mod.rs | 18 ++++++++++ sehn/src/se/pretty/mod.rs | 66 +++++++++++++++++++++++++++++++++++ 4 files changed, 146 insertions(+), 14 deletions(-) create mode 100644 sehn/src/se/pretty/mod.rs diff --git a/sehn/TODO.md b/sehn/TODO.md index c4cb4b3..88a29e4 100644 --- a/sehn/TODO.md +++ b/sehn/TODO.md @@ -1,3 +1,5 @@ # TODO -- text and atom escaping \ No newline at end of file +- tests +- text and atom escaping +- documentation \ No newline at end of file diff --git a/sehn/src/se/base/mod.rs b/sehn/src/se/base/mod.rs index d11e8a7..f667a92 100644 --- a/sehn/src/se/base/mod.rs +++ b/sehn/src/se/base/mod.rs @@ -10,7 +10,9 @@ use super::{ Serializer, SerializeDict, SerializeList, - SerializeMultilineText + SerializeMultilineText, + SerializeReal, + SerializeRealPrimitive }; use self::real::{ @@ -85,13 +87,13 @@ where } #[inline] - fn write_delim(&mut self, delim: u8) -> Result<(), W::Error> { - unsafe { self.out.write_delim_unchecked(delim) } + fn write_delim(&mut self, delim: u8) -> Result<(), SerializerError> { + unsafe { Ok(self.out.write_delim_unchecked(delim)?) } } #[inline] - fn write_utf8(&mut self, slice: &[u8]) -> Result<(), W::Error> { - unsafe { self.out.write_utf8_unchecked(slice) } + fn write_utf8(&mut self, slice: &[u8]) -> Result<(), SerializerError> { + unsafe { Ok(self.out.write_utf8_unchecked(slice)?) } } } @@ -102,9 +104,11 @@ where { type Error = SerializerError; + type SerializeReal = SerializeRealBase<'se, C, W>; type SerializeDict = SerializeDictBase<'se, C, W>; type SerializeList = SerializeListBase<'se, C, W>; type SerializeMultilineText = SerializeMultilineTextBase<'se, C, W>; + #[inline] fn serialize_real_u8(self, real: u8) -> Result<(), Self::Error> { @@ -163,19 +167,19 @@ where self.serialize_atom(name)?; self.write_delim(GRAMMAR_PAREN_OPEN)?; self.serialize_any(value)?; - Ok(self.write_delim(GRAMMAR_PAREN_CLOSE)?) + self.write_delim(GRAMMAR_PAREN_CLOSE) } #[inline] fn serialize_atom<'a>(self, atom: &'a str) -> Result<(), Self::Error> { - Ok(self.write_utf8(atom.as_bytes())?) + self.write_utf8(atom.as_bytes()) } #[inline] fn serialize_text<'a>(self, text: &'a str) -> Result<(), Self::Error> { self.write_delim(GRAMMAR_QUOTE)?; self.write_utf8(text.as_bytes())?; - Ok(self.write_delim(GRAMMAR_QUOTE)?) + self.write_delim(GRAMMAR_QUOTE) } #[inline] @@ -255,7 +259,7 @@ where for item in list.into_iter() { state.serialize_item(item)?; } - Ok(state.end()?) + state.end() } } @@ -280,7 +284,7 @@ where #[inline] fn end(self) -> Result<(), Self::Error> { - Ok(self.ser.write_delim(GRAMMAR_BRACE_CLOSE)?) + self.ser.write_delim(GRAMMAR_BRACE_CLOSE) } } @@ -349,7 +353,7 @@ where #[inline] fn end(self) -> Result<(), Self::Error> { - Ok(self.ser.write_delim(GRAMMAR_BRACE_CLOSE)?) + self.ser.write_delim(GRAMMAR_BRACE_CLOSE) } } @@ -403,6 +407,48 @@ where #[inline] fn end(self) -> Result<(), Self::Error> { - Ok(self.ser.write_delim(GRAMMAR_BTICK)?) + self.ser.write_delim(GRAMMAR_BTICK) } -} \ No newline at end of file +} + +/////////////////////////////////////////////////////////////////////////////// + +pub struct SerializeRealBase<'se, C, W> +where + C: Config, + W: Write +{ + ser: &'se mut BaseSerializer +} + +impl<'se, C, W> SerializeRealBase<'se, C, W> +where + C: Config, + W: Write +{ + #[inline] + fn new(ser: &'se mut BaseSerializer) -> Result> { + Ok(Self { + ser + }) + } +} + +impl<'se, C, W> SerializeRealPrimitive for SerializeRealBase<'se, C, W> +where + C: Config, + W: Write +{ + type Error = SerializerError; + + fn serialize_real_primitive(self, real: u8) -> Result<(), Self::Error> { + self.ser.write_utf8(real.to_string().as_bytes()) + } +} + +impl<'se, C, W> SerializeReal for SerializeRealBase<'se, C, W> +where + C: Config, + W: Write +{} + diff --git a/sehn/src/se/mod.rs b/sehn/src/se/mod.rs index e182721..7f667cd 100644 --- a/sehn/src/se/mod.rs +++ b/sehn/src/se/mod.rs @@ -8,6 +8,15 @@ pub trait Serialize { where S: Serializer; } +pub trait SerializeRealPrimitive { + type Error; + + fn serialize_real_primitive(self, real: R) -> Result<(), Self::Error>; +} + +pub trait SerializeReal: SerializeRealPrimitive { +} + pub trait SerializeDict { type Error; @@ -39,6 +48,7 @@ pub trait SerializeMultilineText { pub trait Serializer: Sized { type Error; + type SerializeReal: SerializeReal; type SerializeDict: SerializeDict; type SerializeList: SerializeList; type SerializeMultilineText: SerializeMultilineText; @@ -50,6 +60,14 @@ pub trait Serializer: Sized { any.serialize(self) } + fn serialize_real(self, r: R) -> Result<(), Self::Error> + where Self::SerializeReal: SerializeRealPrimitive + { + Self::SerializeReal::serialize_real_primitive(r) + //Ok(C::RealSerializer::serialize_real::(&mut self.out, r)?) + //Ok(()) + } + fn serialize_real_u8(self, real: u8) -> Result<(), Self::Error>; fn serialize_real_u16(self, real: u16) -> Result<(), Self::Error>; fn serialize_real_u32(self, real: u32) -> Result<(), Self::Error>; diff --git a/sehn/src/se/pretty/mod.rs b/sehn/src/se/pretty/mod.rs new file mode 100644 index 0000000..de4cac8 --- /dev/null +++ b/sehn/src/se/pretty/mod.rs @@ -0,0 +1,66 @@ +use super::base::*; + +impl Serializer for PrettySerializer { + type Error; + + type SerializeDict: SerializeDictBase; + type SerializeList: SerializeListBase; + type SerializeMultilineText: SerializeMultilineTextBase; + + #[inline] + fn serialize_real_u8(self, real: u8) -> Result<(), Self::Error> { + self.base.serialize_real_u8(real) + } + fn serialize_real_u16(self, real: u16) -> Result<(), Self::Error> { + self.base.serialize_real_u8(real) + } + fn serialize_real_u32(self, real: u32) -> Result<(), Self::Error> { + self.base.serialize_real_u8(real) + } + fn serialize_real_u64(self, real: u64) -> Result<(), Self::Error> { + self.base.serialize_real_u8(real) + } + + fn serialize_real_i8(self, real: i8) -> Result<(), Self::Error> { + self.base.serialize_real_u8(real) + } + fn serialize_real_i16(self, real: i16) -> Result<(), Self::Error> { + self.base.serialize_real_u8(real) + } + fn serialize_real_i32(self, real: i32) -> Result<(), Self::Error> { + self.base.serialize_real_u8(real) + } + fn serialize_real_i64(self, real: i64) -> Result<(), Self::Error> { + self.base.serialize_real_i64(real) + } + fn serialize_real_f32(self, real: f32) -> Result<(), Self::Error> { + self.base.serialize_real_f32(real) + } + fn serialize_real_f64(self, real: f64) -> Result<(), Self::Error> { + self.base.serialize_real_f64(real) + } + + fn serialize_atom<'a>(self, atom: &'a str) -> Result<(), Self::Error>; + fn serialize_text<'a>(self, text: &'a str) -> Result<(), Self::Error>; + + fn serialize_multiline_text<'a, M>(self, lines: M) -> Result<(), Self::Error> + where M: IntoIterator; + + fn serialize_unit<'a, V>(self, name: &'a str, value: V) -> Result<(), Self::Error> + where V: Serialize; + + fn serialize_list_parts(self) -> Result; + fn serialize_dict_parts(self) -> Result; + fn serialize_multiline_text_parts(self) -> Result; + + fn serialize_list(self, list: L) -> Result<(), Self::Error> + where + V: Serialize, + L: IntoIterator; + + fn serialize_dict(self, dict: D) -> Result<(), Self::Error> + where + K: Serialize, + V: Serialize, + D: IntoIterator; +}