Allow embedding of domain-specific non-Preserves data within a Preserves Value
This commit is contained in:
parent
826fce6203
commit
27fb961653
|
@ -1,6 +1,6 @@
|
||||||
[package]
|
[package]
|
||||||
name = "preserves"
|
name = "preserves"
|
||||||
version = "0.2.3"
|
version = "0.3.0"
|
||||||
authors = ["Tony Garnock-Jones <tonyg@leastfixedpoint.com>"]
|
authors = ["Tony Garnock-Jones <tonyg@leastfixedpoint.com>"]
|
||||||
edition = "2018"
|
edition = "2018"
|
||||||
description = "Implementation of the Preserves serialization format via serde."
|
description = "Implementation of the Preserves serialization format via serde."
|
||||||
|
|
|
@ -1,13 +1,17 @@
|
||||||
pub mod value;
|
pub mod value;
|
||||||
pub mod symbol;
|
pub mod symbol;
|
||||||
|
|
||||||
|
#[cfg(test)]
|
||||||
|
type Dom = ();
|
||||||
|
|
||||||
#[cfg(test)]
|
#[cfg(test)]
|
||||||
mod ieee754_section_5_10_total_order_tests {
|
mod ieee754_section_5_10_total_order_tests {
|
||||||
use std::cmp::Ordering::{Less, Equal, Greater};
|
use std::cmp::Ordering::{Less, Equal, Greater};
|
||||||
|
use super::Dom;
|
||||||
|
|
||||||
use crate::value::{Value, PlainValue};
|
use crate::value::{Value, PlainValue};
|
||||||
fn f(val: f32) -> Value<PlainValue> { Value::from(val) }
|
fn f(val: f32) -> Value<PlainValue<Dom>, Dom> { Value::from(val) }
|
||||||
fn d(val: f64) -> Value<PlainValue> { Value::from(val) }
|
fn d(val: f64) -> Value<PlainValue<Dom>, Dom> { Value::from(val) }
|
||||||
|
|
||||||
// TODO: Test cases with a few different signalling and non-signalling NaNs
|
// TODO: Test cases with a few different signalling and non-signalling NaNs
|
||||||
|
|
||||||
|
@ -99,8 +103,9 @@ mod ieee754_section_5_10_total_order_tests {
|
||||||
mod value_tests {
|
mod value_tests {
|
||||||
use crate::value::{Value, PlainValue};
|
use crate::value::{Value, PlainValue};
|
||||||
use num::bigint::BigInt;
|
use num::bigint::BigInt;
|
||||||
|
use super::Dom;
|
||||||
|
|
||||||
type VV = Value<PlainValue>;
|
type VV = Value<PlainValue<Dom>, Dom>;
|
||||||
|
|
||||||
#[test] fn boolean_mut() {
|
#[test] fn boolean_mut() {
|
||||||
let mut b = VV::Boolean(true);
|
let mut b = VV::Boolean(true);
|
||||||
|
@ -179,10 +184,11 @@ mod value_tests {
|
||||||
mod decoder_tests {
|
mod decoder_tests {
|
||||||
use crate::value::Decoder;
|
use crate::value::Decoder;
|
||||||
use crate::value::{Value, PlainValue, NestedValue};
|
use crate::value::{Value, PlainValue, NestedValue};
|
||||||
|
use super::Dom;
|
||||||
|
|
||||||
#[test] fn read_123() {
|
#[test] fn read_123() {
|
||||||
let mut buf = &b"abc"[..];
|
let mut buf = &b"abc"[..];
|
||||||
let mut d = Decoder::<_, PlainValue>::new(&mut buf, None);
|
let mut d = Decoder::<_, PlainValue<Dom>, Dom>::new(&mut buf, None);
|
||||||
assert_eq!(d.read().ok(), Some(97));
|
assert_eq!(d.read().ok(), Some(97));
|
||||||
assert_eq!(d.read().ok(), Some(98));
|
assert_eq!(d.read().ok(), Some(98));
|
||||||
assert_eq!(d.read().ok(), Some(99));
|
assert_eq!(d.read().ok(), Some(99));
|
||||||
|
@ -191,7 +197,7 @@ mod decoder_tests {
|
||||||
|
|
||||||
#[test] fn skip_annotations_noskip() {
|
#[test] fn skip_annotations_noskip() {
|
||||||
let mut buf = &b"\x0521"[..];
|
let mut buf = &b"\x0521"[..];
|
||||||
let mut d = Decoder::<_, PlainValue>::new(&mut buf, None);
|
let mut d = Decoder::<_, PlainValue<Dom>, Dom>::new(&mut buf, None);
|
||||||
let v = d.next().unwrap();
|
let v = d.next().unwrap();
|
||||||
assert_eq!(v.annotations().len(), 1);
|
assert_eq!(v.annotations().len(), 1);
|
||||||
assert_eq!(v.annotations()[0], Value::from(2).wrap());
|
assert_eq!(v.annotations()[0], Value::from(2).wrap());
|
||||||
|
@ -200,7 +206,7 @@ mod decoder_tests {
|
||||||
|
|
||||||
#[test] fn skip_annotations_skip() {
|
#[test] fn skip_annotations_skip() {
|
||||||
let mut buf = &b"\x0521"[..];
|
let mut buf = &b"\x0521"[..];
|
||||||
let mut d = Decoder::<_, PlainValue>::new(&mut buf, None);
|
let mut d = Decoder::<_, PlainValue<Dom>, Dom>::new(&mut buf, None);
|
||||||
d.set_read_annotations(false);
|
d.set_read_annotations(false);
|
||||||
let v = d.next().unwrap();
|
let v = d.next().unwrap();
|
||||||
assert_eq!(v.annotations().len(), 0);
|
assert_eq!(v.annotations().len(), 0);
|
||||||
|
@ -210,7 +216,7 @@ mod decoder_tests {
|
||||||
#[test] fn two_values_at_once() {
|
#[test] fn two_values_at_once() {
|
||||||
let mut buf = &b"\x81tPing\x81tPong"[..];
|
let mut buf = &b"\x81tPing\x81tPong"[..];
|
||||||
assert_eq!(buf.len(), 12);
|
assert_eq!(buf.len(), 12);
|
||||||
let mut d = Decoder::<_, PlainValue>::new(&mut buf, None);
|
let mut d = Decoder::<_, PlainValue<Dom>, Dom>::new(&mut buf, None);
|
||||||
assert_eq!(d.next().unwrap().value(), &Value::simple_record("Ping", vec![]));
|
assert_eq!(d.next().unwrap().value(), &Value::simple_record("Ping", vec![]));
|
||||||
assert_eq!(d.next().unwrap().value(), &Value::simple_record("Pong", vec![]));
|
assert_eq!(d.next().unwrap().value(), &Value::simple_record("Pong", vec![]));
|
||||||
assert_eq!(buf.len(), 0);
|
assert_eq!(buf.len(), 0);
|
||||||
|
@ -219,7 +225,7 @@ mod decoder_tests {
|
||||||
#[test] fn buf_advanced() {
|
#[test] fn buf_advanced() {
|
||||||
let mut buf = &b"\x81tPing\x81tPong"[..];
|
let mut buf = &b"\x81tPing\x81tPong"[..];
|
||||||
assert_eq!(buf.len(), 12);
|
assert_eq!(buf.len(), 12);
|
||||||
let mut d = Decoder::<_, PlainValue>::new(&mut buf, None);
|
let mut d = Decoder::<_, PlainValue<Dom>, Dom>::new(&mut buf, None);
|
||||||
assert_eq!(d.next().unwrap().value(), &Value::simple_record("Ping", vec![]));
|
assert_eq!(d.next().unwrap().value(), &Value::simple_record("Ping", vec![]));
|
||||||
assert_eq!(buf.len(), 6);
|
assert_eq!(buf.len(), 6);
|
||||||
}
|
}
|
||||||
|
@ -233,9 +239,10 @@ mod samples_tests {
|
||||||
use crate::value::DecodePlaceholderMap;
|
use crate::value::DecodePlaceholderMap;
|
||||||
use crate::value::to_value;
|
use crate::value::to_value;
|
||||||
use crate::value::from_value;
|
use crate::value::from_value;
|
||||||
|
use super::Dom;
|
||||||
|
|
||||||
#[derive(Debug, serde::Serialize, serde::Deserialize)]
|
#[derive(Debug, serde::Serialize, serde::Deserialize)]
|
||||||
struct ExpectedPlaceholderMapping(DecodePlaceholderMap<PlainValue>);
|
struct ExpectedPlaceholderMapping(DecodePlaceholderMap<PlainValue<Dom>, Dom>);
|
||||||
|
|
||||||
#[derive(Debug, serde::Serialize, serde::Deserialize)]
|
#[derive(Debug, serde::Serialize, serde::Deserialize)]
|
||||||
struct TestCases {
|
struct TestCases {
|
||||||
|
@ -245,9 +252,9 @@ mod samples_tests {
|
||||||
|
|
||||||
#[derive(Debug, serde::Serialize, serde::Deserialize)]
|
#[derive(Debug, serde::Serialize, serde::Deserialize)]
|
||||||
enum TestCase {
|
enum TestCase {
|
||||||
Test(#[serde(with = "serde_bytes")] Vec<u8>, PlainValue),
|
Test(#[serde(with = "serde_bytes")] Vec<u8>, PlainValue<Dom>),
|
||||||
NondeterministicTest(#[serde(with = "serde_bytes")] Vec<u8>, PlainValue),
|
NondeterministicTest(#[serde(with = "serde_bytes")] Vec<u8>, PlainValue<Dom>),
|
||||||
StreamingTest(#[serde(with = "serde_bytes")] Vec<u8>, PlainValue),
|
StreamingTest(#[serde(with = "serde_bytes")] Vec<u8>, PlainValue<Dom>),
|
||||||
ParseError(String),
|
ParseError(String),
|
||||||
ParseShort(String),
|
ParseShort(String),
|
||||||
DecodeError(#[serde(with = "serde_bytes")] Vec<u8>),
|
DecodeError(#[serde(with = "serde_bytes")] Vec<u8>),
|
||||||
|
@ -256,7 +263,7 @@ mod samples_tests {
|
||||||
|
|
||||||
#[test] fn run() -> std::io::Result<()> {
|
#[test] fn run() -> std::io::Result<()> {
|
||||||
let mut fh = std::fs::File::open("../../tests/samples.bin").unwrap();
|
let mut fh = std::fs::File::open("../../tests/samples.bin").unwrap();
|
||||||
let mut d = Decoder::<_, PlainValue>::new(&mut fh, None);
|
let mut d = Decoder::<_, PlainValue<Dom>, Dom>::new(&mut fh, None);
|
||||||
let tests: TestCases = from_value(&d.next().unwrap()).unwrap();
|
let tests: TestCases = from_value(&d.next().unwrap()).unwrap();
|
||||||
// println!("{:#?}", tests);
|
// println!("{:#?}", tests);
|
||||||
|
|
||||||
|
@ -312,7 +319,7 @@ mod samples_tests {
|
||||||
#[serde(with = "serde_bytes")] &'a [u8],
|
#[serde(with = "serde_bytes")] &'a [u8],
|
||||||
#[serde(with = "serde_bytes")] Vec<u8>,
|
#[serde(with = "serde_bytes")] Vec<u8>,
|
||||||
i16,
|
i16,
|
||||||
PlainValue);
|
PlainValue<Dom>);
|
||||||
let v = SimpleValue("hello".to_string(),
|
let v = SimpleValue("hello".to_string(),
|
||||||
"sym1".to_string(),
|
"sym1".to_string(),
|
||||||
Symbol("sym2".to_string()),
|
Symbol("sym2".to_string()),
|
||||||
|
@ -322,7 +329,7 @@ mod samples_tests {
|
||||||
12345,
|
12345,
|
||||||
Value::from("hi").wrap());
|
Value::from("hi").wrap());
|
||||||
println!("{:#?}", v);
|
println!("{:#?}", v);
|
||||||
let w: PlainValue = to_value(&v).unwrap();
|
let w: PlainValue<Dom> = to_value(&v).unwrap();
|
||||||
println!("{:#?}", w);
|
println!("{:#?}", w);
|
||||||
let x = from_value(&w).unwrap();
|
let x = from_value(&w).unwrap();
|
||||||
println!("{:#?}", &x);
|
println!("{:#?}", &x);
|
||||||
|
|
|
@ -5,13 +5,13 @@ pub struct Symbol(pub String);
|
||||||
|
|
||||||
impl serde::Serialize for Symbol {
|
impl serde::Serialize for Symbol {
|
||||||
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: serde::Serializer {
|
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: serde::Serializer {
|
||||||
Value::<PlainValue>::symbol(&self.0).wrap().serialize(serializer)
|
Value::<PlainValue<()>, ()>::symbol(&self.0).wrap().serialize(serializer)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'de> serde::Deserialize<'de> for Symbol {
|
impl<'de> serde::Deserialize<'de> for Symbol {
|
||||||
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: serde::Deserializer<'de> {
|
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: serde::Deserializer<'de> {
|
||||||
let v = PlainValue::deserialize(deserializer)?;
|
let v = PlainValue::<()>::deserialize(deserializer)?;
|
||||||
let s = v.value().as_symbol().ok_or_else(|| serde::de::Error::custom("Expected symbol"))?;
|
let s = v.value().as_symbol().ok_or_else(|| serde::de::Error::custom("Expected symbol"))?;
|
||||||
Ok(Symbol(s.clone()))
|
Ok(Symbol(s.clone()))
|
||||||
}
|
}
|
||||||
|
|
|
@ -1,15 +1,15 @@
|
||||||
use crate::value::{decoder, encoder, invert_map, NestedValue};
|
use crate::value::{decoder, encoder, invert_map, NestedValue, Domain};
|
||||||
use decoder::{Decoder, DecodePlaceholderMap};
|
use decoder::{Decoder, DecodePlaceholderMap};
|
||||||
use encoder::{Encoder, EncodePlaceholderMap};
|
use encoder::{Encoder, EncodePlaceholderMap};
|
||||||
use std::io::{Read, Write};
|
use std::io::{Read, Write};
|
||||||
|
|
||||||
pub struct Codec<N: NestedValue> {
|
pub struct Codec<N: NestedValue<D>, D: Domain> {
|
||||||
pub decode_placeholders: Option<DecodePlaceholderMap<N>>,
|
pub decode_placeholders: Option<DecodePlaceholderMap<N, D>>,
|
||||||
pub encode_placeholders: Option<EncodePlaceholderMap<N>>,
|
pub encode_placeholders: Option<EncodePlaceholderMap<N, D>>,
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<N: NestedValue> Codec<N> {
|
impl<N: NestedValue<D>, D: Domain> Codec<N, D> {
|
||||||
pub fn new(decode_placeholders: DecodePlaceholderMap<N>) -> Self {
|
pub fn new(decode_placeholders: DecodePlaceholderMap<N, D>) -> Self {
|
||||||
let encode_placeholders = Some(invert_map(&decode_placeholders));
|
let encode_placeholders = Some(invert_map(&decode_placeholders));
|
||||||
Codec { decode_placeholders: Some(decode_placeholders), encode_placeholders }
|
Codec { decode_placeholders: Some(decode_placeholders), encode_placeholders }
|
||||||
}
|
}
|
||||||
|
@ -18,11 +18,11 @@ impl<N: NestedValue> Codec<N> {
|
||||||
Codec { decode_placeholders: None, encode_placeholders: None }
|
Codec { decode_placeholders: None, encode_placeholders: None }
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn decoder<'a, 'r, R: Read>(&'a self, read: &'r mut R) -> Decoder<'r, 'a, R, N> {
|
pub fn decoder<'a, 'r, R: Read>(&'a self, read: &'r mut R) -> Decoder<'r, 'a, R, N, D> {
|
||||||
Decoder::new(read, self.decode_placeholders.as_ref())
|
Decoder::new(read, self.decode_placeholders.as_ref())
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn encoder<'a, 'w, W: Write>(&'a self, write: &'w mut W) -> Encoder<'w, 'a, W, N> {
|
pub fn encoder<'a, 'w, W: Write>(&'a self, write: &'w mut W) -> Encoder<'w, 'a, W, N, D> {
|
||||||
Encoder::new(write, self.encode_placeholders.as_ref())
|
Encoder::new(write, self.encode_placeholders.as_ref())
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
|
@ -1,4 +1,4 @@
|
||||||
use crate::value::{Value, NestedValue, Map};
|
use crate::value::{Value, NestedValue, Map, Domain};
|
||||||
use crate::value::value::{Float, Double};
|
use crate::value::value::{Float, Double};
|
||||||
use crate::value::error::{Error, Result, ExpectedKind};
|
use crate::value::error::{Error, Result, ExpectedKind};
|
||||||
use num::traits::cast::ToPrimitive;
|
use num::traits::cast::ToPrimitive;
|
||||||
|
@ -6,33 +6,39 @@ use serde::Deserialize;
|
||||||
use serde::de::{Visitor, SeqAccess, MapAccess, EnumAccess, VariantAccess, DeserializeSeed};
|
use serde::de::{Visitor, SeqAccess, MapAccess, EnumAccess, VariantAccess, DeserializeSeed};
|
||||||
use std::convert::TryFrom;
|
use std::convert::TryFrom;
|
||||||
use std::iter::Iterator;
|
use std::iter::Iterator;
|
||||||
|
use std::marker::PhantomData;
|
||||||
|
|
||||||
pub struct Deserializer<'de, N: NestedValue> {
|
pub struct Deserializer<'de, N: NestedValue<D>, D: Domain> {
|
||||||
input: &'de N,
|
input: &'de N,
|
||||||
|
phantom: PhantomData<D>,
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn from_value<'a, T, N: NestedValue>(v: &'a N) -> Result<T> where T: Deserialize<'a> {
|
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 mut de = Deserializer::from_value(v);
|
||||||
let t = T::deserialize(&mut de)?;
|
let t = T::deserialize(&mut de)?;
|
||||||
Ok(t)
|
Ok(t)
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'de, N: NestedValue> Deserializer<'de, N> {
|
impl<'de, N: NestedValue<D>, D: 'de + Domain> Deserializer<'de, N, D> {
|
||||||
pub fn from_value(v: &'de N) -> Self {
|
pub fn from_value(v: &'de N) -> Self {
|
||||||
Deserializer{ input: v }
|
Deserializer{ input: v, phantom: PhantomData }
|
||||||
}
|
}
|
||||||
|
|
||||||
fn check<'a, T, F>(&'a mut self, f: F, k: ExpectedKind) -> Result<T>
|
fn check<'a, T, F>(&'a mut self, f: F, k: ExpectedKind) -> Result<T, D>
|
||||||
where F: FnOnce(&'de Value<N>) -> Option<T>
|
where F: FnOnce(&'de Value<N, D>) -> Option<T>
|
||||||
{
|
{
|
||||||
f(self.input.value()).ok_or_else(|| Error::Expected(k, self.input.copy_via()))
|
f(self.input.value()).ok_or_else(|| Error::Expected(k, self.input.copy_via()))
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'de, 'a, N: NestedValue> serde::de::Deserializer<'de> for &'a mut Deserializer<'de, N> {
|
impl<'de, 'a, N: NestedValue<D>, D: 'de + Domain> serde::de::Deserializer<'de>
|
||||||
type Error = Error;
|
for &'a mut Deserializer<'de, N, D>
|
||||||
|
{
|
||||||
|
type Error = Error<D>;
|
||||||
|
|
||||||
fn deserialize_any<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>
|
fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, D> where V: Visitor<'de>
|
||||||
{
|
{
|
||||||
let v = self.input.value();
|
let v = self.input.value();
|
||||||
match v {
|
match v {
|
||||||
|
@ -67,70 +73,70 @@ impl<'de, 'a, N: NestedValue> serde::de::Deserializer<'de> for &'a mut Deseriali
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>
|
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)?)
|
visitor.visit_bool(self.check(|v| v.as_boolean(), ExpectedKind::Boolean)?)
|
||||||
}
|
}
|
||||||
|
|
||||||
fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>
|
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)?;
|
let i = self.check(|v| v.as_signedinteger(), ExpectedKind::SignedInteger)?;
|
||||||
visitor.visit_i8(i.to_i8().ok_or_else(|| Error::NumberTooLarge(i.clone()))?)
|
visitor.visit_i8(i.to_i8().ok_or_else(|| Error::NumberTooLarge(i.clone()))?)
|
||||||
}
|
}
|
||||||
|
|
||||||
fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>
|
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)?;
|
let i = self.check(|v| v.as_signedinteger(), ExpectedKind::SignedInteger)?;
|
||||||
visitor.visit_i16(i.to_i16().ok_or_else(|| Error::NumberTooLarge(i.clone()))?)
|
visitor.visit_i16(i.to_i16().ok_or_else(|| Error::NumberTooLarge(i.clone()))?)
|
||||||
}
|
}
|
||||||
|
|
||||||
fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>
|
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)?;
|
let i = self.check(|v| v.as_signedinteger(), ExpectedKind::SignedInteger)?;
|
||||||
visitor.visit_i32(i.to_i32().ok_or_else(|| Error::NumberTooLarge(i.clone()))?)
|
visitor.visit_i32(i.to_i32().ok_or_else(|| Error::NumberTooLarge(i.clone()))?)
|
||||||
}
|
}
|
||||||
|
|
||||||
fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>
|
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)?;
|
let i = self.check(|v| v.as_signedinteger(), ExpectedKind::SignedInteger)?;
|
||||||
visitor.visit_i64(i.to_i64().ok_or_else(|| Error::NumberTooLarge(i.clone()))?)
|
visitor.visit_i64(i.to_i64().ok_or_else(|| Error::NumberTooLarge(i.clone()))?)
|
||||||
}
|
}
|
||||||
|
|
||||||
fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>
|
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)?;
|
let i = self.check(|v| v.as_signedinteger(), ExpectedKind::SignedInteger)?;
|
||||||
visitor.visit_u8(i.to_u8().ok_or_else(|| Error::NumberTooLarge(i.clone()))?)
|
visitor.visit_u8(i.to_u8().ok_or_else(|| Error::NumberTooLarge(i.clone()))?)
|
||||||
}
|
}
|
||||||
|
|
||||||
fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>
|
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)?;
|
let i = self.check(|v| v.as_signedinteger(), ExpectedKind::SignedInteger)?;
|
||||||
visitor.visit_u16(i.to_u16().ok_or_else(|| Error::NumberTooLarge(i.clone()))?)
|
visitor.visit_u16(i.to_u16().ok_or_else(|| Error::NumberTooLarge(i.clone()))?)
|
||||||
}
|
}
|
||||||
|
|
||||||
fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>
|
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)?;
|
let i = self.check(|v| v.as_signedinteger(), ExpectedKind::SignedInteger)?;
|
||||||
visitor.visit_u32(i.to_u32().ok_or_else(|| Error::NumberTooLarge(i.clone()))?)
|
visitor.visit_u32(i.to_u32().ok_or_else(|| Error::NumberTooLarge(i.clone()))?)
|
||||||
}
|
}
|
||||||
|
|
||||||
fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>
|
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)?;
|
let i = self.check(|v| v.as_signedinteger(), ExpectedKind::SignedInteger)?;
|
||||||
visitor.visit_u64(i.to_u64().ok_or_else(|| Error::NumberTooLarge(i.clone()))?)
|
visitor.visit_u64(i.to_u64().ok_or_else(|| Error::NumberTooLarge(i.clone()))?)
|
||||||
}
|
}
|
||||||
|
|
||||||
fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>
|
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)?)
|
visitor.visit_f32(self.check(|v| v.as_float(), ExpectedKind::Float)?)
|
||||||
}
|
}
|
||||||
|
|
||||||
fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>
|
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)?)
|
visitor.visit_f64(self.check(|v| v.as_double(), ExpectedKind::Double)?)
|
||||||
}
|
}
|
||||||
|
|
||||||
fn deserialize_char<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>
|
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)),
|
let fs = self.check(|v| v.as_simple_record("UnicodeScalar", Some(1)),
|
||||||
ExpectedKind::SimpleRecord("UnicodeScalar", Some(1)))?;
|
ExpectedKind::SimpleRecord("UnicodeScalar", Some(1)))?;
|
||||||
|
@ -139,27 +145,27 @@ impl<'de, 'a, N: NestedValue> serde::de::Deserializer<'de> for &'a mut Deseriali
|
||||||
visitor.visit_char(char::try_from(c).or(Err(Error::InvalidUnicodeScalar(c)))?)
|
visitor.visit_char(char::try_from(c).or(Err(Error::InvalidUnicodeScalar(c)))?)
|
||||||
}
|
}
|
||||||
|
|
||||||
fn deserialize_str<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>
|
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)?)
|
visitor.visit_borrowed_str(&self.check(|v| v.as_string(), ExpectedKind::String)?)
|
||||||
}
|
}
|
||||||
|
|
||||||
fn deserialize_string<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>
|
fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, D> where V: Visitor<'de>
|
||||||
{
|
{
|
||||||
self.deserialize_str(visitor)
|
self.deserialize_str(visitor)
|
||||||
}
|
}
|
||||||
|
|
||||||
fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>
|
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)?)
|
visitor.visit_borrowed_bytes(&self.check(|v| v.as_bytestring(), ExpectedKind::ByteString)?)
|
||||||
}
|
}
|
||||||
|
|
||||||
fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>
|
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())
|
visitor.visit_byte_buf(self.check(|v| v.as_bytestring(), ExpectedKind::ByteString)?.clone())
|
||||||
}
|
}
|
||||||
|
|
||||||
fn deserialize_option<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>
|
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)) {
|
match self.input.value().as_simple_record("None", Some(0)) {
|
||||||
Some(_fs) => visitor.visit_none(),
|
Some(_fs) => visitor.visit_none(),
|
||||||
|
@ -173,7 +179,7 @@ impl<'de, 'a, N: NestedValue> serde::de::Deserializer<'de> for &'a mut Deseriali
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>
|
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)) {
|
if self.input.value().is_simple_record("tuple", Some(0)) {
|
||||||
visitor.visit_unit()
|
visitor.visit_unit()
|
||||||
|
@ -183,7 +189,7 @@ impl<'de, 'a, N: NestedValue> serde::de::Deserializer<'de> for &'a mut Deseriali
|
||||||
}
|
}
|
||||||
|
|
||||||
fn deserialize_unit_struct<V>(self, name: &'static str, visitor: V)
|
fn deserialize_unit_struct<V>(self, name: &'static str, visitor: V)
|
||||||
-> Result<V::Value> where V: Visitor<'de>
|
-> Result<V::Value, D> where V: Visitor<'de>
|
||||||
{
|
{
|
||||||
if self.input.value().is_simple_record(name, Some(0)) {
|
if self.input.value().is_simple_record(name, Some(0)) {
|
||||||
visitor.visit_unit()
|
visitor.visit_unit()
|
||||||
|
@ -193,7 +199,7 @@ impl<'de, 'a, N: NestedValue> serde::de::Deserializer<'de> for &'a mut Deseriali
|
||||||
}
|
}
|
||||||
|
|
||||||
fn deserialize_newtype_struct<V>(self, name: &'static str, visitor: V)
|
fn deserialize_newtype_struct<V>(self, name: &'static str, visitor: V)
|
||||||
-> Result<V::Value> where V: Visitor<'de>
|
-> Result<V::Value, D> where V: Visitor<'de>
|
||||||
{
|
{
|
||||||
if name == crate::value::value::MAGIC {
|
if name == crate::value::value::MAGIC {
|
||||||
let mut buf: Vec<u8> = Vec::new();
|
let mut buf: Vec<u8> = Vec::new();
|
||||||
|
@ -208,12 +214,12 @@ impl<'de, 'a, N: NestedValue> serde::de::Deserializer<'de> for &'a mut Deseriali
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de> {
|
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)?;
|
let vs = self.check(|v| v.as_sequence(), ExpectedKind::Sequence)?;
|
||||||
visitor.visit_seq(VecSeq::new(self, vs))
|
visitor.visit_seq(VecSeq::new(self, vs))
|
||||||
}
|
}
|
||||||
|
|
||||||
fn deserialize_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value> where V: Visitor<'de>
|
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)),
|
let fs = self.check(|v| v.as_simple_record("tuple", Some(len)),
|
||||||
ExpectedKind::SimpleRecord("tuple", Some(len)))?;
|
ExpectedKind::SimpleRecord("tuple", Some(len)))?;
|
||||||
|
@ -221,14 +227,14 @@ impl<'de, 'a, N: NestedValue> serde::de::Deserializer<'de> for &'a mut Deseriali
|
||||||
}
|
}
|
||||||
|
|
||||||
fn deserialize_tuple_struct<V>(self, name: &'static str, len: usize, visitor: V)
|
fn deserialize_tuple_struct<V>(self, name: &'static str, len: usize, visitor: V)
|
||||||
-> Result<V::Value> where V: Visitor<'de>
|
-> Result<V::Value, D> where V: Visitor<'de>
|
||||||
{
|
{
|
||||||
let fs = self.check(|v| v.as_simple_record(name, Some(len)),
|
let fs = self.check(|v| v.as_simple_record(name, Some(len)),
|
||||||
ExpectedKind::SimpleRecord(name, Some(len)))?;
|
ExpectedKind::SimpleRecord(name, Some(len)))?;
|
||||||
visitor.visit_seq(VecSeq::new(self, fs))
|
visitor.visit_seq(VecSeq::new(self, fs))
|
||||||
}
|
}
|
||||||
|
|
||||||
fn deserialize_map<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de> {
|
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)?;
|
let d = self.check(|v| v.as_dictionary(), ExpectedKind::Dictionary)?;
|
||||||
visitor.visit_map(DictMap::new(self, d))
|
visitor.visit_map(DictMap::new(self, d))
|
||||||
}
|
}
|
||||||
|
@ -237,7 +243,7 @@ impl<'de, 'a, N: NestedValue> serde::de::Deserializer<'de> for &'a mut Deseriali
|
||||||
name: &'static str,
|
name: &'static str,
|
||||||
fields: &'static [&'static str],
|
fields: &'static [&'static str],
|
||||||
visitor: V)
|
visitor: V)
|
||||||
-> Result<V::Value> where V: Visitor<'de>
|
-> Result<V::Value, D> where V: Visitor<'de>
|
||||||
{
|
{
|
||||||
let fs = self.check(|v| v.as_simple_record(name, Some(fields.len())),
|
let fs = self.check(|v| v.as_simple_record(name, Some(fields.len())),
|
||||||
ExpectedKind::SimpleRecord(name, Some(fields.len())))?;
|
ExpectedKind::SimpleRecord(name, Some(fields.len())))?;
|
||||||
|
@ -248,39 +254,39 @@ impl<'de, 'a, N: NestedValue> serde::de::Deserializer<'de> for &'a mut Deseriali
|
||||||
_name: &'static str,
|
_name: &'static str,
|
||||||
_variants: &'static [&'static str],
|
_variants: &'static [&'static str],
|
||||||
visitor: V)
|
visitor: V)
|
||||||
-> Result<V::Value> where V: Visitor<'de>
|
-> Result<V::Value, D> where V: Visitor<'de>
|
||||||
{
|
{
|
||||||
visitor.visit_enum(self)
|
visitor.visit_enum(self)
|
||||||
}
|
}
|
||||||
|
|
||||||
fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>
|
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)?)
|
visitor.visit_borrowed_str(&self.check(|v| v.as_symbol(), ExpectedKind::Symbol)?)
|
||||||
}
|
}
|
||||||
|
|
||||||
fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>
|
fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, D> where V: Visitor<'de>
|
||||||
{
|
{
|
||||||
visitor.visit_none()
|
visitor.visit_none()
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
pub struct VecSeq<'a, 'de: 'a, N: NestedValue> {
|
pub struct VecSeq<'a, 'de: 'a, N: NestedValue<D>, D: Domain> {
|
||||||
index: usize,
|
index: usize,
|
||||||
vec: &'de [N],
|
vec: &'de [N],
|
||||||
de: &'a mut Deserializer<'de, N>,
|
de: &'a mut Deserializer<'de, N, D>,
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'de, 'a, N: NestedValue> VecSeq<'a, 'de, N> {
|
impl<'de, 'a, N: NestedValue<D>, D: Domain> VecSeq<'a, 'de, N, D> {
|
||||||
fn new(de: &'a mut Deserializer<'de, N>, vec: &'de [N]) -> Self {
|
fn new(de: &'a mut Deserializer<'de, N, D>, vec: &'de [N]) -> Self {
|
||||||
VecSeq{ index: 0, vec, de }
|
VecSeq{ index: 0, vec, de }
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'de, 'a, N: NestedValue> SeqAccess<'de> for VecSeq<'a, 'de, N> {
|
impl<'de, 'a, N: NestedValue<D>, D: 'de + Domain> SeqAccess<'de> for VecSeq<'a, 'de, N, D> {
|
||||||
type Error = Error;
|
type Error = Error<D>;
|
||||||
|
|
||||||
fn next_element_seed<T>(&mut self, seed: T)
|
fn next_element_seed<T>(&mut self, seed: T)
|
||||||
-> Result<Option<T::Value>> where T: DeserializeSeed<'de>
|
-> Result<Option<T::Value>, D> where T: DeserializeSeed<'de>
|
||||||
{
|
{
|
||||||
if self.index == self.vec.len() {
|
if self.index == self.vec.len() {
|
||||||
return Ok(None)
|
return Ok(None)
|
||||||
|
@ -293,23 +299,23 @@ impl<'de, 'a, N: NestedValue> SeqAccess<'de> for VecSeq<'a, 'de, N> {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
pub struct DictMap<'a, 'de: 'a, N: NestedValue> {
|
pub struct DictMap<'a, 'de: 'a, N: NestedValue<D>, D: Domain> {
|
||||||
pending: Option<&'de N>,
|
pending: Option<&'de N>,
|
||||||
iter: Box<dyn Iterator<Item = (&'de N, &'de N)> + 'a>,
|
iter: Box<dyn Iterator<Item = (&'de N, &'de N)> + 'a>,
|
||||||
de: &'a mut Deserializer<'de, N>,
|
de: &'a mut Deserializer<'de, N, D>,
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'de, 'a, N: NestedValue> DictMap<'a, 'de, N> {
|
impl<'de, 'a, N: NestedValue<D>, D: Domain> DictMap<'a, 'de, N, D> {
|
||||||
fn new(de: &'a mut Deserializer<'de, N>, d: &'de Map<N, N>) -> Self {
|
fn new(de: &'a mut Deserializer<'de, N, D>, d: &'de Map<N, N>) -> Self {
|
||||||
DictMap{ pending: None, iter: Box::new(d.iter()), de }
|
DictMap{ pending: None, iter: Box::new(d.iter()), de }
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'de, 'a, N: NestedValue> MapAccess<'de> for DictMap<'a, 'de, N> {
|
impl<'de, 'a, N: NestedValue<D>, D: 'de + Domain> MapAccess<'de> for DictMap<'a, 'de, N, D> {
|
||||||
type Error = Error;
|
type Error = Error<D>;
|
||||||
|
|
||||||
fn next_key_seed<K>(&mut self, seed: K)
|
fn next_key_seed<K>(&mut self, seed: K)
|
||||||
-> Result<Option<K::Value>> where K: DeserializeSeed<'de>
|
-> Result<Option<K::Value>, D> where K: DeserializeSeed<'de>
|
||||||
{
|
{
|
||||||
match self.iter.next() {
|
match self.iter.next() {
|
||||||
None => Ok(None),
|
None => Ok(None),
|
||||||
|
@ -321,7 +327,7 @@ impl<'de, 'a, N: NestedValue> MapAccess<'de> for DictMap<'a, 'de, N> {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value> where V: DeserializeSeed<'de> {
|
fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, D> where V: DeserializeSeed<'de> {
|
||||||
let v = self.pending.unwrap();
|
let v = self.pending.unwrap();
|
||||||
self.pending = None;
|
self.pending = None;
|
||||||
self.de.input = v;
|
self.de.input = v;
|
||||||
|
@ -329,12 +335,12 @@ impl<'de, 'a, N: NestedValue> MapAccess<'de> for DictMap<'a, 'de, N> {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'a, 'de, N: NestedValue> EnumAccess<'de> for &'a mut Deserializer<'de, N> {
|
impl<'a, 'de, N: NestedValue<D>, D: 'de + Domain> EnumAccess<'de> for &'a mut Deserializer<'de, N, D> {
|
||||||
type Error = Error;
|
type Error = Error<D>;
|
||||||
type Variant = Self;
|
type Variant = Self;
|
||||||
|
|
||||||
fn variant_seed<V>(self, seed: V)
|
fn variant_seed<V>(self, seed: V)
|
||||||
-> Result<(V::Value, Self::Variant)> where V: DeserializeSeed<'de>
|
-> Result<(V::Value, Self::Variant), D> where V: DeserializeSeed<'de>
|
||||||
{
|
{
|
||||||
let (lp, _) = self.check(|v| v.as_record(), ExpectedKind::Record)?;
|
let (lp, _) = self.check(|v| v.as_record(), ExpectedKind::Record)?;
|
||||||
let v = self.input;
|
let v = self.input;
|
||||||
|
@ -345,25 +351,25 @@ impl<'a, 'de, N: NestedValue> EnumAccess<'de> for &'a mut Deserializer<'de, N> {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'a, 'de, N: NestedValue> VariantAccess<'de> for &'a mut Deserializer<'de, N> {
|
impl<'a, 'de, N: NestedValue<D>, D: 'de + Domain> VariantAccess<'de> for &'a mut Deserializer<'de, N, D> {
|
||||||
type Error = Error;
|
type Error = Error<D>;
|
||||||
|
|
||||||
fn unit_variant(self) -> Result<()> {
|
fn unit_variant(self) -> Result<(), D> {
|
||||||
Ok(())
|
Ok(())
|
||||||
}
|
}
|
||||||
|
|
||||||
fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value> where T: DeserializeSeed<'de> {
|
fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, D> where T: DeserializeSeed<'de> {
|
||||||
let (_, fs) = self.input.value().as_record().unwrap();
|
let (_, fs) = self.input.value().as_record().unwrap();
|
||||||
self.input = &fs[0];
|
self.input = &fs[0];
|
||||||
seed.deserialize(&mut *self)
|
seed.deserialize(&mut *self)
|
||||||
}
|
}
|
||||||
|
|
||||||
fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value> where V: Visitor<'de> {
|
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().unwrap().1))
|
visitor.visit_seq(VecSeq::new(self, &self.input.value().as_record().unwrap().1))
|
||||||
}
|
}
|
||||||
|
|
||||||
fn struct_variant<V>(self, _fields: &'static [&'static str], visitor: V)
|
fn struct_variant<V>(self, _fields: &'static [&'static str], visitor: V)
|
||||||
-> Result<V::Value> where V: Visitor<'de>
|
-> Result<V::Value, D> where V: Visitor<'de>
|
||||||
{
|
{
|
||||||
visitor.visit_seq(VecSeq::new(self, &self.input.value().as_record().unwrap().1))
|
visitor.visit_seq(VecSeq::new(self, &self.input.value().as_record().unwrap().1))
|
||||||
}
|
}
|
||||||
|
|
|
@ -1,7 +1,7 @@
|
||||||
use std::io::{Read, ErrorKind};
|
use std::io::{Read, ErrorKind};
|
||||||
use std::convert::TryInto;
|
use std::convert::TryInto;
|
||||||
use std::convert::TryFrom;
|
use std::convert::TryFrom;
|
||||||
use crate::value::{Value, NestedValue, Set, Map};
|
use crate::value::{Value, NestedValue, Set, Map, Domain};
|
||||||
use num::bigint::BigInt;
|
use num::bigint::BigInt;
|
||||||
use crate::value::constants::{Op, InvalidOp, AtomMinor, CompoundMinor};
|
use crate::value::constants::{Op, InvalidOp, AtomMinor, CompoundMinor};
|
||||||
|
|
||||||
|
@ -48,7 +48,7 @@ impl Error {
|
||||||
pub fn is_eof(&self) -> bool { if let Error::Eof = *self { true } else { false } }
|
pub fn is_eof(&self) -> bool { if let Error::Eof = *self { true } else { false } }
|
||||||
}
|
}
|
||||||
|
|
||||||
pub type DecodePlaceholderMap<N> = Map<usize, Value<N>>;
|
pub type DecodePlaceholderMap<N, D> = Map<usize, Value<N, D>>;
|
||||||
|
|
||||||
#[derive(PartialEq, Eq)]
|
#[derive(PartialEq, Eq)]
|
||||||
enum PeekState {
|
enum PeekState {
|
||||||
|
@ -57,11 +57,11 @@ enum PeekState {
|
||||||
Full(u8),
|
Full(u8),
|
||||||
}
|
}
|
||||||
|
|
||||||
pub struct Decoder<'a, 'b, R: Read, N: NestedValue> {
|
pub struct Decoder<'a, 'b, R: Read, N: NestedValue<D>, D: Domain> {
|
||||||
read: &'a mut R,
|
read: &'a mut R,
|
||||||
index: usize,
|
index: usize,
|
||||||
buf: Box<PeekState>,
|
buf: Box<PeekState>,
|
||||||
placeholders: Option<&'b DecodePlaceholderMap<N>>,
|
placeholders: Option<&'b DecodePlaceholderMap<N, D>>,
|
||||||
read_annotations: bool,
|
read_annotations: bool,
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -69,8 +69,8 @@ fn decodeint(bs: &[u8]) -> BigInt {
|
||||||
BigInt::from_signed_bytes_be(bs)
|
BigInt::from_signed_bytes_be(bs)
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'a, 'b, R: Read, N: NestedValue> Decoder<'a, 'b, R, N> {
|
impl<'a, 'b, R: Read, N: NestedValue<D>, D: Domain> Decoder<'a, 'b, R, N, D> {
|
||||||
pub fn new(read: &'a mut R, placeholders: Option<&'b DecodePlaceholderMap<N>>) -> Self {
|
pub fn new(read: &'a mut R, placeholders: Option<&'b DecodePlaceholderMap<N, D>>) -> Self {
|
||||||
Decoder{
|
Decoder{
|
||||||
read,
|
read,
|
||||||
index: 0,
|
index: 0,
|
||||||
|
@ -190,7 +190,7 @@ impl<'a, 'b, R: Read, N: NestedValue> Decoder<'a, 'b, R, N> {
|
||||||
Ok(match minor {
|
Ok(match minor {
|
||||||
AtomMinor::SignedInteger => Value::from(decodeint(&bs)).wrap(),
|
AtomMinor::SignedInteger => Value::from(decodeint(&bs)).wrap(),
|
||||||
AtomMinor::String => Value::from(std::str::from_utf8(&bs)?).wrap(),
|
AtomMinor::String => Value::from(std::str::from_utf8(&bs)?).wrap(),
|
||||||
AtomMinor::ByteString => Value::from(bs).wrap(),
|
AtomMinor::ByteString => Value::from(&bs as &[u8]).wrap(),
|
||||||
AtomMinor::Symbol => Value::symbol(std::str::from_utf8(&bs)?).wrap(),
|
AtomMinor::Symbol => Value::symbol(std::str::from_utf8(&bs)?).wrap(),
|
||||||
})
|
})
|
||||||
}
|
}
|
||||||
|
|
|
@ -1,5 +1,5 @@
|
||||||
use std::io::Write;
|
use std::io::Write;
|
||||||
use crate::value::value::{Value, NestedValue, Float, Double, Map};
|
use crate::value::value::{Value, NestedValue, Float, Double, Map, Domain};
|
||||||
use num::bigint::BigInt;
|
use num::bigint::BigInt;
|
||||||
use num::cast::ToPrimitive;
|
use num::cast::ToPrimitive;
|
||||||
use crate::value::constants::{Op, AtomMinor, CompoundMinor};
|
use crate::value::constants::{Op, AtomMinor, CompoundMinor};
|
||||||
|
@ -7,15 +7,15 @@ use crate::value::constants::{Op, AtomMinor, CompoundMinor};
|
||||||
pub type Error = std::io::Error;
|
pub type Error = std::io::Error;
|
||||||
pub type Result = std::result::Result<(), Error>;
|
pub type Result = std::result::Result<(), Error>;
|
||||||
|
|
||||||
pub type EncodePlaceholderMap<N> = Map<Value<N>, usize>;
|
pub type EncodePlaceholderMap<N, D> = Map<Value<N, D>, usize>;
|
||||||
|
|
||||||
pub struct Encoder<'a, 'b, W: Write, N: NestedValue> {
|
pub struct Encoder<'a, 'b, W: Write, N: NestedValue<D>, D: Domain> {
|
||||||
write: &'a mut W,
|
write: &'a mut W,
|
||||||
placeholders: Option<&'b EncodePlaceholderMap<N>>,
|
placeholders: Option<&'b EncodePlaceholderMap<N, D>>,
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'a, 'b, W: Write, N: NestedValue> Encoder<'a, 'b, W, N> {
|
impl<'a, 'b, W: Write, N: NestedValue<D>, D: Domain> Encoder<'a, 'b, W, N, D> {
|
||||||
pub fn new(write: &'a mut W, placeholders: Option<&'b EncodePlaceholderMap<N>>) -> Self {
|
pub fn new(write: &'a mut W, placeholders: Option<&'b EncodePlaceholderMap<N, D>>) -> Self {
|
||||||
Encoder{ write, placeholders }
|
Encoder{ write, placeholders }
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -78,7 +78,7 @@ impl<'a, 'b, W: Write, N: NestedValue> Encoder<'a, 'b, W, N> {
|
||||||
self.write_value(v.value())
|
self.write_value(v.value())
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn write_value(&mut self, v: &Value<N>) -> Result {
|
pub fn write_value(&mut self, v: &Value<N, D>) -> Result {
|
||||||
match self.placeholders.and_then(|m| m.get(v)) {
|
match self.placeholders.and_then(|m| m.get(v)) {
|
||||||
Some(&n) => self.write_header(Op::Misc(1), n),
|
Some(&n) => self.write_header(Op::Misc(1), n),
|
||||||
None => match v {
|
None => match v {
|
||||||
|
@ -117,6 +117,10 @@ impl<'a, 'b, W: Write, N: NestedValue> Encoder<'a, 'b, W, N> {
|
||||||
for (k, v) in vs { self.write(k)?; self.write(v)?; }
|
for (k, v) in vs { self.write(k)?; self.write(v)?; }
|
||||||
Ok(())
|
Ok(())
|
||||||
}
|
}
|
||||||
|
Value::Domain(ref d) =>
|
||||||
|
Err(Error::new(std::io::ErrorKind::InvalidData,
|
||||||
|
format!("Cannot Preserves-encode domain-specific value {:?}",
|
||||||
|
d))),
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
|
@ -1,13 +1,13 @@
|
||||||
use num::bigint::BigInt;
|
use num::bigint::BigInt;
|
||||||
use crate::value::PlainValue;
|
use crate::value::{PlainValue, Domain};
|
||||||
|
|
||||||
#[derive(Debug)]
|
#[derive(Debug)]
|
||||||
pub enum Error {
|
pub enum Error<D: Domain> {
|
||||||
Message(String),
|
Message(String),
|
||||||
InvalidUnicodeScalar(u32),
|
InvalidUnicodeScalar(u32),
|
||||||
NumberTooLarge(BigInt),
|
NumberTooLarge(BigInt),
|
||||||
CannotDeserializeAny,
|
CannotDeserializeAny,
|
||||||
Expected(ExpectedKind, PlainValue),
|
Expected(ExpectedKind, PlainValue<D>),
|
||||||
InternalMagicError,
|
InternalMagicError,
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -29,23 +29,23 @@ pub enum ExpectedKind {
|
||||||
Dictionary,
|
Dictionary,
|
||||||
}
|
}
|
||||||
|
|
||||||
pub type Result<T> = std::result::Result<T, Error>;
|
pub type Result<T, D> = std::result::Result<T, Error<D>>;
|
||||||
|
|
||||||
impl serde::ser::Error for Error {
|
impl<D: Domain> serde::ser::Error for Error<D> {
|
||||||
fn custom<T: std::fmt::Display>(msg: T) -> Self {
|
fn custom<T: std::fmt::Display>(msg: T) -> Self {
|
||||||
Self::Message(msg.to_string())
|
Self::Message(msg.to_string())
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl serde::de::Error for Error {
|
impl<D: Domain> serde::de::Error for Error<D> {
|
||||||
fn custom<T: std::fmt::Display>(msg: T) -> Self {
|
fn custom<T: std::fmt::Display>(msg: T) -> Self {
|
||||||
Self::Message(msg.to_string())
|
Self::Message(msg.to_string())
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl std::error::Error for Error {}
|
impl<D: Domain> std::error::Error for Error<D> {}
|
||||||
|
|
||||||
impl std::fmt::Display for Error {
|
impl<D: Domain> std::fmt::Display for Error<D> {
|
||||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||||
write!(f, "{:?}", self)
|
write!(f, "{:?}", self)
|
||||||
}
|
}
|
||||||
|
|
|
@ -16,6 +16,7 @@ pub use encoder::EncodePlaceholderMap;
|
||||||
pub use encoder::Encoder;
|
pub use encoder::Encoder;
|
||||||
pub use ser::Serializer;
|
pub use ser::Serializer;
|
||||||
pub use ser::to_value;
|
pub use ser::to_value;
|
||||||
|
pub use value::Domain;
|
||||||
pub use value::NestedValue;
|
pub use value::NestedValue;
|
||||||
pub use value::Value;
|
pub use value::Value;
|
||||||
pub use value::AnnotatedValue;
|
pub use value::AnnotatedValue;
|
||||||
|
|
|
@ -1,106 +1,109 @@
|
||||||
use crate::value::{Value, NestedValue, Map};
|
use crate::value::{Value, NestedValue, Map, Domain};
|
||||||
use serde::Serialize;
|
use serde::Serialize;
|
||||||
use crate::value::error::{Error, Result};
|
use crate::value::error::{Error, Result};
|
||||||
use std::marker::PhantomData;
|
use std::marker::PhantomData;
|
||||||
|
|
||||||
pub struct Serializer<N: NestedValue> {
|
pub struct Serializer<N: NestedValue<D>, D: Domain> {
|
||||||
phantom: PhantomData<N>
|
phantom: PhantomData<(N, D)>,
|
||||||
}
|
}
|
||||||
|
|
||||||
pub struct SerializeDictionary<N: NestedValue> {
|
pub struct SerializeDictionary<N: NestedValue<D>, D: Domain> {
|
||||||
next_key: Option<N>,
|
next_key: Option<N>,
|
||||||
items: Map<N,N>,
|
items: Map<N,N>,
|
||||||
|
phantom: PhantomData<D>,
|
||||||
}
|
}
|
||||||
|
|
||||||
pub struct SerializeRecord<N: NestedValue> {
|
pub struct SerializeRecord<N: NestedValue<D>, D: Domain> {
|
||||||
name: &'static str,
|
name: &'static str,
|
||||||
vec: Vec<N>,
|
vec: Vec<N>,
|
||||||
|
phantom: PhantomData<D>,
|
||||||
}
|
}
|
||||||
|
|
||||||
pub struct SerializeSequence<N: NestedValue> {
|
pub struct SerializeSequence<N: NestedValue<D>, D: Domain> {
|
||||||
vec: Vec<N>,
|
vec: Vec<N>,
|
||||||
|
phantom: PhantomData<D>,
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<N: NestedValue> serde::Serializer for Serializer<N> {
|
impl<N: NestedValue<D>, D: Domain> serde::Serializer for Serializer<N, D> {
|
||||||
type Ok = N;
|
type Ok = N;
|
||||||
type Error = Error;
|
type Error = Error<D>;
|
||||||
type SerializeSeq = SerializeSequence<N>;
|
type SerializeSeq = SerializeSequence<N, D>;
|
||||||
type SerializeTuple = SerializeRecord<N>;
|
type SerializeTuple = SerializeRecord<N, D>;
|
||||||
type SerializeTupleStruct = SerializeRecord<N>;
|
type SerializeTupleStruct = SerializeRecord<N, D>;
|
||||||
type SerializeTupleVariant = SerializeRecord<N>;
|
type SerializeTupleVariant = SerializeRecord<N, D>;
|
||||||
type SerializeMap = SerializeDictionary<N>;
|
type SerializeMap = SerializeDictionary<N, D>;
|
||||||
type SerializeStruct = SerializeRecord<N>;
|
type SerializeStruct = SerializeRecord<N, D>;
|
||||||
type SerializeStructVariant = SerializeRecord<N>;
|
type SerializeStructVariant = SerializeRecord<N, D>;
|
||||||
|
|
||||||
fn serialize_bool(self, v: bool) -> Result<Self::Ok> {
|
fn serialize_bool(self, v: bool) -> Result<Self::Ok, D> {
|
||||||
Ok(Value::from(v).wrap())
|
Ok(Value::from(v).wrap())
|
||||||
}
|
}
|
||||||
|
|
||||||
fn serialize_i8(self, v: i8) -> Result<Self::Ok> {
|
fn serialize_i8(self, v: i8) -> Result<Self::Ok, D> {
|
||||||
Ok(Value::from(v).wrap())
|
Ok(Value::from(v).wrap())
|
||||||
}
|
}
|
||||||
|
|
||||||
fn serialize_i16(self, v: i16) -> Result<Self::Ok> {
|
fn serialize_i16(self, v: i16) -> Result<Self::Ok, D> {
|
||||||
Ok(Value::from(v).wrap())
|
Ok(Value::from(v).wrap())
|
||||||
}
|
}
|
||||||
|
|
||||||
fn serialize_i32(self, v: i32) -> Result<Self::Ok> {
|
fn serialize_i32(self, v: i32) -> Result<Self::Ok, D> {
|
||||||
Ok(Value::from(v).wrap())
|
Ok(Value::from(v).wrap())
|
||||||
}
|
}
|
||||||
|
|
||||||
fn serialize_i64(self, v: i64) -> Result<Self::Ok> {
|
fn serialize_i64(self, v: i64) -> Result<Self::Ok, D> {
|
||||||
Ok(Value::from(v).wrap())
|
Ok(Value::from(v).wrap())
|
||||||
}
|
}
|
||||||
|
|
||||||
fn serialize_u8(self, v: u8) -> Result<Self::Ok> {
|
fn serialize_u8(self, v: u8) -> Result<Self::Ok, D> {
|
||||||
Ok(Value::from(v).wrap())
|
Ok(Value::from(v).wrap())
|
||||||
}
|
}
|
||||||
|
|
||||||
fn serialize_u16(self, v: u16) -> Result<Self::Ok> {
|
fn serialize_u16(self, v: u16) -> Result<Self::Ok, D> {
|
||||||
Ok(Value::from(v).wrap())
|
Ok(Value::from(v).wrap())
|
||||||
}
|
}
|
||||||
|
|
||||||
fn serialize_u32(self, v: u32) -> Result<Self::Ok> {
|
fn serialize_u32(self, v: u32) -> Result<Self::Ok, D> {
|
||||||
Ok(Value::from(v).wrap())
|
Ok(Value::from(v).wrap())
|
||||||
}
|
}
|
||||||
|
|
||||||
fn serialize_u64(self, v: u64) -> Result<Self::Ok> {
|
fn serialize_u64(self, v: u64) -> Result<Self::Ok, D> {
|
||||||
Ok(Value::from(v).wrap())
|
Ok(Value::from(v).wrap())
|
||||||
}
|
}
|
||||||
|
|
||||||
fn serialize_f32(self, v: f32) -> Result<Self::Ok> {
|
fn serialize_f32(self, v: f32) -> Result<Self::Ok, D> {
|
||||||
Ok(Value::from(v).wrap())
|
Ok(Value::from(v).wrap())
|
||||||
}
|
}
|
||||||
|
|
||||||
fn serialize_f64(self, v: f64) -> Result<Self::Ok> {
|
fn serialize_f64(self, v: f64) -> Result<Self::Ok, D> {
|
||||||
Ok(Value::from(v).wrap())
|
Ok(Value::from(v).wrap())
|
||||||
}
|
}
|
||||||
|
|
||||||
fn serialize_char(self, v: char) -> Result<Self::Ok> {
|
fn serialize_char(self, v: char) -> Result<Self::Ok, D> {
|
||||||
Ok(Value::simple_record("UnicodeScalar", vec![Value::from(v as u32).wrap()]).wrap())
|
Ok(Value::simple_record("UnicodeScalar", vec![Value::from(v as u32).wrap()]).wrap())
|
||||||
}
|
}
|
||||||
|
|
||||||
fn serialize_str(self, v: &str) -> Result<Self::Ok> {
|
fn serialize_str(self, v: &str) -> Result<Self::Ok, D> {
|
||||||
Ok(Value::from(v).wrap())
|
Ok(Value::from(v).wrap())
|
||||||
}
|
}
|
||||||
|
|
||||||
fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok> {
|
fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, D> {
|
||||||
Ok(Value::from(v).wrap())
|
Ok(Value::from(v).wrap())
|
||||||
}
|
}
|
||||||
|
|
||||||
fn serialize_none(self) -> Result<Self::Ok> {
|
fn serialize_none(self) -> Result<Self::Ok, D> {
|
||||||
Ok(Value::simple_record("None", vec![]).wrap())
|
Ok(Value::simple_record("None", vec![]).wrap())
|
||||||
}
|
}
|
||||||
|
|
||||||
fn serialize_some<T: ?Sized>(self, v: &T) -> Result<Self::Ok> where T: Serialize {
|
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())
|
Ok(Value::simple_record("Some", vec![to_value(v)?]).wrap())
|
||||||
}
|
}
|
||||||
|
|
||||||
fn serialize_unit(self) -> Result<Self::Ok> {
|
fn serialize_unit(self) -> Result<Self::Ok, D> {
|
||||||
Ok(Value::simple_record("tuple", vec![]).wrap())
|
Ok(Value::simple_record("tuple", vec![]).wrap())
|
||||||
}
|
}
|
||||||
|
|
||||||
fn serialize_unit_struct(self, name: &'static str) -> Result<Self::Ok> {
|
fn serialize_unit_struct(self, name: &'static str) -> Result<Self::Ok, D> {
|
||||||
Ok(Value::simple_record(name, vec![]).wrap())
|
Ok(Value::simple_record(name, vec![]).wrap())
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -108,16 +111,16 @@ impl<N: NestedValue> serde::Serializer for Serializer<N> {
|
||||||
_name: &'static str,
|
_name: &'static str,
|
||||||
_variant: u32,
|
_variant: u32,
|
||||||
variant_name: &'static str) ->
|
variant_name: &'static str) ->
|
||||||
Result<Self::Ok>
|
Result<Self::Ok, D>
|
||||||
{
|
{
|
||||||
Ok(Value::simple_record(variant_name, vec![]).wrap())
|
Ok(Value::simple_record(variant_name, vec![]).wrap())
|
||||||
}
|
}
|
||||||
|
|
||||||
fn serialize_newtype_struct<T: ?Sized>(self, name: &'static str, value: &T) ->
|
fn serialize_newtype_struct<T: ?Sized>(self, name: &'static str, value: &T) ->
|
||||||
Result<Self::Ok> where T: Serialize
|
Result<Self::Ok, D> where T: Serialize
|
||||||
{
|
{
|
||||||
if name == crate::value::value::MAGIC {
|
if name == crate::value::value::MAGIC {
|
||||||
let v: crate::value::PlainValue = to_value(value)?;
|
let v: crate::value::PlainValue<D> = to_value(value)?;
|
||||||
let mut buf: &[u8] = v.value().as_bytestring().ok_or(Error::InternalMagicError)?;
|
let mut buf: &[u8] = v.value().as_bytestring().ok_or(Error::InternalMagicError)?;
|
||||||
crate::value::Decoder::new(&mut buf, None).next().or(Err(Error::InternalMagicError))
|
crate::value::Decoder::new(&mut buf, None).next().or(Err(Error::InternalMagicError))
|
||||||
} else {
|
} else {
|
||||||
|
@ -131,24 +134,24 @@ impl<N: NestedValue> serde::Serializer for Serializer<N> {
|
||||||
_variant: u32,
|
_variant: u32,
|
||||||
variant_name: &'static str,
|
variant_name: &'static str,
|
||||||
value: &T) ->
|
value: &T) ->
|
||||||
Result<Self::Ok> where T: Serialize
|
Result<Self::Ok, D> 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> {
|
fn serialize_seq(self, count: Option<usize>) -> Result<Self::SerializeSeq, D> {
|
||||||
let vec = match count { Some(n) => Vec::with_capacity(n), None => Vec::new() };
|
let vec = match count { Some(n) => Vec::with_capacity(n), None => Vec::new() };
|
||||||
Ok(SerializeSequence{ vec })
|
Ok(SerializeSequence{ vec, phantom: PhantomData })
|
||||||
}
|
}
|
||||||
|
|
||||||
fn serialize_tuple(self, count: usize) -> Result<Self::SerializeTuple> {
|
fn serialize_tuple(self, count: usize) -> Result<Self::SerializeTuple, D> {
|
||||||
Ok(SerializeRecord{ name: "tuple", vec: Vec::with_capacity(count) })
|
Ok(SerializeRecord{ name: "tuple", vec: Vec::with_capacity(count), phantom: PhantomData })
|
||||||
}
|
}
|
||||||
|
|
||||||
fn serialize_tuple_struct(self, name: &'static str, count: usize) ->
|
fn serialize_tuple_struct(self, name: &'static str, count: usize) ->
|
||||||
Result<Self::SerializeTupleStruct>
|
Result<Self::SerializeTupleStruct, D>
|
||||||
{
|
{
|
||||||
Ok(SerializeRecord{ name, vec: Vec::with_capacity(count) })
|
Ok(SerializeRecord{ name, vec: Vec::with_capacity(count), phantom: PhantomData })
|
||||||
}
|
}
|
||||||
|
|
||||||
fn serialize_tuple_variant(self,
|
fn serialize_tuple_variant(self,
|
||||||
|
@ -156,17 +159,17 @@ impl<N: NestedValue> serde::Serializer for Serializer<N> {
|
||||||
_variant: u32,
|
_variant: u32,
|
||||||
variant_name: &'static str,
|
variant_name: &'static str,
|
||||||
count: usize) ->
|
count: usize) ->
|
||||||
Result<Self::SerializeTupleVariant>
|
Result<Self::SerializeTupleVariant, D>
|
||||||
{
|
{
|
||||||
Ok(SerializeRecord{ name: variant_name, vec: Vec::with_capacity(count) })
|
Ok(SerializeRecord{ name: variant_name, vec: Vec::with_capacity(count), phantom: PhantomData })
|
||||||
}
|
}
|
||||||
|
|
||||||
fn serialize_map(self, _count: Option<usize>) -> Result<Self::SerializeMap> {
|
fn serialize_map(self, _count: Option<usize>) -> Result<Self::SerializeMap, D> {
|
||||||
Ok(SerializeDictionary{ next_key: None, items: Map::new() })
|
Ok(SerializeDictionary{ next_key: None, items: Map::new(), phantom: PhantomData })
|
||||||
}
|
}
|
||||||
|
|
||||||
fn serialize_struct(self, name: &'static str, count: usize) -> Result<Self::SerializeStruct> {
|
fn serialize_struct(self, name: &'static str, count: usize) -> Result<Self::SerializeStruct, D> {
|
||||||
Ok(SerializeRecord{ name, vec: Vec::with_capacity(count) })
|
Ok(SerializeRecord{ name, vec: Vec::with_capacity(count), phantom: PhantomData })
|
||||||
}
|
}
|
||||||
|
|
||||||
fn serialize_struct_variant(self,
|
fn serialize_struct_variant(self,
|
||||||
|
@ -174,126 +177,126 @@ impl<N: NestedValue> serde::Serializer for Serializer<N> {
|
||||||
_variant: u32,
|
_variant: u32,
|
||||||
variant_name: &'static str,
|
variant_name: &'static str,
|
||||||
count: usize) ->
|
count: usize) ->
|
||||||
Result<Self::SerializeStructVariant>
|
Result<Self::SerializeStructVariant, D>
|
||||||
{
|
{
|
||||||
Ok(SerializeRecord{ name: variant_name, vec: Vec::with_capacity(count) })
|
Ok(SerializeRecord{ name: variant_name, vec: Vec::with_capacity(count), phantom: PhantomData })
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<N: NestedValue> serde::ser::SerializeMap for SerializeDictionary<N> {
|
impl<N: NestedValue<D>, D: Domain> serde::ser::SerializeMap for SerializeDictionary<N, D> {
|
||||||
type Ok = N;
|
type Ok = N;
|
||||||
type Error = Error;
|
type Error = Error<D>;
|
||||||
|
|
||||||
fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<()> where T: Serialize {
|
fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<(), D> where T: Serialize {
|
||||||
self.next_key = Some(to_value(key)?);
|
self.next_key = Some(to_value(key)?);
|
||||||
Ok(())
|
Ok(())
|
||||||
}
|
}
|
||||||
|
|
||||||
fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<()> where T: Serialize {
|
fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<(), D> where T: Serialize {
|
||||||
let key = self.next_key.take().unwrap();
|
let key = self.next_key.take().unwrap();
|
||||||
self.items.insert(key, to_value(value)?);
|
self.items.insert(key, to_value(value)?);
|
||||||
Ok(())
|
Ok(())
|
||||||
}
|
}
|
||||||
|
|
||||||
fn end(self) -> Result<Self::Ok> {
|
fn end(self) -> Result<Self::Ok, D> {
|
||||||
Ok(Value::from(self.items).wrap())
|
Ok(Value::from(self.items).wrap())
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<N: NestedValue> SerializeRecord<N> {
|
impl<N: NestedValue<D>, D: Domain> SerializeRecord<N, D> {
|
||||||
fn push(&mut self, value: N) -> Result<()> {
|
fn push(&mut self, value: N) -> Result<(), D> {
|
||||||
self.vec.push(value);
|
self.vec.push(value);
|
||||||
Ok(())
|
Ok(())
|
||||||
}
|
}
|
||||||
|
|
||||||
fn finish(self) -> Result<N> {
|
fn finish(self) -> Result<N, D> {
|
||||||
Ok(Value::simple_record(self.name, self.vec).wrap())
|
Ok(Value::simple_record(self.name, self.vec).wrap())
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<N: NestedValue> serde::ser::SerializeStruct for SerializeRecord<N> {
|
impl<N: NestedValue<D>, D: Domain> serde::ser::SerializeStruct for SerializeRecord<N, D> {
|
||||||
type Ok = N;
|
type Ok = N;
|
||||||
type Error = Error;
|
type Error = Error<D>;
|
||||||
|
|
||||||
fn serialize_field<T: ?Sized>(&mut self, _name: &'static str, value: &T) -> Result<()>
|
fn serialize_field<T: ?Sized>(&mut self, _name: &'static str, value: &T) -> Result<(), D>
|
||||||
where T: Serialize
|
where T: Serialize
|
||||||
{
|
{
|
||||||
self.push(to_value(value)?)
|
self.push(to_value(value)?)
|
||||||
}
|
}
|
||||||
|
|
||||||
fn end(self) -> Result<Self::Ok> {
|
fn end(self) -> Result<Self::Ok, D> {
|
||||||
self.finish()
|
self.finish()
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<N: NestedValue> serde::ser::SerializeStructVariant for SerializeRecord<N> {
|
impl<N: NestedValue<D>, D: Domain> serde::ser::SerializeStructVariant for SerializeRecord<N, D> {
|
||||||
type Ok = N;
|
type Ok = N;
|
||||||
type Error = Error;
|
type Error = Error<D>;
|
||||||
|
|
||||||
fn serialize_field<T: ?Sized>(&mut self, _name: &'static str, value: &T) -> Result<()>
|
fn serialize_field<T: ?Sized>(&mut self, _name: &'static str, value: &T) -> Result<(), D>
|
||||||
where T: Serialize
|
where T: Serialize
|
||||||
{
|
{
|
||||||
self.push(to_value(value)?)
|
self.push(to_value(value)?)
|
||||||
}
|
}
|
||||||
|
|
||||||
fn end(self) -> Result<Self::Ok> {
|
fn end(self) -> Result<Self::Ok, D> {
|
||||||
self.finish()
|
self.finish()
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<N: NestedValue> serde::ser::SerializeTuple for SerializeRecord<N> {
|
impl<N: NestedValue<D>, D: Domain> serde::ser::SerializeTuple for SerializeRecord<N, D> {
|
||||||
type Ok = N;
|
type Ok = N;
|
||||||
type Error = Error;
|
type Error = Error<D>;
|
||||||
|
|
||||||
fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<()> where T: Serialize {
|
fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), D> where T: Serialize {
|
||||||
self.push(to_value(value)?)
|
self.push(to_value(value)?)
|
||||||
}
|
}
|
||||||
|
|
||||||
fn end(self) -> Result<Self::Ok> {
|
fn end(self) -> Result<Self::Ok, D> {
|
||||||
self.finish()
|
self.finish()
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<N: NestedValue> serde::ser::SerializeTupleStruct for SerializeRecord<N> {
|
impl<N: NestedValue<D>, D: Domain> serde::ser::SerializeTupleStruct for SerializeRecord<N, D> {
|
||||||
type Ok = N;
|
type Ok = N;
|
||||||
type Error = Error;
|
type Error = Error<D>;
|
||||||
|
|
||||||
fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<()> where T: Serialize {
|
fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), D> where T: Serialize {
|
||||||
self.push(to_value(value)?)
|
self.push(to_value(value)?)
|
||||||
}
|
}
|
||||||
|
|
||||||
fn end(self) -> Result<Self::Ok> {
|
fn end(self) -> Result<Self::Ok, D> {
|
||||||
self.finish()
|
self.finish()
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<N: NestedValue> serde::ser::SerializeTupleVariant for SerializeRecord<N> {
|
impl<N: NestedValue<D>, D: Domain> serde::ser::SerializeTupleVariant for SerializeRecord<N, D> {
|
||||||
type Ok = N;
|
type Ok = N;
|
||||||
type Error = Error;
|
type Error = Error<D>;
|
||||||
|
|
||||||
fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<()> where T: Serialize {
|
fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), D> where T: Serialize {
|
||||||
self.push(to_value(value)?)
|
self.push(to_value(value)?)
|
||||||
}
|
}
|
||||||
|
|
||||||
fn end(self) -> Result<Self::Ok> {
|
fn end(self) -> Result<Self::Ok, D> {
|
||||||
self.finish()
|
self.finish()
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<N: NestedValue> serde::ser::SerializeSeq for SerializeSequence<N> {
|
impl<N: NestedValue<D>, D: Domain> serde::ser::SerializeSeq for SerializeSequence<N, D> {
|
||||||
type Ok = N;
|
type Ok = N;
|
||||||
type Error = Error;
|
type Error = Error<D>;
|
||||||
|
|
||||||
fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<()> where T: Serialize {
|
fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), D> where T: Serialize {
|
||||||
self.vec.push(to_value(value)?);
|
self.vec.push(to_value(value)?);
|
||||||
Ok(())
|
Ok(())
|
||||||
}
|
}
|
||||||
|
|
||||||
fn end(self) -> Result<Self::Ok> {
|
fn end(self) -> Result<Self::Ok, D> {
|
||||||
Ok(Value::from(self.vec).wrap())
|
Ok(Value::from(self.vec).wrap())
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn to_value<T, N>(value: T) -> Result<N> where T: Serialize, N: NestedValue {
|
pub fn to_value<T, N, D: Domain>(value: T) -> Result<N, D> where T: Serialize, N: NestedValue<D> {
|
||||||
value.serialize(Serializer{ phantom: PhantomData })
|
value.serialize(Serializer{ phantom: PhantomData })
|
||||||
}
|
}
|
||||||
|
|
|
@ -11,18 +11,20 @@ use num::traits::cast::ToPrimitive;
|
||||||
pub use std::collections::BTreeSet as Set;
|
pub use std::collections::BTreeSet as Set;
|
||||||
pub use std::collections::BTreeMap as Map;
|
pub use std::collections::BTreeMap as Map;
|
||||||
|
|
||||||
pub trait NestedValue: Sized + Debug + Clone + Eq + Hash + Ord {
|
pub trait Domain: Sized + Debug + Clone + Eq + Hash + Ord {}
|
||||||
|
|
||||||
|
pub trait NestedValue<D: Domain>: Sized + Debug + Clone + Eq + Hash + Ord {
|
||||||
type BoxType: Sized + Debug + Clone + Eq + Hash + Ord;
|
type BoxType: Sized + Debug + Clone + Eq + Hash + Ord;
|
||||||
|
|
||||||
fn wrap(v: Value<Self>) -> Self;
|
fn wrap(v: Value<Self, D>) -> Self;
|
||||||
fn wrap_ann(anns: Vec<Self>, v: Value<Self>) -> Self;
|
fn wrap_ann(anns: Vec<Self>, v: Value<Self, D>) -> Self;
|
||||||
|
|
||||||
fn boxwrap(self) -> Self::BoxType;
|
fn boxwrap(self) -> Self::BoxType;
|
||||||
fn boxunwrap(b: &Self::BoxType) -> &Self;
|
fn boxunwrap(b: &Self::BoxType) -> &Self;
|
||||||
|
|
||||||
fn annotations(&self) -> &[Self];
|
fn annotations(&self) -> &[Self];
|
||||||
fn value(&self) -> &Value<Self>;
|
fn value(&self) -> &Value<Self, D>;
|
||||||
fn value_owned(self) -> Value<Self>;
|
fn value_owned(self) -> Value<Self, D>;
|
||||||
|
|
||||||
fn debug_fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
fn debug_fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||||
for ann in self.annotations() {
|
for ann in self.annotations() {
|
||||||
|
@ -31,7 +33,7 @@ pub trait NestedValue: Sized + Debug + Clone + Eq + Hash + Ord {
|
||||||
self.value().fmt(f)
|
self.value().fmt(f)
|
||||||
}
|
}
|
||||||
|
|
||||||
fn copy_via<M: NestedValue>(&self) -> M {
|
fn copy_via<M: NestedValue<D>>(&self) -> M {
|
||||||
M::wrap_ann(self.annotations().iter().map(|a| a.copy_via()).collect(),
|
M::wrap_ann(self.annotations().iter().map(|a| a.copy_via()).collect(),
|
||||||
self.value().copy_via())
|
self.value().copy_via())
|
||||||
}
|
}
|
||||||
|
@ -39,7 +41,7 @@ pub trait NestedValue: Sized + Debug + Clone + Eq + Hash + Ord {
|
||||||
|
|
||||||
/// The `Value`s from the specification.
|
/// The `Value`s from the specification.
|
||||||
#[derive(Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
|
#[derive(Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
|
||||||
pub enum Value<N> where N: NestedValue {
|
pub enum Value<N, D> where N: NestedValue<D>, D: Domain {
|
||||||
Boolean(bool),
|
Boolean(bool),
|
||||||
Float(Float),
|
Float(Float),
|
||||||
Double(Double),
|
Double(Double),
|
||||||
|
@ -47,10 +49,11 @@ pub enum Value<N> where N: NestedValue {
|
||||||
String(String),
|
String(String),
|
||||||
ByteString(Vec<u8>),
|
ByteString(Vec<u8>),
|
||||||
Symbol(String),
|
Symbol(String),
|
||||||
Record(Record<N>),
|
Record(Record<N, D>),
|
||||||
Sequence(Vec<N>),
|
Sequence(Vec<N>),
|
||||||
Set(Set<N>),
|
Set(Set<N>),
|
||||||
Dictionary(Map<N, N>),
|
Dictionary(Map<N, N>),
|
||||||
|
Domain(D),
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Single-precision IEEE 754 Value
|
/// Single-precision IEEE 754 Value
|
||||||
|
@ -62,7 +65,7 @@ pub struct Float(pub f32);
|
||||||
pub struct Double(pub f64);
|
pub struct Double(pub f64);
|
||||||
|
|
||||||
/// A Record `Value`
|
/// A Record `Value`
|
||||||
pub type Record<N> = (<N as NestedValue>::BoxType, Vec<N>);
|
pub type Record<N, D> = (<N as NestedValue<D>>::BoxType, Vec<N>);
|
||||||
|
|
||||||
impl From<f32> for Float {
|
impl From<f32> for Float {
|
||||||
fn from(v: f32) -> Self {
|
fn from(v: f32) -> Self {
|
||||||
|
@ -148,34 +151,34 @@ impl PartialOrd for Double {
|
||||||
|
|
||||||
impl Eq for Double {}
|
impl Eq for Double {}
|
||||||
|
|
||||||
impl<N: NestedValue> From<bool> for Value<N> { fn from(v: bool) -> Self { Value::Boolean(v) } }
|
impl<N: NestedValue<D>, D: Domain> From<bool> for Value<N, D> { fn from(v: bool) -> Self { Value::Boolean(v) } }
|
||||||
|
|
||||||
impl<N: NestedValue> From<f32> for Value<N> { fn from(v: f32) -> Self { Value::Float(Float::from(v)) } }
|
impl<N: NestedValue<D>, D: Domain> From<f32> for Value<N, D> { fn from(v: f32) -> Self { Value::Float(Float::from(v)) } }
|
||||||
impl<N: NestedValue> From<f64> for Value<N> { fn from(v: f64) -> Self { Value::Double(Double::from(v)) } }
|
impl<N: NestedValue<D>, D: Domain> From<f64> for Value<N, D> { fn from(v: f64) -> Self { Value::Double(Double::from(v)) } }
|
||||||
|
|
||||||
impl<N: NestedValue> From<u8> for Value<N> { fn from(v: u8) -> Self { Value::from(i128::from(v)) } }
|
impl<N: NestedValue<D>, D: Domain> From<u8> for Value<N, D> { fn from(v: u8) -> Self { Value::from(i128::from(v)) } }
|
||||||
impl<N: NestedValue> From<i8> for Value<N> { fn from(v: i8) -> Self { Value::from(i128::from(v)) } }
|
impl<N: NestedValue<D>, D: Domain> From<i8> for Value<N, D> { fn from(v: i8) -> Self { Value::from(i128::from(v)) } }
|
||||||
impl<N: NestedValue> From<u16> for Value<N> { fn from(v: u16) -> Self { Value::from(i128::from(v)) } }
|
impl<N: NestedValue<D>, D: Domain> From<u16> for Value<N, D> { fn from(v: u16) -> Self { Value::from(i128::from(v)) } }
|
||||||
impl<N: NestedValue> From<i16> for Value<N> { fn from(v: i16) -> Self { Value::from(i128::from(v)) } }
|
impl<N: NestedValue<D>, D: Domain> From<i16> for Value<N, D> { fn from(v: i16) -> Self { Value::from(i128::from(v)) } }
|
||||||
impl<N: NestedValue> From<u32> for Value<N> { fn from(v: u32) -> Self { Value::from(i128::from(v)) } }
|
impl<N: NestedValue<D>, D: Domain> From<u32> for Value<N, D> { fn from(v: u32) -> Self { Value::from(i128::from(v)) } }
|
||||||
impl<N: NestedValue> From<i32> for Value<N> { fn from(v: i32) -> Self { Value::from(i128::from(v)) } }
|
impl<N: NestedValue<D>, D: Domain> From<i32> for Value<N, D> { fn from(v: i32) -> Self { Value::from(i128::from(v)) } }
|
||||||
impl<N: NestedValue> From<u64> for Value<N> { fn from(v: u64) -> Self { Value::from(i128::from(v)) } }
|
impl<N: NestedValue<D>, D: Domain> From<u64> for Value<N, D> { fn from(v: u64) -> Self { Value::from(i128::from(v)) } }
|
||||||
impl<N: NestedValue> From<i64> for Value<N> { fn from(v: i64) -> Self { Value::from(i128::from(v)) } }
|
impl<N: NestedValue<D>, D: Domain> From<i64> for Value<N, D> { fn from(v: i64) -> Self { Value::from(i128::from(v)) } }
|
||||||
impl<N: NestedValue> From<u128> for Value<N> { fn from(v: u128) -> Self { Value::SignedInteger(BigInt::from(v)) } }
|
impl<N: NestedValue<D>, D: Domain> From<u128> for Value<N, D> { fn from(v: u128) -> Self { Value::SignedInteger(BigInt::from(v)) } }
|
||||||
impl<N: NestedValue> From<i128> for Value<N> { fn from(v: i128) -> Self { Value::SignedInteger(BigInt::from(v)) } }
|
impl<N: NestedValue<D>, D: Domain> From<i128> for Value<N, D> { fn from(v: i128) -> Self { Value::SignedInteger(BigInt::from(v)) } }
|
||||||
impl<N: NestedValue> From<BigInt> for Value<N> { fn from(v: BigInt) -> Self { Value::SignedInteger(v) } }
|
impl<N: NestedValue<D>, D: Domain> From<BigInt> for Value<N, D> { fn from(v: BigInt) -> Self { Value::SignedInteger(v) } }
|
||||||
|
|
||||||
impl<N: NestedValue> From<&str> for Value<N> { fn from(v: &str) -> Self { Value::String(String::from(v)) } }
|
impl<N: NestedValue<D>, D: Domain> From<&str> for Value<N, D> { fn from(v: &str) -> Self { Value::String(String::from(v)) } }
|
||||||
impl<N: NestedValue> From<String> for Value<N> { fn from(v: String) -> Self { Value::String(v) } }
|
impl<N: NestedValue<D>, D: Domain> From<String> for Value<N, D> { fn from(v: String) -> Self { Value::String(v) } }
|
||||||
|
|
||||||
impl<N: NestedValue> From<&[u8]> for Value<N> { fn from(v: &[u8]) -> Self { Value::ByteString(Vec::from(v)) } }
|
impl<N: NestedValue<D>, D: Domain> From<&[u8]> for Value<N, D> { fn from(v: &[u8]) -> Self { Value::ByteString(Vec::from(v)) } }
|
||||||
impl<N: NestedValue> From<Vec<u8>> for Value<N> { fn from(v: Vec<u8>) -> Self { Value::ByteString(v) } }
|
// impl<N: NestedValue<D>, D: Domain> From<Vec<u8>> for Value<N, D> { fn from(v: Vec<u8>) -> Self { Value::ByteString(v) } }
|
||||||
|
|
||||||
impl<N: NestedValue> From<Vec<N>> for Value<N> { fn from(v: Vec<N>) -> Self { Value::Sequence(v) } }
|
impl<N: NestedValue<D>, D: Domain> From<Vec<N>> for Value<N, D> { fn from(v: Vec<N>) -> Self { Value::Sequence(v) } }
|
||||||
impl<N: NestedValue> From<Set<N>> for Value<N> { fn from(v: Set<N>) -> Self { Value::Set(v) } }
|
impl<N: NestedValue<D>, D: Domain> From<Set<N>> for Value<N, D> { fn from(v: Set<N>) -> Self { Value::Set(v) } }
|
||||||
impl<N: NestedValue> From<Map<N, N>> for Value<N> { fn from(v: Map<N, N>) -> Self { Value::Dictionary(v) } }
|
impl<N: NestedValue<D>, D: Domain> From<Map<N, N>> for Value<N, D> { fn from(v: Map<N, N>) -> Self { Value::Dictionary(v) } }
|
||||||
|
|
||||||
impl<N: NestedValue> Debug for Value<N> {
|
impl<N: NestedValue<D>, D: Domain> Debug for Value<N, D> {
|
||||||
// Not *quite* a formatter for the Preserves text syntax, since it
|
// Not *quite* a formatter for the Preserves text syntax, since it
|
||||||
// doesn't escape strings/symbols properly.
|
// doesn't escape strings/symbols properly.
|
||||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||||
|
@ -213,14 +216,15 @@ impl<N: NestedValue> Debug for Value<N> {
|
||||||
f.write_str("#set")?;
|
f.write_str("#set")?;
|
||||||
f.debug_set().entries(v.iter()).finish()
|
f.debug_set().entries(v.iter()).finish()
|
||||||
}
|
}
|
||||||
Value::Dictionary(ref v) => f.debug_map().entries(v.iter()).finish()
|
Value::Dictionary(ref v) => f.debug_map().entries(v.iter()).finish(),
|
||||||
|
Value::Domain(ref d) => write!(f, "{:?}", d),
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
//---------------------------------------------------------------------------
|
//---------------------------------------------------------------------------
|
||||||
|
|
||||||
impl<N: NestedValue> Value<N> {
|
impl<N: NestedValue<D>, D: Domain> Value<N, D> {
|
||||||
pub fn wrap(self) -> N {
|
pub fn wrap(self) -> N {
|
||||||
N::wrap(self)
|
N::wrap(self)
|
||||||
}
|
}
|
||||||
|
@ -354,7 +358,7 @@ impl<N: NestedValue> Value<N> {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn symbol(s: &str) -> Value<N> {
|
pub fn symbol(s: &str) -> Value<N, D> {
|
||||||
Value::Symbol(s.to_string())
|
Value::Symbol(s.to_string())
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -378,7 +382,7 @@ impl<N: NestedValue> Value<N> {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn record(label: N, fields: Vec<N>) -> Value<N> {
|
pub fn record(label: N, fields: Vec<N>) -> Value<N, D> {
|
||||||
Value::Record((label.boxwrap(), fields))
|
Value::Record((label.boxwrap(), fields))
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -386,7 +390,7 @@ impl<N: NestedValue> Value<N> {
|
||||||
self.as_record().is_some()
|
self.as_record().is_some()
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn as_record(&self) -> Option<&Record<N>> {
|
pub fn as_record(&self) -> Option<&Record<N, D>> {
|
||||||
if let Value::Record(ref r) = *self {
|
if let Value::Record(ref r) = *self {
|
||||||
Some(r)
|
Some(r)
|
||||||
} else {
|
} else {
|
||||||
|
@ -394,7 +398,7 @@ impl<N: NestedValue> Value<N> {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn as_record_mut(&mut self) -> Option<&mut Record<N>> {
|
pub fn as_record_mut(&mut self) -> Option<&mut Record<N, D>> {
|
||||||
if let Value::Record(ref mut r) = *self {
|
if let Value::Record(ref mut r) = *self {
|
||||||
Some(r)
|
Some(r)
|
||||||
} else {
|
} else {
|
||||||
|
@ -402,7 +406,7 @@ impl<N: NestedValue> Value<N> {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn simple_record(label: &str, fields: Vec<N>) -> Value<N> {
|
pub fn simple_record(label: &str, fields: Vec<N>) -> Value<N, D> {
|
||||||
Value::record(Value::symbol(label).wrap(), fields)
|
Value::record(Value::symbol(label).wrap(), fields)
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -484,7 +488,7 @@ impl<N: NestedValue> Value<N> {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn copy_via<M: NestedValue>(&self) -> Value<M> {
|
pub fn copy_via<M: NestedValue<D>>(&self) -> Value<M, D> {
|
||||||
match self {
|
match self {
|
||||||
Value::Boolean(b) => Value::Boolean(*b),
|
Value::Boolean(b) => Value::Boolean(*b),
|
||||||
Value::Float(f) => Value::Float(f.clone()),
|
Value::Float(f) => Value::Float(f.clone()),
|
||||||
|
@ -499,11 +503,12 @@ impl<N: NestedValue> Value<N> {
|
||||||
Value::Set(ref v) => Value::Set(v.iter().map(|a| a.copy_via()).collect()),
|
Value::Set(ref v) => Value::Set(v.iter().map(|a| a.copy_via()).collect()),
|
||||||
Value::Dictionary(ref v) =>
|
Value::Dictionary(ref v) =>
|
||||||
Value::Dictionary(v.iter().map(|(a,b)| (a.copy_via(), b.copy_via())).collect()),
|
Value::Dictionary(v.iter().map(|(a,b)| (a.copy_via(), b.copy_via())).collect()),
|
||||||
|
Value::Domain(d) => Value::Domain(d.clone()),
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<N: NestedValue> Index<usize> for Value<N> {
|
impl<N: NestedValue<D>, D: Domain> Index<usize> for Value<N, D> {
|
||||||
type Output = N;
|
type Output = N;
|
||||||
|
|
||||||
fn index(&self, i: usize) -> &Self::Output {
|
fn index(&self, i: usize) -> &Self::Output {
|
||||||
|
@ -511,13 +516,13 @@ impl<N: NestedValue> Index<usize> for Value<N> {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<N: NestedValue> IndexMut<usize> for Value<N> {
|
impl<N: NestedValue<D>, D: Domain> IndexMut<usize> for Value<N, D> {
|
||||||
fn index_mut(&mut self, i: usize) -> &mut Self::Output {
|
fn index_mut(&mut self, i: usize) -> &mut Self::Output {
|
||||||
&mut self.as_sequence_mut().unwrap()[i]
|
&mut self.as_sequence_mut().unwrap()[i]
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<N: NestedValue> Index<&N> for Value<N> {
|
impl<N: NestedValue<D>, D: Domain> Index<&N> for Value<N, D> {
|
||||||
type Output = N;
|
type Output = N;
|
||||||
|
|
||||||
fn index(&self, i: &N) -> &Self::Output {
|
fn index(&self, i: &N) -> &Self::Output {
|
||||||
|
@ -554,7 +559,7 @@ impl<'de> serde::Deserialize<'de> for ValueWrapper {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<N: NestedValue> serde::Serialize for Value<N> {
|
impl<N: NestedValue<D>, D: Domain> serde::Serialize for Value<N, D> {
|
||||||
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: serde::Serializer {
|
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: serde::Serializer {
|
||||||
let mut buf: Vec<u8> = Vec::new();
|
let mut buf: Vec<u8> = Vec::new();
|
||||||
crate::value::Encoder::new(&mut buf, None).write_value(self)
|
crate::value::Encoder::new(&mut buf, None).write_value(self)
|
||||||
|
@ -563,7 +568,7 @@ impl<N: NestedValue> serde::Serialize for Value<N> {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'de, N: NestedValue> serde::Deserialize<'de> for Value<N> {
|
impl<'de, N: NestedValue<Dom>, Dom: Domain> serde::Deserialize<'de> for Value<N, Dom> {
|
||||||
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: serde::Deserializer<'de> {
|
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: serde::Deserializer<'de> {
|
||||||
let ValueWrapper(buf) = ValueWrapper::deserialize(deserializer)?;
|
let ValueWrapper(buf) = ValueWrapper::deserialize(deserializer)?;
|
||||||
let v: N = crate::value::Decoder::new(&mut &buf[..], None).next()
|
let v: N = crate::value::Decoder::new(&mut &buf[..], None).next()
|
||||||
|
@ -572,8 +577,8 @@ impl<'de, N: NestedValue> serde::Deserialize<'de> for Value<N> {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn serialize_nested_value<S, N>(v: &N, serializer: S) ->
|
pub fn serialize_nested_value<S, N, D: Domain>(v: &N, serializer: S) ->
|
||||||
Result<S::Ok, S::Error> where S: serde::Serializer, N: NestedValue
|
Result<S::Ok, S::Error> where S: serde::Serializer, N: NestedValue<D>
|
||||||
{
|
{
|
||||||
use serde::Serialize;
|
use serde::Serialize;
|
||||||
let mut buf: Vec<u8> = Vec::new();
|
let mut buf: Vec<u8> = Vec::new();
|
||||||
|
@ -582,8 +587,8 @@ pub fn serialize_nested_value<S, N>(v: &N, serializer: S) ->
|
||||||
ValueWrapper(buf).serialize(serializer)
|
ValueWrapper(buf).serialize(serializer)
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn deserialize_nested_value<'de, D, N>(deserializer: D) ->
|
pub fn deserialize_nested_value<'de, D, N, Dom: Domain>(deserializer: D) ->
|
||||||
Result<N, D::Error> where D: serde::Deserializer<'de>, N: NestedValue
|
Result<N, D::Error> where D: serde::Deserializer<'de>, N: NestedValue<Dom>
|
||||||
{
|
{
|
||||||
use serde::Deserialize;
|
use serde::Deserialize;
|
||||||
let ValueWrapper(buf) = ValueWrapper::deserialize(deserializer)?;
|
let ValueWrapper(buf) = ValueWrapper::deserialize(deserializer)?;
|
||||||
|
@ -596,29 +601,29 @@ pub fn deserialize_nested_value<'de, D, N>(deserializer: D) ->
|
||||||
/// An possibly-annotated Value, with annotations (themselves
|
/// An possibly-annotated Value, with annotations (themselves
|
||||||
/// possibly-annotated) in order of appearance.
|
/// possibly-annotated) in order of appearance.
|
||||||
#[derive(Clone)]
|
#[derive(Clone)]
|
||||||
pub struct AnnotatedValue<N: NestedValue>(pub Vec<N>, pub Value<N>);
|
pub struct AnnotatedValue<N: NestedValue<D>, D: Domain>(pub Vec<N>, pub Value<N, D>);
|
||||||
|
|
||||||
impl<N: NestedValue> PartialEq for AnnotatedValue<N> {
|
impl<N: NestedValue<D>, D: Domain> PartialEq for AnnotatedValue<N, D> {
|
||||||
fn eq(&self, other: &Self) -> bool {
|
fn eq(&self, other: &Self) -> bool {
|
||||||
self.1.eq(&other.1)
|
self.1.eq(&other.1)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<N: NestedValue> Eq for AnnotatedValue<N> {}
|
impl<N: NestedValue<D>, D: Domain> Eq for AnnotatedValue<N, D> {}
|
||||||
|
|
||||||
impl<N: NestedValue> Hash for AnnotatedValue<N> {
|
impl<N: NestedValue<D>, D: Domain> Hash for AnnotatedValue<N, D> {
|
||||||
fn hash<H: Hasher>(&self, state: &mut H) {
|
fn hash<H: Hasher>(&self, state: &mut H) {
|
||||||
self.1.hash(state);
|
self.1.hash(state);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<N: NestedValue> PartialOrd for AnnotatedValue<N> {
|
impl<N: NestedValue<D>, D: Domain> PartialOrd for AnnotatedValue<N, D> {
|
||||||
fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
|
fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
|
||||||
Some(self.cmp(other))
|
Some(self.cmp(other))
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<N: NestedValue> Ord for AnnotatedValue<N> {
|
impl<N: NestedValue<D>, D: Domain> Ord for AnnotatedValue<N, D> {
|
||||||
fn cmp(&self, other: &Self) -> Ordering {
|
fn cmp(&self, other: &Self) -> Ordering {
|
||||||
self.1.cmp(&other.1)
|
self.1.cmp(&other.1)
|
||||||
}
|
}
|
||||||
|
@ -627,26 +632,26 @@ impl<N: NestedValue> Ord for AnnotatedValue<N> {
|
||||||
//---------------------------------------------------------------------------
|
//---------------------------------------------------------------------------
|
||||||
|
|
||||||
#[derive(Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
|
#[derive(Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
|
||||||
pub struct PlainValue(AnnotatedValue<PlainValue>);
|
pub struct PlainValue<D: Domain>(AnnotatedValue<PlainValue<D>, D>);
|
||||||
|
|
||||||
impl PlainValue {
|
impl<D: Domain> PlainValue<D> {
|
||||||
pub fn annotations_mut(&mut self) -> &mut Vec<Self> {
|
pub fn annotations_mut(&mut self) -> &mut Vec<Self> {
|
||||||
&mut (self.0).0
|
&mut (self.0).0
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn value_mut(&mut self) -> &mut Value<Self> {
|
pub fn value_mut(&mut self) -> &mut Value<Self, D> {
|
||||||
&mut (self.0).1
|
&mut (self.0).1
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl NestedValue for PlainValue {
|
impl<D: Domain> NestedValue<D> for PlainValue<D> {
|
||||||
type BoxType = Box<Self>;
|
type BoxType = Box<Self>;
|
||||||
|
|
||||||
fn wrap(v: Value<Self>) -> Self {
|
fn wrap(v: Value<Self, D>) -> Self {
|
||||||
Self::wrap_ann(Vec::new(), v)
|
Self::wrap_ann(Vec::new(), v)
|
||||||
}
|
}
|
||||||
|
|
||||||
fn wrap_ann(anns: Vec<Self>, v: Value<Self>) -> Self {
|
fn wrap_ann(anns: Vec<Self>, v: Value<Self, D>) -> Self {
|
||||||
PlainValue(AnnotatedValue(anns, v))
|
PlainValue(AnnotatedValue(anns, v))
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -662,28 +667,28 @@ impl NestedValue for PlainValue {
|
||||||
&(self.0).0
|
&(self.0).0
|
||||||
}
|
}
|
||||||
|
|
||||||
fn value(&self) -> &Value<Self> {
|
fn value(&self) -> &Value<Self, D> {
|
||||||
&(self.0).1
|
&(self.0).1
|
||||||
}
|
}
|
||||||
|
|
||||||
fn value_owned(self) -> Value<Self> {
|
fn value_owned(self) -> Value<Self, D> {
|
||||||
(self.0).1
|
(self.0).1
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl Debug for PlainValue {
|
impl<D: Domain> Debug for PlainValue<D> {
|
||||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||||
self.debug_fmt(f)
|
self.debug_fmt(f)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl serde::Serialize for PlainValue {
|
impl<D: Domain> serde::Serialize for PlainValue<D> {
|
||||||
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: serde::Serializer {
|
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: serde::Serializer {
|
||||||
serialize_nested_value(self, serializer)
|
serialize_nested_value(self, serializer)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'de> serde::Deserialize<'de> for PlainValue {
|
impl<'de, Dom: Domain> serde::Deserialize<'de> for PlainValue<Dom> {
|
||||||
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: serde::Deserializer<'de> {
|
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: serde::Deserializer<'de> {
|
||||||
deserialize_nested_value(deserializer)
|
deserialize_nested_value(deserializer)
|
||||||
}
|
}
|
||||||
|
@ -694,16 +699,16 @@ impl<'de> serde::Deserialize<'de> for PlainValue {
|
||||||
use std::rc::Rc;
|
use std::rc::Rc;
|
||||||
|
|
||||||
#[derive(Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
|
#[derive(Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
|
||||||
pub struct RcValue(Rc<AnnotatedValue<RcValue>>);
|
pub struct RcValue<D: Domain>(Rc<AnnotatedValue<RcValue<D>, D>>);
|
||||||
|
|
||||||
impl NestedValue for RcValue {
|
impl<D: Domain> NestedValue<D> for RcValue<D> {
|
||||||
type BoxType = Self;
|
type BoxType = Self;
|
||||||
|
|
||||||
fn wrap(v: Value<Self>) -> Self {
|
fn wrap(v: Value<Self, D>) -> Self {
|
||||||
Self::wrap_ann(Vec::new(), v)
|
Self::wrap_ann(Vec::new(), v)
|
||||||
}
|
}
|
||||||
|
|
||||||
fn wrap_ann(anns: Vec<Self>, v: Value<Self>) -> Self {
|
fn wrap_ann(anns: Vec<Self>, v: Value<Self, D>) -> Self {
|
||||||
RcValue(Rc::new(AnnotatedValue(anns, v)))
|
RcValue(Rc::new(AnnotatedValue(anns, v)))
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -719,28 +724,28 @@ impl NestedValue for RcValue {
|
||||||
&(self.0).0
|
&(self.0).0
|
||||||
}
|
}
|
||||||
|
|
||||||
fn value(&self) -> &Value<Self> {
|
fn value(&self) -> &Value<Self, D> {
|
||||||
&(self.0).1
|
&(self.0).1
|
||||||
}
|
}
|
||||||
|
|
||||||
fn value_owned(self) -> Value<Self> {
|
fn value_owned(self) -> Value<Self, D> {
|
||||||
Rc::try_unwrap(self.0).unwrap_or_else(|_| panic!("value_owned on RcValue with refcount greater than one")).1
|
Rc::try_unwrap(self.0).unwrap_or_else(|_| panic!("value_owned on RcValue with refcount greater than one")).1
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl Debug for RcValue {
|
impl<D: Domain> Debug for RcValue<D> {
|
||||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||||
self.debug_fmt(f)
|
self.debug_fmt(f)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl serde::Serialize for RcValue {
|
impl<D: Domain> serde::Serialize for RcValue<D> {
|
||||||
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: serde::Serializer {
|
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: serde::Serializer {
|
||||||
serialize_nested_value(self, serializer)
|
serialize_nested_value(self, serializer)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'de> serde::Deserialize<'de> for RcValue {
|
impl<'de, Dom: Domain> serde::Deserialize<'de> for RcValue<Dom> {
|
||||||
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: serde::Deserializer<'de> {
|
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: serde::Deserializer<'de> {
|
||||||
deserialize_nested_value(deserializer)
|
deserialize_nested_value(deserializer)
|
||||||
}
|
}
|
||||||
|
@ -751,16 +756,16 @@ impl<'de> serde::Deserialize<'de> for RcValue {
|
||||||
use std::sync::Arc;
|
use std::sync::Arc;
|
||||||
|
|
||||||
#[derive(Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
|
#[derive(Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
|
||||||
pub struct ArcValue(Arc<AnnotatedValue<ArcValue>>);
|
pub struct ArcValue<D: Domain>(Arc<AnnotatedValue<ArcValue<D>, D>>);
|
||||||
|
|
||||||
impl NestedValue for ArcValue {
|
impl<D: Domain> NestedValue<D> for ArcValue<D> {
|
||||||
type BoxType = Self;
|
type BoxType = Self;
|
||||||
|
|
||||||
fn wrap(v: Value<Self>) -> Self {
|
fn wrap(v: Value<Self, D>) -> Self {
|
||||||
Self::wrap_ann(Vec::new(), v)
|
Self::wrap_ann(Vec::new(), v)
|
||||||
}
|
}
|
||||||
|
|
||||||
fn wrap_ann(anns: Vec<Self>, v: Value<Self>) -> Self {
|
fn wrap_ann(anns: Vec<Self>, v: Value<Self, D>) -> Self {
|
||||||
ArcValue(Arc::new(AnnotatedValue(anns, v)))
|
ArcValue(Arc::new(AnnotatedValue(anns, v)))
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -776,29 +781,33 @@ impl NestedValue for ArcValue {
|
||||||
&(self.0).0
|
&(self.0).0
|
||||||
}
|
}
|
||||||
|
|
||||||
fn value(&self) -> &Value<Self> {
|
fn value(&self) -> &Value<Self, D> {
|
||||||
&(self.0).1
|
&(self.0).1
|
||||||
}
|
}
|
||||||
|
|
||||||
fn value_owned(self) -> Value<Self> {
|
fn value_owned(self) -> Value<Self, D> {
|
||||||
Arc::try_unwrap(self.0).unwrap_or_else(|_| panic!("value_owned on ArcValue with refcount greater than one")).1
|
Arc::try_unwrap(self.0).unwrap_or_else(|_| panic!("value_owned on ArcValue with refcount greater than one")).1
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl Debug for ArcValue {
|
impl<D: Domain> Debug for ArcValue<D> {
|
||||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||||
self.debug_fmt(f)
|
self.debug_fmt(f)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl serde::Serialize for ArcValue {
|
impl<D: Domain> serde::Serialize for ArcValue<D> {
|
||||||
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: serde::Serializer {
|
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: serde::Serializer {
|
||||||
serialize_nested_value(self, serializer)
|
serialize_nested_value(self, serializer)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'de> serde::Deserialize<'de> for ArcValue {
|
impl<'de, Dom: Domain> serde::Deserialize<'de> for ArcValue<Dom> {
|
||||||
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: serde::Deserializer<'de> {
|
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: serde::Deserializer<'de> {
|
||||||
deserialize_nested_value(deserializer)
|
deserialize_nested_value(deserializer)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
|
||||||
|
impl Domain for () {}
|
||||||
|
|
Loading…
Reference in New Issue