From 450b73a4d29b954576dcd81ac6e12557a800dcc9 Mon Sep 17 00:00:00 2001 From: Tony Garnock-Jones Date: Mon, 25 May 2020 16:12:41 +0200 Subject: [PATCH] More error cleanup --- implementations/rust/src/lib.rs | 2 +- implementations/rust/src/value/de.rs | 58 ++++++++- implementations/rust/src/value/error.rs | 51 -------- implementations/rust/src/value/mod.rs | 1 - implementations/rust/src/value/ser.rs | 149 +++++++++++++----------- 5 files changed, 140 insertions(+), 121 deletions(-) delete mode 100644 implementations/rust/src/value/error.rs diff --git a/implementations/rust/src/lib.rs b/implementations/rust/src/lib.rs index f9afe0c..310802a 100644 --- a/implementations/rust/src/lib.rs +++ b/implementations/rust/src/lib.rs @@ -392,7 +392,7 @@ mod samples_tests { 12345, Value::from("hi").wrap()); println!("== v: {:#?}", v); - let w: PlainValue = to_value(&v).unwrap(); + let w: PlainValue = to_value(&v); println!("== w: {:#?}", w); let x = from_value(&w).unwrap(); println!("== x: {:#?}", &x); diff --git a/implementations/rust/src/value/de.rs b/implementations/rust/src/value/de.rs index 4801ac9..7c8de0e 100644 --- a/implementations/rust/src/value/de.rs +++ b/implementations/rust/src/value/de.rs @@ -1,6 +1,5 @@ use crate::value::{Value, NestedValue, Map, Domain}; use crate::value::value::{Float, Double}; -use crate::value::error::{Error, Result, ExpectedKind}; use num::traits::cast::ToPrimitive; use serde::Deserialize; use serde::de::{Visitor, SeqAccess, MapAccess, EnumAccess, VariantAccess, DeserializeSeed}; @@ -8,6 +7,63 @@ use std::convert::TryFrom; use std::iter::Iterator; use std::marker::PhantomData; +pub mod error { + use num::bigint::BigInt; + use crate::value::{PlainValue, Domain}; + + #[derive(Debug)] + pub enum Error { + Message(String), + InvalidUnicodeScalar(u32), + NumberTooLarge(BigInt), + CannotDeserializeAny, + Expected(ExpectedKind, PlainValue), + } + + #[derive(Debug)] + pub enum ExpectedKind { + Boolean, + Float, + Double, + + SignedInteger, + String, + ByteString, + Symbol, + + Record(Option), + SimpleRecord(&'static str, Option), + Option, + Sequence, + Dictionary, + } + + impl serde::ser::Error for Error { + fn custom(msg: T) -> Self { + Self::Message(msg.to_string()) + } + } + + impl serde::de::Error for Error { + fn custom(msg: T) -> Self { + Self::Message(msg.to_string()) + } + } + + impl std::error::Error for Error {} + + impl std::fmt::Display for Error { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(f, "{:?}", self) + } + } +} + +pub use error::Error; +use error::ExpectedKind; + +pub type Result = std::result::Result>; + pub struct Deserializer<'de, N: NestedValue, D: Domain> { input: &'de N, phantom: PhantomData, diff --git a/implementations/rust/src/value/error.rs b/implementations/rust/src/value/error.rs deleted file mode 100644 index 55af256..0000000 --- a/implementations/rust/src/value/error.rs +++ /dev/null @@ -1,51 +0,0 @@ -use num::bigint::BigInt; -use crate::value::{PlainValue, Domain}; - -#[derive(Debug)] -pub enum Error { - Message(String), - InvalidUnicodeScalar(u32), - NumberTooLarge(BigInt), - CannotDeserializeAny, - Expected(ExpectedKind, PlainValue), -} - -#[derive(Debug)] -pub enum ExpectedKind { - Boolean, - Float, - Double, - - SignedInteger, - String, - ByteString, - Symbol, - - Record(Option), - SimpleRecord(&'static str, Option), - Option, - Sequence, - Dictionary, -} - -pub type Result = std::result::Result>; - -impl serde::ser::Error for Error { - fn custom(msg: T) -> Self { - Self::Message(msg.to_string()) - } -} - -impl serde::de::Error for Error { - fn custom(msg: T) -> Self { - Self::Message(msg.to_string()) - } -} - -impl std::error::Error for Error {} - -impl std::fmt::Display for Error { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(f, "{:?}", self) - } -} diff --git a/implementations/rust/src/value/mod.rs b/implementations/rust/src/value/mod.rs index 3680efb..c3f6d0a 100644 --- a/implementations/rust/src/value/mod.rs +++ b/implementations/rust/src/value/mod.rs @@ -3,7 +3,6 @@ pub mod constants; pub mod de; pub mod decoder; pub mod encoder; -pub mod error; pub mod reader; pub mod ser; pub mod value; diff --git a/implementations/rust/src/value/ser.rs b/implementations/rust/src/value/ser.rs index 1d9ad11..f459319 100644 --- a/implementations/rust/src/value/ser.rs +++ b/implementations/rust/src/value/ser.rs @@ -1,8 +1,23 @@ use crate::value::{Value, NestedValue, Map, Domain}; use serde::Serialize; -use crate::value::error::{Error, Result}; use std::marker::PhantomData; +#[derive(Debug)] +pub enum Error {} +impl serde::ser::Error for Error { + fn custom(_: T) -> Self where T: std::fmt::Display { + unreachable!() + } +} +impl std::error::Error for Error {} +impl std::fmt::Display for Error { + fn fmt(&self, _fmt: &mut std::fmt::Formatter) -> std::result::Result<(), std::fmt::Error> { + unreachable!() + } +} + +type Result = std::result::Result; + pub struct Serializer, D: Domain> { phantom: PhantomData<(N, D)>, } @@ -26,7 +41,7 @@ pub struct SerializeSequence, D: Domain> { impl, D: Domain> serde::Serializer for Serializer { type Ok = N; - type Error = Error; + type Error = Error; type SerializeSeq = SerializeSequence; type SerializeTuple = SerializeRecord; type SerializeTupleStruct = SerializeRecord; @@ -35,75 +50,75 @@ impl, D: Domain> serde::Serializer for Serializer { type SerializeStruct = SerializeRecord; type SerializeStructVariant = SerializeRecord; - fn serialize_bool(self, v: bool) -> Result { + fn serialize_bool(self, v: bool) -> Result { Ok(Value::from(v).wrap()) } - fn serialize_i8(self, v: i8) -> Result { + fn serialize_i8(self, v: i8) -> Result { Ok(Value::from(v).wrap()) } - fn serialize_i16(self, v: i16) -> Result { + fn serialize_i16(self, v: i16) -> Result { Ok(Value::from(v).wrap()) } - fn serialize_i32(self, v: i32) -> Result { + fn serialize_i32(self, v: i32) -> Result { Ok(Value::from(v).wrap()) } - fn serialize_i64(self, v: i64) -> Result { + fn serialize_i64(self, v: i64) -> Result { Ok(Value::from(v).wrap()) } - fn serialize_u8(self, v: u8) -> Result { + fn serialize_u8(self, v: u8) -> Result { Ok(Value::from(v).wrap()) } - fn serialize_u16(self, v: u16) -> Result { + fn serialize_u16(self, v: u16) -> Result { Ok(Value::from(v).wrap()) } - fn serialize_u32(self, v: u32) -> Result { + fn serialize_u32(self, v: u32) -> Result { Ok(Value::from(v).wrap()) } - fn serialize_u64(self, v: u64) -> Result { + fn serialize_u64(self, v: u64) -> Result { Ok(Value::from(v).wrap()) } - fn serialize_f32(self, v: f32) -> Result { + fn serialize_f32(self, v: f32) -> Result { Ok(Value::from(v).wrap()) } - fn serialize_f64(self, v: f64) -> Result { + fn serialize_f64(self, v: f64) -> Result { Ok(Value::from(v).wrap()) } - fn serialize_char(self, v: char) -> Result { + fn serialize_char(self, v: char) -> Result { Ok(Value::simple_record("UnicodeScalar", vec![Value::from(v as u32).wrap()]).wrap()) } - fn serialize_str(self, v: &str) -> Result { + fn serialize_str(self, v: &str) -> Result { Ok(Value::from(v).wrap()) } - fn serialize_bytes(self, v: &[u8]) -> Result { + fn serialize_bytes(self, v: &[u8]) -> Result { Ok(Value::from(v).wrap()) } - fn serialize_none(self) -> Result { + fn serialize_none(self) -> Result { Ok(Value::simple_record("None", vec![]).wrap()) } - fn serialize_some(self, v: &T) -> Result where T: Serialize { - Ok(Value::simple_record("Some", vec![to_value(v)?]).wrap()) + fn serialize_some(self, v: &T) -> Result where T: Serialize { + Ok(Value::simple_record("Some", vec![to_value(v)]).wrap()) } - fn serialize_unit(self) -> Result { + fn serialize_unit(self) -> Result { Ok(Value::simple_record("tuple", vec![]).wrap()) } - fn serialize_unit_struct(self, name: &'static str) -> Result { + fn serialize_unit_struct(self, name: &'static str) -> Result { Ok(Value::simple_record(name, vec![]).wrap()) } @@ -111,13 +126,13 @@ impl, D: Domain> serde::Serializer for Serializer { _name: &'static str, _variant: u32, variant_name: &'static str) -> - Result + Result { Ok(Value::simple_record(variant_name, vec![]).wrap()) } fn serialize_newtype_struct(self, name: &'static str, value: &T) -> - Result where T: Serialize + Result where T: Serialize { if name == crate::value::value::MAGIC_VALUE { let b = unsafe { Box::from_raw(*((value as *const T) as *const u64) as *mut &Value) }; @@ -129,7 +144,7 @@ impl, D: Domain> serde::Serializer for Serializer { Ok(v.clone()) } else { // TODO: This is apparently discouraged, and we should apparently just serialize `value`? - Ok(Value::simple_record(name, vec![to_value(value)?]).wrap()) + Ok(Value::simple_record(name, vec![to_value(value)]).wrap()) } } @@ -138,22 +153,22 @@ impl, D: Domain> serde::Serializer for Serializer { _variant: u32, variant_name: &'static str, value: &T) -> - Result where T: Serialize + Result where T: Serialize { - Ok(Value::simple_record(variant_name, vec![to_value(value)?]).wrap()) + Ok(Value::simple_record(variant_name, vec![to_value(value)]).wrap()) } - fn serialize_seq(self, count: Option) -> Result { + fn serialize_seq(self, count: Option) -> Result { let vec = match count { Some(n) => Vec::with_capacity(n), None => Vec::new() }; Ok(SerializeSequence{ vec, phantom: PhantomData }) } - fn serialize_tuple(self, count: usize) -> Result { + fn serialize_tuple(self, count: usize) -> Result { Ok(SerializeRecord{ name: "tuple", vec: Vec::with_capacity(count), phantom: PhantomData }) } fn serialize_tuple_struct(self, name: &'static str, count: usize) -> - Result + Result { Ok(SerializeRecord{ name, vec: Vec::with_capacity(count), phantom: PhantomData }) } @@ -163,16 +178,16 @@ impl, D: Domain> serde::Serializer for Serializer { _variant: u32, variant_name: &'static str, count: usize) -> - Result + Result { Ok(SerializeRecord{ name: variant_name, vec: Vec::with_capacity(count), phantom: PhantomData }) } - fn serialize_map(self, _count: Option) -> Result { + fn serialize_map(self, _count: Option) -> Result { Ok(SerializeDictionary{ next_key: None, items: Map::new(), phantom: PhantomData }) } - fn serialize_struct(self, name: &'static str, count: usize) -> Result { + fn serialize_struct(self, name: &'static str, count: usize) -> Result { Ok(SerializeRecord{ name, vec: Vec::with_capacity(count), phantom: PhantomData }) } @@ -181,7 +196,7 @@ impl, D: Domain> serde::Serializer for Serializer { _variant: u32, variant_name: &'static str, count: usize) -> - Result + Result { Ok(SerializeRecord{ name: variant_name, vec: Vec::with_capacity(count), phantom: PhantomData }) } @@ -189,118 +204,118 @@ impl, D: Domain> serde::Serializer for Serializer { impl, D: Domain> serde::ser::SerializeMap for SerializeDictionary { type Ok = N; - type Error = Error; + type Error = Error; - fn serialize_key(&mut self, key: &T) -> Result<(), D> where T: Serialize { - self.next_key = Some(to_value(key)?); + fn serialize_key(&mut self, key: &T) -> Result<()> where T: Serialize { + self.next_key = Some(to_value(key)); Ok(()) } - fn serialize_value(&mut self, value: &T) -> Result<(), D> where T: Serialize { + fn serialize_value(&mut self, value: &T) -> Result<()> where T: Serialize { let key = self.next_key.take().unwrap(); - self.items.insert(key, to_value(value)?); + self.items.insert(key, to_value(value)); Ok(()) } - fn end(self) -> Result { + fn end(self) -> Result { Ok(Value::from(self.items).wrap()) } } impl, D: Domain> SerializeRecord { - fn push(&mut self, value: N) -> Result<(), D> { + fn push(&mut self, value: N) -> Result<()> { self.vec.push(value); Ok(()) } - fn finish(self) -> Result { + fn finish(self) -> Result { Ok(Value::simple_record(self.name, self.vec).wrap()) } } impl, D: Domain> serde::ser::SerializeStruct for SerializeRecord { type Ok = N; - type Error = Error; + type Error = Error; - fn serialize_field(&mut self, _name: &'static str, value: &T) -> Result<(), D> + fn serialize_field(&mut self, _name: &'static str, value: &T) -> Result<()> where T: Serialize { - self.push(to_value(value)?) + self.push(to_value(value)) } - fn end(self) -> Result { + fn end(self) -> Result { self.finish() } } impl, D: Domain> serde::ser::SerializeStructVariant for SerializeRecord { type Ok = N; - type Error = Error; + type Error = Error; - fn serialize_field(&mut self, _name: &'static str, value: &T) -> Result<(), D> + fn serialize_field(&mut self, _name: &'static str, value: &T) -> Result<()> where T: Serialize { - self.push(to_value(value)?) + self.push(to_value(value)) } - fn end(self) -> Result { + fn end(self) -> Result { self.finish() } } impl, D: Domain> serde::ser::SerializeTuple for SerializeRecord { type Ok = N; - type Error = Error; + type Error = Error; - fn serialize_element(&mut self, value: &T) -> Result<(), D> where T: Serialize { - self.push(to_value(value)?) + fn serialize_element(&mut self, value: &T) -> Result<()> where T: Serialize { + self.push(to_value(value)) } - fn end(self) -> Result { + fn end(self) -> Result { self.finish() } } impl, D: Domain> serde::ser::SerializeTupleStruct for SerializeRecord { type Ok = N; - type Error = Error; + type Error = Error; - fn serialize_field(&mut self, value: &T) -> Result<(), D> where T: Serialize { - self.push(to_value(value)?) + fn serialize_field(&mut self, value: &T) -> Result<()> where T: Serialize { + self.push(to_value(value)) } - fn end(self) -> Result { + fn end(self) -> Result { self.finish() } } impl, D: Domain> serde::ser::SerializeTupleVariant for SerializeRecord { type Ok = N; - type Error = Error; + type Error = Error; - fn serialize_field(&mut self, value: &T) -> Result<(), D> where T: Serialize { - self.push(to_value(value)?) + fn serialize_field(&mut self, value: &T) -> Result<()> where T: Serialize { + self.push(to_value(value)) } - fn end(self) -> Result { + fn end(self) -> Result { self.finish() } } impl, D: Domain> serde::ser::SerializeSeq for SerializeSequence { type Ok = N; - type Error = Error; + type Error = Error; - fn serialize_element(&mut self, value: &T) -> Result<(), D> where T: Serialize { - self.vec.push(to_value(value)?); + fn serialize_element(&mut self, value: &T) -> Result<()> where T: Serialize { + self.vec.push(to_value(value)); Ok(()) } - fn end(self) -> Result { + fn end(self) -> Result { Ok(Value::from(self.vec).wrap()) } } -pub fn to_value(value: T) -> Result where T: Serialize, N: NestedValue { - value.serialize(Serializer{ phantom: PhantomData }) +pub fn to_value(value: T) -> N where T: Serialize, N: NestedValue { + value.serialize(Serializer{ phantom: PhantomData }).unwrap() }