syndicate-lang
/
preserves
mirror of https://gitlab.com/preserves/preserves.git
1
0
Fork 1
Code Releases Activity

More error cleanup

This commit is contained in:
Tony Garnock-Jones 2020-05-25 16:12:41 +02:00
parent 3f5e431717
commit 450b73a4d2
5 changed files with 140 additions and 121 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
implementations/rust/src/lib.rs
View File

@ -392,7 +392,7 @@ mod samples_tests {
12345,
Value::from("hi").wrap());
println!("== v: {:#?}", v);
let w: PlainValue<Dom> = to_value(&v).unwrap();
let w: PlainValue<Dom> = to_value(&v);
println!("== w: {:#?}", w);
let x = from_value(&w).unwrap();
println!("== x: {:#?}", &x);

58
implementations/rust/src/value/de.rs
View File

@ -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<D: Domain> {
Message(String),
InvalidUnicodeScalar(u32),
NumberTooLarge(BigInt),
CannotDeserializeAny,
Expected(ExpectedKind, PlainValue<D>),
}
#[derive(Debug)]
pub enum ExpectedKind {
Boolean,
Float,
Double,
SignedInteger,
String,
ByteString,
Symbol,
Record(Option<usize>),
SimpleRecord(&'static str, Option<usize>),
Option,
Sequence,
Dictionary,
}
impl<D: Domain> serde::ser::Error for Error<D> {
fn custom<T: std::fmt::Display>(msg: T) -> Self {
Self::Message(msg.to_string())
}
}
impl<D: Domain> serde::de::Error for Error<D> {
fn custom<T: std::fmt::Display>(msg: T) -> Self {
Self::Message(msg.to_string())
}
}
impl<D: Domain> std::error::Error for Error<D> {}
impl<D: Domain> std::fmt::Display for Error<D> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "{:?}", self)
}
}
}
pub use error::Error;
use error::ExpectedKind;
pub type Result<T, D> = std::result::Result<T, Error<D>>;
pub struct Deserializer<'de, N: NestedValue<D>, D: Domain> {
input: &'de N,
phantom: PhantomData<D>,

51
implementations/rust/src/value/error.rs
View File

@ -1,51 +0,0 @@
use num::bigint::BigInt;
use crate::value::{PlainValue, Domain};
#[derive(Debug)]
pub enum Error<D: Domain> {
Message(String),
InvalidUnicodeScalar(u32),
NumberTooLarge(BigInt),
CannotDeserializeAny,
Expected(ExpectedKind, PlainValue<D>),
}
#[derive(Debug)]
pub enum ExpectedKind {
Boolean,
Float,
Double,
SignedInteger,
String,
ByteString,
Symbol,
Record(Option<usize>),
SimpleRecord(&'static str, Option<usize>),
Option,
Sequence,
Dictionary,
}
pub type Result<T, D> = std::result::Result<T, Error<D>>;
impl<D: Domain> serde::ser::Error for Error<D> {
fn custom<T: std::fmt::Display>(msg: T) -> Self {
Self::Message(msg.to_string())
}
}
impl<D: Domain> serde::de::Error for Error<D> {
fn custom<T: std::fmt::Display>(msg: T) -> Self {
Self::Message(msg.to_string())
}
}
impl<D: Domain> std::error::Error for Error<D> {}
impl<D: Domain> std::fmt::Display for Error<D> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "{:?}", self)
}
}

1
implementations/rust/src/value/mod.rs
View File

@ -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;

149
implementations/rust/src/value/ser.rs
View File

@ -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>(_: 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<T> = std::result::Result<T, Error>;
pub struct Serializer<N: NestedValue<D>, D: Domain> {
phantom: PhantomData<(N, D)>,
}
@ -26,7 +41,7 @@ pub struct SerializeSequence<N: NestedValue<D>, D: Domain> {
impl<N: NestedValue<D>, D: Domain> serde::Serializer for Serializer<N, D> {
type Ok = N;
type Error = Error<D>;
type Error = Error;
type SerializeSeq = SerializeSequence<N, D>;
type SerializeTuple = SerializeRecord<N, D>;
type SerializeTupleStruct = SerializeRecord<N, D>;
@ -35,75 +50,75 @@ impl<N: NestedValue<D>, D: Domain> serde::Serializer for Serializer<N, D> {
type SerializeStruct = SerializeRecord<N, D>;
type SerializeStructVariant = SerializeRecord<N, D>;
fn serialize_bool(self, v: bool) -> Result<Self::Ok, D> {
fn serialize_bool(self, v: bool) -> Result<Self::Ok> {
Ok(Value::from(v).wrap())
}
fn serialize_i8(self, v: i8) -> Result<Self::Ok, D> {
fn serialize_i8(self, v: i8) -> Result<Self::Ok> {
Ok(Value::from(v).wrap())
}
fn serialize_i16(self, v: i16) -> Result<Self::Ok, D> {
fn serialize_i16(self, v: i16) -> Result<Self::Ok> {
Ok(Value::from(v).wrap())
}
fn serialize_i32(self, v: i32) -> Result<Self::Ok, D> {
fn serialize_i32(self, v: i32) -> Result<Self::Ok> {
Ok(Value::from(v).wrap())
}
fn serialize_i64(self, v: i64) -> Result<Self::Ok, D> {
fn serialize_i64(self, v: i64) -> Result<Self::Ok> {
Ok(Value::from(v).wrap())
}
fn serialize_u8(self, v: u8) -> Result<Self::Ok, D> {
fn serialize_u8(self, v: u8) -> Result<Self::Ok> {
Ok(Value::from(v).wrap())
}
fn serialize_u16(self, v: u16) -> Result<Self::Ok, D> {
fn serialize_u16(self, v: u16) -> Result<Self::Ok> {
Ok(Value::from(v).wrap())
}
fn serialize_u32(self, v: u32) -> Result<Self::Ok, D> {
fn serialize_u32(self, v: u32) -> Result<Self::Ok> {
Ok(Value::from(v).wrap())
}
fn serialize_u64(self, v: u64) -> Result<Self::Ok, D> {
fn serialize_u64(self, v: u64) -> Result<Self::Ok> {
Ok(Value::from(v).wrap())
}
fn serialize_f32(self, v: f32) -> Result<Self::Ok, D> {
fn serialize_f32(self, v: f32) -> Result<Self::Ok> {
Ok(Value::from(v).wrap())
}
fn serialize_f64(self, v: f64) -> Result<Self::Ok, D> {
fn serialize_f64(self, v: f64) -> Result<Self::Ok> {
Ok(Value::from(v).wrap())
}
fn serialize_char(self, v: char) -> Result<Self::Ok, D> {
fn serialize_char(self, v: char) -> Result<Self::Ok> {
Ok(Value::simple_record("UnicodeScalar", vec![Value::from(v as u32).wrap()]).wrap())
}
fn serialize_str(self, v: &str) -> Result<Self::Ok, D> {
fn serialize_str(self, v: &str) -> Result<Self::Ok> {
Ok(Value::from(v).wrap())
}
fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, D> {
fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok> {
Ok(Value::from(v).wrap())
}
fn serialize_none(self) -> Result<Self::Ok, D> {
fn serialize_none(self) -> Result<Self::Ok> {
Ok(Value::simple_record("None", vec![]).wrap())
}
fn serialize_some<T: ?Sized>(self, v: &T) -> Result<Self::Ok, D> where T: Serialize {
Ok(Value::simple_record("Some", vec![to_value(v)?]).wrap())
fn serialize_some<T: ?Sized>(self, v: &T) -> Result<Self::Ok> where T: Serialize {
Ok(Value::simple_record("Some", vec![to_value(v)]).wrap())
}
fn serialize_unit(self) -> Result<Self::Ok, D> {
fn serialize_unit(self) -> Result<Self::Ok> {
Ok(Value::simple_record("tuple", vec![]).wrap())
}
fn serialize_unit_struct(self, name: &'static str) -> Result<Self::Ok, D> {
fn serialize_unit_struct(self, name: &'static str) -> Result<Self::Ok> {
Ok(Value::simple_record(name, vec![]).wrap())
}
@ -111,13 +126,13 @@ impl<N: NestedValue<D>, D: Domain> serde::Serializer for Serializer<N, D> {
_name: &'static str,
_variant: u32,
variant_name: &'static str) ->
Result<Self::Ok, D>
Result<Self::Ok>
{
Ok(Value::simple_record(variant_name, vec![]).wrap())
}
fn serialize_newtype_struct<T: ?Sized>(self, name: &'static str, value: &T) ->
Result<Self::Ok, D> where T: Serialize
Result<Self::Ok> 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<N, D>) };
@ -129,7 +144,7 @@ impl<N: NestedValue<D>, D: Domain> serde::Serializer for Serializer<N, D> {
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<N: NestedValue<D>, D: Domain> serde::Serializer for Serializer<N, D> {
_variant: u32,
variant_name: &'static str,
value: &T) ->
Result<Self::Ok, D> where T: Serialize
Result<Self::Ok> 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<usize>) -> Result<Self::SerializeSeq, D> {
fn serialize_seq(self, count: Option<usize>) -> Result<Self::SerializeSeq> {
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<Self::SerializeTuple, D> {
fn serialize_tuple(self, count: usize) -> Result<Self::SerializeTuple> {
Ok(SerializeRecord{ name: "tuple", vec: Vec::with_capacity(count), phantom: PhantomData })
}
fn serialize_tuple_struct(self, name: &'static str, count: usize) ->
Result<Self::SerializeTupleStruct, D>
Result<Self::SerializeTupleStruct>
{
Ok(SerializeRecord{ name, vec: Vec::with_capacity(count), phantom: PhantomData })
}
@ -163,16 +178,16 @@ impl<N: NestedValue<D>, D: Domain> serde::Serializer for Serializer<N, D> {
_variant: u32,
variant_name: &'static str,
count: usize) ->
Result<Self::SerializeTupleVariant, D>
Result<Self::SerializeTupleVariant>
{
Ok(SerializeRecord{ name: variant_name, vec: Vec::with_capacity(count), phantom: PhantomData })
}
fn serialize_map(self, _count: Option<usize>) -> Result<Self::SerializeMap, D> {
fn serialize_map(self, _count: Option<usize>) -> Result<Self::SerializeMap> {
Ok(SerializeDictionary{ next_key: None, items: Map::new(), phantom: PhantomData })
}
fn serialize_struct(self, name: &'static str, count: usize) -> Result<Self::SerializeStruct, D> {
fn serialize_struct(self, name: &'static str, count: usize) -> Result<Self::SerializeStruct> {
Ok(SerializeRecord{ name, vec: Vec::with_capacity(count), phantom: PhantomData })
}
@ -181,7 +196,7 @@ impl<N: NestedValue<D>, D: Domain> serde::Serializer for Serializer<N, D> {
_variant: u32,
variant_name: &'static str,
count: usize) ->
Result<Self::SerializeStructVariant, D>
Result<Self::SerializeStructVariant>
{
Ok(SerializeRecord{ name: variant_name, vec: Vec::with_capacity(count), phantom: PhantomData })
}
@ -189,118 +204,118 @@ impl<N: NestedValue<D>, D: Domain> serde::Serializer for Serializer<N, D> {
impl<N: NestedValue<D>, D: Domain> serde::ser::SerializeMap for SerializeDictionary<N, D> {
type Ok = N;
type Error = Error<D>;
type Error = Error;
fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<(), D> where T: Serialize {
self.next_key = Some(to_value(key)?);
fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<()> where T: Serialize {
self.next_key = Some(to_value(key));
Ok(())
}
fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<(), D> where T: Serialize {
fn serialize_value<T: ?Sized>(&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<Self::Ok, D> {
fn end(self) -> Result<Self::Ok> {
Ok(Value::from(self.items).wrap())
}
}
impl<N: NestedValue<D>, D: Domain> SerializeRecord<N, D> {
fn push(&mut self, value: N) -> Result<(), D> {
fn push(&mut self, value: N) -> Result<()> {
self.vec.push(value);
Ok(())
}
fn finish(self) -> Result<N, D> {
fn finish(self) -> Result<N> {
Ok(Value::simple_record(self.name, self.vec).wrap())
}
}
impl<N: NestedValue<D>, D: Domain> serde::ser::SerializeStruct for SerializeRecord<N, D> {
type Ok = N;
type Error = Error<D>;
type Error = Error;
fn serialize_field<T: ?Sized>(&mut self, _name: &'static str, value: &T) -> Result<(), D>
fn serialize_field<T: ?Sized>(&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<Self::Ok, D> {
fn end(self) -> Result<Self::Ok> {
self.finish()
}
}
impl<N: NestedValue<D>, D: Domain> serde::ser::SerializeStructVariant for SerializeRecord<N, D> {
type Ok = N;
type Error = Error<D>;
type Error = Error;
fn serialize_field<T: ?Sized>(&mut self, _name: &'static str, value: &T) -> Result<(), D>
fn serialize_field<T: ?Sized>(&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<Self::Ok, D> {
fn end(self) -> Result<Self::Ok> {
self.finish()
}
}
impl<N: NestedValue<D>, D: Domain> serde::ser::SerializeTuple for SerializeRecord<N, D> {
type Ok = N;
type Error = Error<D>;
type Error = Error;
fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), D> where T: Serialize {
self.push(to_value(value)?)
fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<()> where T: Serialize {
self.push(to_value(value))
}
fn end(self) -> Result<Self::Ok, D> {
fn end(self) -> Result<Self::Ok> {
self.finish()
}
}
impl<N: NestedValue<D>, D: Domain> serde::ser::SerializeTupleStruct for SerializeRecord<N, D> {
type Ok = N;
type Error = Error<D>;
type Error = Error;
fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), D> where T: Serialize {
self.push(to_value(value)?)
fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<()> where T: Serialize {
self.push(to_value(value))
}
fn end(self) -> Result<Self::Ok, D> {
fn end(self) -> Result<Self::Ok> {
self.finish()
}
}
impl<N: NestedValue<D>, D: Domain> serde::ser::SerializeTupleVariant for SerializeRecord<N, D> {
type Ok = N;
type Error = Error<D>;
type Error = Error;
fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), D> where T: Serialize {
self.push(to_value(value)?)
fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<()> where T: Serialize {
self.push(to_value(value))
}
fn end(self) -> Result<Self::Ok, D> {
fn end(self) -> Result<Self::Ok> {
self.finish()
}
}
impl<N: NestedValue<D>, D: Domain> serde::ser::SerializeSeq for SerializeSequence<N, D> {
type Ok = N;
type Error = Error<D>;
type Error = Error;
fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), D> where T: Serialize {
self.vec.push(to_value(value)?);
fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<()> where T: Serialize {
self.vec.push(to_value(value));
Ok(())
}
fn end(self) -> Result<Self::Ok, D> {
fn end(self) -> Result<Self::Ok> {
Ok(Value::from(self.vec).wrap())
}
}
pub fn to_value<T, N, D: Domain>(value: T) -> Result<N, D> where T: Serialize, N: NestedValue<D> {
value.serialize(Serializer{ phantom: PhantomData })
pub fn to_value<T, N, D: Domain>(value: T) -> N where T: Serialize, N: NestedValue<D> {
value.serialize(Serializer{ phantom: PhantomData }).unwrap()
}