syndicate-lang
/
preserves
mirror of https://gitlab.com/preserves/preserves.git
1
0
Fork 1
Code Releases Activity
preserves/implementations/rust/src/value/de.rs

434 lines
16 KiB
Rust
Raw Blame History

use crate::value::{Value, NestedValue, Map, Domain};
use crate::value::value::{Float, Double};
use num::traits::cast::ToPrimitive;
use serde::Deserialize;
use serde::de::{Visitor, SeqAccess, MapAccess, EnumAccess, VariantAccess, DeserializeSeed};
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>,
}
pub fn from_value<'a, T, N: NestedValue<D>, D: 'a + Domain>(v: &'a N) ->
Result<T, D> where T: Deserialize<'a>
{
let mut de = Deserializer::from_value(v);
let t = T::deserialize(&mut de)?;
Ok(t)
}
impl<'de, N: NestedValue<D>, D: 'de + Domain> Deserializer<'de, N, D> {
pub fn from_value(v: &'de N) -> Self {
Deserializer{ input: v, phantom: PhantomData }
}
fn check<'a, T, F>(&'a mut self, f: F, k: ExpectedKind) -> Result<T, D>
where F: FnOnce(&'de Value<N, D>) -> Option<T>
{
f(self.input.value()).ok_or_else(|| Error::Expected(k, self.input.copy_via()))
}
}
impl<'de, 'a, N: NestedValue<D>, D: 'de + Domain> serde::de::Deserializer<'de>
for &'a mut Deserializer<'de, N, D>
{
type Error = Error<D>;
fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, D> where V: Visitor<'de>
{
let v = self.input.value();
match v {
Value::Boolean(b) => visitor.visit_bool(*b),
Value::Float(Float(f)) => visitor.visit_f32(*f),
Value::Double(Double(d)) => visitor.visit_f64(*d),
Value::SignedInteger(ref i) =>
match i.to_i64() {
None => match i.to_u64() {
None => Err(Error::NumberTooLarge(i.clone())),
Some(n) => visitor.visit_u64(n),
}
Some(n) => visitor.visit_i64(n),
}
Value::String(ref s) => visitor.visit_str(&s),
Value::ByteString(_) => self.deserialize_bytes(visitor),
Value::Record(_) =>
if v.is_simple_record("tuple", Some(0)) {
self.deserialize_unit(visitor)
} else if v.is_simple_record("UnicodeScalar", Some(1)) {
self.deserialize_char(visitor)
} else if v.is_simple_record("None", Some(0)) || v.is_simple_record("Some", Some(1)) {
self.deserialize_option(visitor)
} else if v.is_simple_record("tuple", None) {
visitor.visit_seq(VecSeq::new(self, v.as_simple_record("tuple", None).unwrap()))
} else {
Err(Error::CannotDeserializeAny)
}
Value::Sequence(ref v) => visitor.visit_seq(VecSeq::new(self, v)),
Value::Dictionary(ref d) => visitor.visit_map(DictMap::new(self, d)),
_ => Err(Error::CannotDeserializeAny),
}
}
fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, D> where V: Visitor<'de>
{
visitor.visit_bool(self.check(|v| v.as_boolean(), ExpectedKind::Boolean)?)
}
fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value, D> where V: Visitor<'de>
{
let i = self.check(|v| v.as_signedinteger(), ExpectedKind::SignedInteger)?;
visitor.visit_i8(i.to_i8().ok_or_else(|| Error::NumberTooLarge(i.clone()))?)
}
fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value, D> where V: Visitor<'de>
{
let i = self.check(|v| v.as_signedinteger(), ExpectedKind::SignedInteger)?;
visitor.visit_i16(i.to_i16().ok_or_else(|| Error::NumberTooLarge(i.clone()))?)
}
fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value, D> where V: Visitor<'de>
{
let i = self.check(|v| v.as_signedinteger(), ExpectedKind::SignedInteger)?;
visitor.visit_i32(i.to_i32().ok_or_else(|| Error::NumberTooLarge(i.clone()))?)
}
fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value, D> where V: Visitor<'de>
{
let i = self.check(|v| v.as_signedinteger(), ExpectedKind::SignedInteger)?;
visitor.visit_i64(i.to_i64().ok_or_else(|| Error::NumberTooLarge(i.clone()))?)
}
fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value, D> where V: Visitor<'de>
{
let i = self.check(|v| v.as_signedinteger(), ExpectedKind::SignedInteger)?;
visitor.visit_u8(i.to_u8().ok_or_else(|| Error::NumberTooLarge(i.clone()))?)
}
fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value, D> where V: Visitor<'de>
{
let i = self.check(|v| v.as_signedinteger(), ExpectedKind::SignedInteger)?;
visitor.visit_u16(i.to_u16().ok_or_else(|| Error::NumberTooLarge(i.clone()))?)
}
fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value, D> where V: Visitor<'de>
{
let i = self.check(|v| v.as_signedinteger(), ExpectedKind::SignedInteger)?;
visitor.visit_u32(i.to_u32().ok_or_else(|| Error::NumberTooLarge(i.clone()))?)
}
fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value, D> where V: Visitor<'de>
{
let i = self.check(|v| v.as_signedinteger(), ExpectedKind::SignedInteger)?;
visitor.visit_u64(i.to_u64().ok_or_else(|| Error::NumberTooLarge(i.clone()))?)
}
fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value, D> where V: Visitor<'de>
{
visitor.visit_f32(self.check(|v| v.as_float(), ExpectedKind::Float)?)
}
fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value, D> where V: Visitor<'de>
{
visitor.visit_f64(self.check(|v| v.as_double(), ExpectedKind::Double)?)
}
fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, D> where V: Visitor<'de>
{
let fs = self.check(|v| v.as_simple_record("UnicodeScalar", Some(1)),
ExpectedKind::SimpleRecord("UnicodeScalar", Some(1)))?;
let c = fs[0].value().as_u32()
.ok_or_else(|| Error::Expected(ExpectedKind::SignedInteger, self.input.copy_via()))?;
visitor.visit_char(char::try_from(c).or(Err(Error::InvalidUnicodeScalar(c)))?)
}
fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, D> where V: Visitor<'de>
{
visitor.visit_borrowed_str(&self.check(|v| v.as_string(), ExpectedKind::String)?)
}
fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, D> where V: Visitor<'de>
{
self.deserialize_str(visitor)
}
fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, D> where V: Visitor<'de>
{
visitor.visit_borrowed_bytes(&self.check(|v| v.as_bytestring(), ExpectedKind::ByteString)?)
}
fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, D> where V: Visitor<'de>
{
visitor.visit_byte_buf(self.check(|v| v.as_bytestring(), ExpectedKind::ByteString)?.clone())
}
fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, D> where V: Visitor<'de>
{
match self.input.value().as_simple_record("None", Some(0)) {
Some(_fs) => visitor.visit_none(),
None => match self.input.value().as_simple_record("Some", Some(1)) {
Some(fs) => {
self.input = &fs[0];
visitor.visit_some(self)
}
None => Err(Error::Expected(ExpectedKind::Option, self.input.copy_via()))
}
}
}
fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, D> where V: Visitor<'de>
{
if self.input.value().is_simple_record("tuple", Some(0)) {
visitor.visit_unit()
} else {
Err(Error::Expected(ExpectedKind::SimpleRecord("tuple", Some(0)), self.input.copy_via()))
}
}
fn deserialize_unit_struct<V>(self, name: &'static str, visitor: V)
-> Result<V::Value, D> where V: Visitor<'de>
{
if self.input.value().is_simple_record(name, Some(0)) {
visitor.visit_unit()
} else {
Err(Error::Expected(ExpectedKind::SimpleRecord(name, Some(0)), self.input.copy_via()))
}
}
fn deserialize_newtype_struct<V>(self, name: &'static str, visitor: V)
-> Result<V::Value, D> where V: Visitor<'de>
{
if name == crate::value::value::MAGIC_VALUE {
let v: Box<Value<N, D>> = Box::new(self.input.clone().value_owned());
visitor.visit_u64(Box::into_raw(v) as u64)
} else if name == crate::value::value::MAGIC_NESTEDVALUE {
let v: Box<N> = Box::new(self.input.clone());
visitor.visit_u64(Box::into_raw(v) as u64)
} else {
let fs = self.check(|v| v.as_simple_record(name, Some(1)),
ExpectedKind::SimpleRecord(name, Some(1)))?;
self.input = &fs[0];
visitor.visit_newtype_struct(self)
}
}
fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, D> where V: Visitor<'de> {
let vs = self.check(|v| v.as_sequence(), ExpectedKind::Sequence)?;
visitor.visit_seq(VecSeq::new(self, vs))
}
fn deserialize_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value, D> where V: Visitor<'de>
{
let fs = self.check(|v| v.as_simple_record("tuple", Some(len)),
ExpectedKind::SimpleRecord("tuple", Some(len)))?;
visitor.visit_seq(VecSeq::new(self, fs))
}
fn deserialize_tuple_struct<V>(self, name: &'static str, len: usize, visitor: V)
-> Result<V::Value, D> where V: Visitor<'de>
{
let fs = self.check(|v| v.as_simple_record(name, Some(len)),
ExpectedKind::SimpleRecord(name, Some(len)))?;
visitor.visit_seq(VecSeq::new(self, fs))
}
fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, D> where V: Visitor<'de> {
let d = self.check(|v| v.as_dictionary(), ExpectedKind::Dictionary)?;
visitor.visit_map(DictMap::new(self, d))
}
fn deserialize_struct<V>(self,
name: &'static str,
fields: &'static [&'static str],
visitor: V)
-> Result<V::Value, D> where V: Visitor<'de>
{
let fs = self.check(|v| v.as_simple_record(name, Some(fields.len())),
ExpectedKind::SimpleRecord(name, Some(fields.len())))?;
visitor.visit_seq(VecSeq::new(self, fs))
}
fn deserialize_enum<V>(self,
_name: &'static str,
_variants: &'static [&'static str],
visitor: V)
-> Result<V::Value, D> where V: Visitor<'de>
{
visitor.visit_enum(self)
}
fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, D> where V: Visitor<'de>
{
visitor.visit_borrowed_str(&self.check(|v| v.as_symbol(), ExpectedKind::Symbol)?)
}
fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, D> where V: Visitor<'de>
{
visitor.visit_none()
}
}
pub struct VecSeq<'a, 'de: 'a, N: NestedValue<D>, D: Domain> {
index: usize,
vec: &'de [N],
de: &'a mut Deserializer<'de, N, D>,
}
impl<'de, 'a, N: NestedValue<D>, D: Domain> VecSeq<'a, 'de, N, D> {
fn new(de: &'a mut Deserializer<'de, N, D>, vec: &'de [N]) -> Self {
VecSeq{ index: 0, vec, de }
}
}
impl<'de, 'a, N: NestedValue<D>, D: 'de + Domain> SeqAccess<'de> for VecSeq<'a, 'de, N, D> {
type Error = Error<D>;
fn next_element_seed<T>(&mut self, seed: T)
-> Result<Option<T::Value>, D> where T: DeserializeSeed<'de>
{
if self.index == self.vec.len() {
return Ok(None)
}
self.de.input = &self.vec[self.index];
self.index += 1;
let value = seed.deserialize(&mut *self.de)?;
Ok(Some(value))
}
}
pub struct DictMap<'a, 'de: 'a, N: NestedValue<D>, D: Domain> {
pending: Option<&'de N>,
iter: Box<dyn Iterator<Item = (&'de N, &'de N)> + 'a>,
de: &'a mut Deserializer<'de, N, D>,
}
impl<'de, 'a, N: NestedValue<D>, D: Domain> DictMap<'a, 'de, N, D> {
fn new(de: &'a mut Deserializer<'de, N, D>, d: &'de Map<N, N>) -> Self {
DictMap{ pending: None, iter: Box::new(d.iter()), de }
}
}
impl<'de, 'a, N: NestedValue<D>, D: 'de + Domain> MapAccess<'de> for DictMap<'a, 'de, N, D> {
type Error = Error<D>;
fn next_key_seed<K>(&mut self, seed: K)
-> Result<Option<K::Value>, D> where K: DeserializeSeed<'de>
{
match self.iter.next() {
None => Ok(None),
Some((k, v)) => {
self.pending = Some(v);
self.de.input = k;
Ok(Some(seed.deserialize(&mut *self.de)?))
}
}
}
fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, D> where V: DeserializeSeed<'de> {
let v = self.pending.unwrap();
self.pending = None;
self.de.input = v;
Ok(seed.deserialize(&mut *self.de)?)
}
}
impl<'a, 'de, N: NestedValue<D>, D: 'de + Domain> EnumAccess<'de> for &'a mut Deserializer<'de, N, D> {
type Error = Error<D>;
type Variant = Self;
fn variant_seed<V>(self, seed: V)
-> Result<(V::Value, Self::Variant), D> where V: DeserializeSeed<'de>
{
let (lp, _) = self.check(|v| v.as_record(None), ExpectedKind::Record(None))?;
let v = self.input;
self.input = N::boxunwrap(lp);
let variant = seed.deserialize(&mut *self)?;
self.input = v;
Ok((variant, self))
}
}
impl<'a, 'de, N: NestedValue<D>, D: 'de + Domain> VariantAccess<'de> for &'a mut Deserializer<'de, N, D> {
type Error = Error<D>;
fn unit_variant(self) -> Result<(), D> {
Ok(())
}
fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, D> where T: DeserializeSeed<'de> {
let (_, fs) = self.check(|v| v.as_record(Some(1)), ExpectedKind::Record(Some(1)))?;
self.input = &fs[0];
seed.deserialize(&mut *self)
}
fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value, D> where V: Visitor<'de> {
visitor.visit_seq(VecSeq::new(self, &self.input.value().as_record(None).unwrap().1))
}
fn struct_variant<V>(self, fields: &'static [&'static str], visitor: V)
-> Result<V::Value, D> where V: Visitor<'de>
{
visitor.visit_seq(VecSeq::new(self, &self.input.value().as_record(Some(fields.len())).unwrap().1))
}
}
View Git Blame Copy Permalink