Simplify code (and get back up to speed! ~150kHz) by insisting on IOValue for all codec operations
This commit is contained in:
parent
c30154e0c8
commit
dfc50fcaee
|
@ -6,7 +6,9 @@ pub mod value;
|
||||||
|
|
||||||
#[cfg(test)]
|
#[cfg(test)]
|
||||||
mod dom {
|
mod dom {
|
||||||
use super::value::{Value, PlainValue, NestedValue, Domain, Encoder, Codec, writer::Writer};
|
use super::value::{
|
||||||
|
Value, IOValue, NestedValue, PlainValue, Domain, Codec,
|
||||||
|
};
|
||||||
|
|
||||||
#[derive(Debug, Hash, Clone, Ord, PartialEq, Eq, PartialOrd)]
|
#[derive(Debug, Hash, Clone, Ord, PartialEq, Eq, PartialOrd)]
|
||||||
pub enum Dom {
|
pub enum Dom {
|
||||||
|
@ -15,22 +17,12 @@ mod dom {
|
||||||
}
|
}
|
||||||
|
|
||||||
impl Domain for Dom {
|
impl Domain for Dom {
|
||||||
fn encode<'a, 'b, W: Writer, N: NestedValue<Self>>(
|
fn as_preserves(&self) -> Result<IOValue, std::io::Error> {
|
||||||
&self, enc: &mut Encoder<'a, 'b, W, N, Self>) ->
|
Ok(match self {
|
||||||
super::value::encoder::Result
|
// TODO: How to nicely expose streaming values?
|
||||||
{
|
Dom::One => Value::ByteString(vec![255, 255, 255, 255]).wrap(),
|
||||||
match self {
|
Dom::Two => Value::symbol(&format!("Dom::{:?}", self)).wrap(),
|
||||||
Dom::One => {
|
})
|
||||||
enc.write.stream_bytes()?;
|
|
||||||
enc.write.write_bytes(&[255, 255, 255, 255])?;
|
|
||||||
enc.write.close_stream()
|
|
||||||
}
|
|
||||||
Dom::Two => enc.write(&self.as_preserves()?)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
fn as_preserves<N: NestedValue<D>, D: Domain>(&self) -> Result<N, std::io::Error> {
|
|
||||||
Ok(Value::symbol(&format!("Dom::{:?}", self)).wrap())
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -39,8 +31,8 @@ mod dom {
|
||||||
Value::Domain(Dom::One).wrap(),
|
Value::Domain(Dom::One).wrap(),
|
||||||
Value::from(2).wrap()])
|
Value::from(2).wrap()])
|
||||||
.wrap();
|
.wrap();
|
||||||
assert_eq!(Codec::without_placeholders().encode_bytes(&v).unwrap(),
|
assert_eq!(Codec::without_placeholders().encode_bytes(&v.to_io_value()).unwrap(),
|
||||||
[147, 49, 38, 100, 255, 255, 255, 255, 4, 50]);
|
[147, 49, 100, 255, 255, 255, 255, 50]);
|
||||||
}
|
}
|
||||||
|
|
||||||
#[test] fn test_two() {
|
#[test] fn test_two() {
|
||||||
|
@ -48,7 +40,7 @@ mod dom {
|
||||||
Value::Domain(Dom::Two).wrap(),
|
Value::Domain(Dom::Two).wrap(),
|
||||||
Value::from(2).wrap()])
|
Value::from(2).wrap()])
|
||||||
.wrap();
|
.wrap();
|
||||||
assert_eq!(Codec::without_placeholders().encode_bytes(&v).unwrap(),
|
assert_eq!(Codec::without_placeholders().encode_bytes(&v.to_io_value()).unwrap(),
|
||||||
[147, 49, 120, 68, 111, 109, 58, 58, 84, 119, 111, 50]);
|
[147, 49, 120, 68, 111, 109, 58, 58, 84, 119, 111, 50]);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -236,13 +228,12 @@ mod value_tests {
|
||||||
#[cfg(test)]
|
#[cfg(test)]
|
||||||
mod decoder_tests {
|
mod decoder_tests {
|
||||||
use crate::value::{Decoder, BinaryReader};
|
use crate::value::{Decoder, BinaryReader};
|
||||||
use crate::value::{Value, PlainValue, NestedValue};
|
use crate::value::{Value, NestedValue};
|
||||||
use super::dom::Dom;
|
|
||||||
|
|
||||||
#[test] fn skip_annotations_noskip() {
|
#[test] fn skip_annotations_noskip() {
|
||||||
let mut buf = &b"\x0521"[..];
|
let mut buf = &b"\x0521"[..];
|
||||||
let r = BinaryReader::new(&mut buf);
|
let r = BinaryReader::new(&mut buf);
|
||||||
let mut d = Decoder::<_, PlainValue<Dom>, Dom>::new(r, None);
|
let mut d = Decoder::new(r, None);
|
||||||
let v = d.next_or_err().unwrap();
|
let v = d.next_or_err().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());
|
||||||
|
@ -252,7 +243,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 r = BinaryReader::new(&mut buf);
|
let r = BinaryReader::new(&mut buf);
|
||||||
let mut d = Decoder::<_, PlainValue<Dom>, Dom>::new(r, None);
|
let mut d = Decoder::new(r, None);
|
||||||
d.set_read_annotations(false);
|
d.set_read_annotations(false);
|
||||||
let v = d.next_or_err().unwrap();
|
let v = d.next_or_err().unwrap();
|
||||||
assert_eq!(v.annotations().len(), 0);
|
assert_eq!(v.annotations().len(), 0);
|
||||||
|
@ -263,7 +254,7 @@ mod decoder_tests {
|
||||||
let mut buf = &b"\x81tPing\x81tPong"[..];
|
let mut buf = &b"\x81tPing\x81tPong"[..];
|
||||||
assert_eq!(buf.len(), 12);
|
assert_eq!(buf.len(), 12);
|
||||||
let r = BinaryReader::new(&mut buf);
|
let r = BinaryReader::new(&mut buf);
|
||||||
let mut d = Decoder::<_, PlainValue<Dom>, Dom>::new(r, None);
|
let mut d = Decoder::new(r, None);
|
||||||
assert_eq!(d.next_or_err().unwrap().value(), &Value::simple_record("Ping", vec![]));
|
assert_eq!(d.next_or_err().unwrap().value(), &Value::simple_record("Ping", vec![]));
|
||||||
assert_eq!(d.next_or_err().unwrap().value(), &Value::simple_record("Pong", vec![]));
|
assert_eq!(d.next_or_err().unwrap().value(), &Value::simple_record("Pong", vec![]));
|
||||||
assert_eq!(buf.len(), 0);
|
assert_eq!(buf.len(), 0);
|
||||||
|
@ -273,11 +264,11 @@ mod decoder_tests {
|
||||||
let mut buf = &b"\x81tPing\x81tPong"[..];
|
let mut buf = &b"\x81tPing\x81tPong"[..];
|
||||||
assert_eq!(buf.len(), 12);
|
assert_eq!(buf.len(), 12);
|
||||||
let mut r = BinaryReader::new(&mut buf);
|
let mut r = BinaryReader::new(&mut buf);
|
||||||
let mut d = Decoder::<_, PlainValue<Dom>, Dom>::new(&mut r, None);
|
let mut d = Decoder::new(&mut r, None);
|
||||||
assert_eq!(d.next_or_err().unwrap().value(), &Value::simple_record("Ping", vec![]));
|
assert_eq!(d.next_or_err().unwrap().value(), &Value::simple_record("Ping", vec![]));
|
||||||
assert_eq!(buf.len(), 6);
|
assert_eq!(buf.len(), 6);
|
||||||
let mut r = BinaryReader::new(&mut buf);
|
let mut r = BinaryReader::new(&mut buf);
|
||||||
let mut d = Decoder::<_, PlainValue<Dom>, Dom>::new(&mut r, None);
|
let mut d = Decoder::new(&mut r, None);
|
||||||
assert_eq!(d.next_or_err().unwrap().value(), &Value::simple_record("Pong", vec![]));
|
assert_eq!(d.next_or_err().unwrap().value(), &Value::simple_record("Pong", vec![]));
|
||||||
assert_eq!(buf.len(), 0);
|
assert_eq!(buf.len(), 0);
|
||||||
}
|
}
|
||||||
|
@ -288,14 +279,13 @@ mod samples_tests {
|
||||||
use crate::symbol::Symbol;
|
use crate::symbol::Symbol;
|
||||||
use crate::value::{Codec, Decoder, BinaryReader};
|
use crate::value::{Codec, Decoder, BinaryReader};
|
||||||
use crate::value::reader::is_syntax_error;
|
use crate::value::reader::is_syntax_error;
|
||||||
use crate::value::{Value, PlainValue, Map};
|
use crate::value::{Value, IOValue, Map};
|
||||||
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::Dom;
|
|
||||||
|
|
||||||
#[derive(Debug, serde::Serialize, serde::Deserialize)]
|
#[derive(Debug, serde::Serialize, serde::Deserialize)]
|
||||||
struct ExpectedPlaceholderMapping(DecodePlaceholderMap<PlainValue<Dom>, Dom>);
|
struct ExpectedPlaceholderMapping(DecodePlaceholderMap);
|
||||||
|
|
||||||
#[derive(Debug, serde::Serialize, serde::Deserialize)]
|
#[derive(Debug, serde::Serialize, serde::Deserialize)]
|
||||||
struct TestCases {
|
struct TestCases {
|
||||||
|
@ -305,10 +295,10 @@ 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<Dom>),
|
Test(#[serde(with = "serde_bytes")] Vec<u8>, IOValue),
|
||||||
NondeterministicTest(#[serde(with = "serde_bytes")] Vec<u8>, PlainValue<Dom>),
|
NondeterministicTest(#[serde(with = "serde_bytes")] Vec<u8>, IOValue),
|
||||||
StreamingTest(#[serde(with = "serde_bytes")] Vec<u8>, PlainValue<Dom>),
|
StreamingTest(#[serde(with = "serde_bytes")] Vec<u8>, IOValue),
|
||||||
DecodeTest(#[serde(with = "serde_bytes")] Vec<u8>, PlainValue<Dom>),
|
DecodeTest(#[serde(with = "serde_bytes")] Vec<u8>, IOValue),
|
||||||
ParseError(String),
|
ParseError(String),
|
||||||
ParseShort(String),
|
ParseShort(String),
|
||||||
DecodeError(#[serde(with = "serde_bytes")] Vec<u8>),
|
DecodeError(#[serde(with = "serde_bytes")] Vec<u8>),
|
||||||
|
@ -318,7 +308,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 r = BinaryReader::new(&mut fh);
|
let r = BinaryReader::new(&mut fh);
|
||||||
let mut d = Decoder::<_, PlainValue<Dom>, Dom>::new(r, None);
|
let mut d = Decoder::new(r, None);
|
||||||
let tests: TestCases = from_value(&d.next_or_err().unwrap()).unwrap();
|
let tests: TestCases = from_value(&d.next_or_err().unwrap()).unwrap();
|
||||||
// println!("{:#?}", tests);
|
// println!("{:#?}", tests);
|
||||||
|
|
||||||
|
@ -380,7 +370,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<Dom>);
|
IOValue);
|
||||||
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()),
|
||||||
|
@ -392,7 +382,7 @@ mod samples_tests {
|
||||||
12345,
|
12345,
|
||||||
Value::from("hi").wrap());
|
Value::from("hi").wrap());
|
||||||
println!("== v: {:#?}", v);
|
println!("== v: {:#?}", v);
|
||||||
let w: PlainValue<Dom> = to_value(&v);
|
let w: IOValue = to_value(&v);
|
||||||
println!("== w: {:#?}", w);
|
println!("== w: {:#?}", w);
|
||||||
let x = from_value(&w).unwrap();
|
let x = from_value(&w).unwrap();
|
||||||
println!("== x: {:#?}", &x);
|
println!("== x: {:#?}", &x);
|
||||||
|
|
|
@ -1,23 +1,18 @@
|
||||||
use serde::Serialize;
|
use serde::Serialize;
|
||||||
use super::value::writer::Writer;
|
use super::value::writer::Writer;
|
||||||
use super::value::{
|
use super::value::{Value, EncodePlaceholderMap, Encoder};
|
||||||
Value, NestedValue, PlainValue,
|
|
||||||
Domain, NullDomain,
|
|
||||||
EncodePlaceholderMap,
|
|
||||||
Encoder,
|
|
||||||
};
|
|
||||||
|
|
||||||
pub use super::error::Error;
|
pub use super::error::Error;
|
||||||
type Result<T> = std::result::Result<T, Error>;
|
type Result<T> = std::result::Result<T, Error>;
|
||||||
|
|
||||||
#[derive(Debug)]
|
#[derive(Debug)]
|
||||||
pub struct Serializer<'a, W: Writer, N: NestedValue<D>, D: Domain> {
|
pub struct Serializer<'a, W: Writer> {
|
||||||
pub write: &'a mut W,
|
pub write: &'a mut W,
|
||||||
placeholders: Option<&'a EncodePlaceholderMap<N, D>>,
|
placeholders: Option<&'a EncodePlaceholderMap>,
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'a, W: Writer, N: NestedValue<D>, D: Domain> Serializer<'a, W, N, D> {
|
impl<'a, W: Writer> Serializer<'a, W> {
|
||||||
pub fn new(write: &'a mut W, placeholders: Option<&'a EncodePlaceholderMap<N, D>>) -> Self {
|
pub fn new(write: &'a mut W, placeholders: Option<&'a EncodePlaceholderMap>) -> Self {
|
||||||
Serializer { write, placeholders }
|
Serializer { write, placeholders }
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -30,21 +25,21 @@ impl<'a, W: Writer, N: NestedValue<D>, D: Domain> Serializer<'a, W, N, D> {
|
||||||
}
|
}
|
||||||
|
|
||||||
#[derive(Debug)]
|
#[derive(Debug)]
|
||||||
pub struct SerializeCompound<'a, 'b, W: Writer, N: NestedValue<D>, D: Domain> {
|
pub struct SerializeCompound<'a, 'b, W: Writer> {
|
||||||
ser: &'a mut Serializer<'b, W, N, D>,
|
ser: &'a mut Serializer<'b, W>,
|
||||||
count: Option<usize>,
|
count: Option<usize>,
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'a, 'b, W: Writer, N: NestedValue<D>, D: Domain> serde::Serializer for &'a mut Serializer<'b, W, N, D> {
|
impl<'a, 'b, W: Writer> serde::Serializer for &'a mut Serializer<'b, W> {
|
||||||
type Ok = ();
|
type Ok = ();
|
||||||
type Error = Error;
|
type Error = Error;
|
||||||
type SerializeSeq = SerializeCompound<'a, 'b, W, N, D>;
|
type SerializeSeq = SerializeCompound<'a, 'b, W>;
|
||||||
type SerializeTuple = SerializeCompound<'a, 'b, W, N, D>;
|
type SerializeTuple = SerializeCompound<'a, 'b, W>;
|
||||||
type SerializeTupleStruct = SerializeCompound<'a, 'b, W, N, D>;
|
type SerializeTupleStruct = SerializeCompound<'a, 'b, W>;
|
||||||
type SerializeTupleVariant = SerializeCompound<'a, 'b, W, N, D>;
|
type SerializeTupleVariant = SerializeCompound<'a, 'b, W>;
|
||||||
type SerializeMap = SerializeCompound<'a, 'b, W, N, D>;
|
type SerializeMap = SerializeCompound<'a, 'b, W>;
|
||||||
type SerializeStruct = SerializeCompound<'a, 'b, W, N, D>;
|
type SerializeStruct = SerializeCompound<'a, 'b, W>;
|
||||||
type SerializeStructVariant = SerializeCompound<'a, 'b, W, N, D>;
|
type SerializeStructVariant = SerializeCompound<'a, 'b, W>;
|
||||||
|
|
||||||
fn serialize_bool(self, v: bool) -> Result<()> {
|
fn serialize_bool(self, v: bool) -> Result<()> {
|
||||||
Ok(self.write.write_bool(v)?)
|
Ok(self.write.write_bool(v)?)
|
||||||
|
@ -146,7 +141,7 @@ impl<'a, 'b, W: Writer, N: NestedValue<D>, D: Domain> serde::Serializer for &'a
|
||||||
{
|
{
|
||||||
match super::value::magic::receive_output_value(name, value) {
|
match super::value::magic::receive_output_value(name, value) {
|
||||||
Some(v) => {
|
Some(v) => {
|
||||||
Encoder::new(self.write, self.placeholders).write(&v.copy_via(&|_| unreachable!()))?;
|
Encoder::new(self.write, self.placeholders).write(&v)?;
|
||||||
Ok(())
|
Ok(())
|
||||||
}
|
}
|
||||||
None => {
|
None => {
|
||||||
|
@ -233,7 +228,7 @@ impl<'a, 'b, W: Writer, N: NestedValue<D>, D: Domain> serde::Serializer for &'a
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'a, 'b, W: Writer, N: NestedValue<D>, D: Domain> serde::ser::SerializeMap for SerializeCompound<'a, 'b, W, N, D> {
|
impl<'a, 'b, W: Writer> serde::ser::SerializeMap for SerializeCompound<'a, 'b, W> {
|
||||||
type Ok = ();
|
type Ok = ();
|
||||||
type Error = Error;
|
type Error = Error;
|
||||||
|
|
||||||
|
@ -253,7 +248,7 @@ impl<'a, 'b, W: Writer, N: NestedValue<D>, D: Domain> serde::ser::SerializeMap f
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'a, 'b, W: Writer, N: NestedValue<D>, D: Domain> serde::ser::SerializeStruct for SerializeCompound<'a, 'b, W, N, D> {
|
impl<'a, 'b, W: Writer> serde::ser::SerializeStruct for SerializeCompound<'a, 'b, W> {
|
||||||
type Ok = ();
|
type Ok = ();
|
||||||
type Error = Error;
|
type Error = Error;
|
||||||
|
|
||||||
|
@ -271,7 +266,7 @@ impl<'a, 'b, W: Writer, N: NestedValue<D>, D: Domain> serde::ser::SerializeStruc
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'a, 'b, W: Writer, N: NestedValue<D>, D: Domain> serde::ser::SerializeStructVariant for SerializeCompound<'a, 'b, W, N, D> {
|
impl<'a, 'b, W: Writer> serde::ser::SerializeStructVariant for SerializeCompound<'a, 'b, W> {
|
||||||
type Ok = ();
|
type Ok = ();
|
||||||
type Error = Error;
|
type Error = Error;
|
||||||
|
|
||||||
|
@ -289,7 +284,7 @@ impl<'a, 'b, W: Writer, N: NestedValue<D>, D: Domain> serde::ser::SerializeStruc
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'a, 'b, W: Writer, N: NestedValue<D>, D: Domain> serde::ser::SerializeTuple for SerializeCompound<'a, 'b, W, N, D> {
|
impl<'a, 'b, W: Writer> serde::ser::SerializeTuple for SerializeCompound<'a, 'b, W> {
|
||||||
type Ok = ();
|
type Ok = ();
|
||||||
type Error = Error;
|
type Error = Error;
|
||||||
|
|
||||||
|
@ -305,7 +300,7 @@ impl<'a, 'b, W: Writer, N: NestedValue<D>, D: Domain> serde::ser::SerializeTuple
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'a, 'b, W: Writer, N: NestedValue<D>, D: Domain> serde::ser::SerializeTupleStruct for SerializeCompound<'a, 'b, W, N, D> {
|
impl<'a, 'b, W: Writer> serde::ser::SerializeTupleStruct for SerializeCompound<'a, 'b, W> {
|
||||||
type Ok = ();
|
type Ok = ();
|
||||||
type Error = Error;
|
type Error = Error;
|
||||||
|
|
||||||
|
@ -321,7 +316,7 @@ impl<'a, 'b, W: Writer, N: NestedValue<D>, D: Domain> serde::ser::SerializeTuple
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'a, 'b, W: Writer, N: NestedValue<D>, D: Domain> serde::ser::SerializeTupleVariant for SerializeCompound<'a, 'b, W, N, D> {
|
impl<'a, 'b, W: Writer> serde::ser::SerializeTupleVariant for SerializeCompound<'a, 'b, W> {
|
||||||
type Ok = ();
|
type Ok = ();
|
||||||
type Error = Error;
|
type Error = Error;
|
||||||
|
|
||||||
|
@ -337,7 +332,7 @@ impl<'a, 'b, W: Writer, N: NestedValue<D>, D: Domain> serde::ser::SerializeTuple
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'a, 'b, W: Writer, N: NestedValue<D>, D: Domain> serde::ser::SerializeSeq for SerializeCompound<'a, 'b, W, N, D> {
|
impl<'a, 'b, W: Writer> serde::ser::SerializeSeq for SerializeCompound<'a, 'b, W> {
|
||||||
type Ok = ();
|
type Ok = ();
|
||||||
type Error = Error;
|
type Error = Error;
|
||||||
|
|
||||||
|
@ -354,6 +349,6 @@ impl<'a, 'b, W: Writer, N: NestedValue<D>, D: Domain> serde::ser::SerializeSeq f
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn to_writer<W: Writer, T: Serialize>(write: &mut W, value: &T) -> Result<()> {
|
pub fn to_writer<W: Writer, T: Serialize>(write: &mut W, value: &T) -> Result<()> {
|
||||||
let mut ser: Serializer<'_, W, PlainValue<NullDomain>, NullDomain> = Serializer::new(write, None);
|
let mut ser: Serializer<'_, W> = Serializer::new(write, None);
|
||||||
value.serialize(&mut ser)
|
value.serialize(&mut ser)
|
||||||
}
|
}
|
||||||
|
|
|
@ -4,18 +4,16 @@ use super::{
|
||||||
encoder::{Encoder, EncodePlaceholderMap},
|
encoder::{Encoder, EncodePlaceholderMap},
|
||||||
invert_map,
|
invert_map,
|
||||||
reader::{BinaryReader, is_eof_error},
|
reader::{BinaryReader, is_eof_error},
|
||||||
value::{
|
value::IOValue,
|
||||||
NestedValue, Domain,
|
|
||||||
},
|
|
||||||
};
|
};
|
||||||
|
|
||||||
pub struct Codec<N: NestedValue<D>, D: Domain> {
|
pub struct Codec {
|
||||||
pub decode_placeholders: Option<DecodePlaceholderMap<N, D>>,
|
pub decode_placeholders: Option<DecodePlaceholderMap>,
|
||||||
pub encode_placeholders: Option<EncodePlaceholderMap<N, D>>,
|
pub encode_placeholders: Option<EncodePlaceholderMap>,
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<N: NestedValue<D>, D: Domain> Codec<N, D> {
|
impl Codec {
|
||||||
pub fn new(decode_placeholders: DecodePlaceholderMap<N, D>) -> Self {
|
pub fn new(decode_placeholders: DecodePlaceholderMap) -> 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 }
|
||||||
}
|
}
|
||||||
|
@ -24,17 +22,18 @@ impl<N: NestedValue<D>, D: Domain> Codec<N, D> {
|
||||||
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<'a, BinaryReader<'r, R>, N, D> {
|
pub fn decoder<'a, 'r, R: Read>(&'a self, read: &'r mut R) -> Decoder<'a, BinaryReader<'r, R>> {
|
||||||
Decoder::new(BinaryReader::new(read), self.decode_placeholders.as_ref())
|
Decoder::new(BinaryReader::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, D> {
|
pub fn encoder<'a, 'w, W: Write>(&'a self, write: &'w mut W) -> Encoder<'w, 'a, W> {
|
||||||
Encoder::new(write, self.encode_placeholders.as_ref())
|
Encoder::new(write, self.encode_placeholders.as_ref())
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn decode_all<'r, R: Read>(&self, read: &'r mut R) -> decoder::Result<Vec<N>> {
|
pub fn decode_all<'r, R: Read>(&self, read: &'r mut R) -> decoder::Result<Vec<IOValue>> {
|
||||||
let mut r = BinaryReader::new(read);
|
let mut r = BinaryReader::new(read);
|
||||||
let vs: Vec<N> = Decoder::new(&mut r, self.decode_placeholders.as_ref()).collect::<decoder::Result<Vec<N>>>()?;
|
let vs: Vec<IOValue> = Decoder::new(&mut r, self.decode_placeholders.as_ref())
|
||||||
|
.collect::<decoder::Result<Vec<IOValue>>>()?;
|
||||||
match r.peek() {
|
match r.peek() {
|
||||||
Err(e) if is_eof_error(&e) => Ok(vs),
|
Err(e) if is_eof_error(&e) => Ok(vs),
|
||||||
Err(e) => Err(e),
|
Err(e) => Err(e),
|
||||||
|
@ -42,7 +41,7 @@ impl<N: NestedValue<D>, D: Domain> Codec<N, D> {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn encode_bytes(&self, v: &N) -> std::io::Result<Vec<u8>> {
|
pub fn encode_bytes(&self, v: &IOValue) -> std::io::Result<Vec<u8>> {
|
||||||
let mut buf: Vec<u8> = Vec::new();
|
let mut buf: Vec<u8> = Vec::new();
|
||||||
self.encoder(&mut buf).write(v)?;
|
self.encoder(&mut buf).write(v)?;
|
||||||
Ok(buf)
|
Ok(buf)
|
||||||
|
|
|
@ -1,23 +1,22 @@
|
||||||
use crate::value::{Value, NestedValue, Map, Domain};
|
use crate::value::{Value, NestedValue, IOValue, UnwrappedIOValue, Map};
|
||||||
use crate::value::value::{Float, Double};
|
use crate::value::value::{Float, Double};
|
||||||
use num::traits::cast::ToPrimitive;
|
use num::traits::cast::ToPrimitive;
|
||||||
use serde::Deserialize;
|
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 mod error {
|
pub mod error {
|
||||||
use num::bigint::BigInt;
|
use num::bigint::BigInt;
|
||||||
use crate::value::{PlainValue, Domain};
|
use crate::value::IOValue;
|
||||||
|
|
||||||
#[derive(Debug)]
|
#[derive(Debug)]
|
||||||
pub enum Error<D: Domain> {
|
pub enum Error {
|
||||||
Message(String),
|
Message(String),
|
||||||
InvalidUnicodeScalar(u32),
|
InvalidUnicodeScalar(u32),
|
||||||
NumberTooLarge(BigInt),
|
NumberTooLarge(BigInt),
|
||||||
CannotDeserializeAny,
|
CannotDeserializeAny,
|
||||||
Expected(ExpectedKind, PlainValue<D>),
|
Expected(ExpectedKind, IOValue),
|
||||||
}
|
}
|
||||||
|
|
||||||
#[derive(Debug)]
|
#[derive(Debug)]
|
||||||
|
@ -38,15 +37,15 @@ pub mod error {
|
||||||
Dictionary,
|
Dictionary,
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<D: Domain> serde::de::Error for Error<D> {
|
impl serde::de::Error for Error {
|
||||||
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<D: Domain> std::error::Error for Error<D> {}
|
impl std::error::Error for Error {}
|
||||||
|
|
||||||
impl<D: Domain> std::fmt::Display for Error<D> {
|
impl std::fmt::Display for Error {
|
||||||
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)
|
||||||
}
|
}
|
||||||
|
@ -56,39 +55,36 @@ pub mod error {
|
||||||
pub use error::Error;
|
pub use error::Error;
|
||||||
use error::ExpectedKind;
|
use error::ExpectedKind;
|
||||||
|
|
||||||
pub type Result<T, D> = std::result::Result<T, Error<D>>;
|
pub type Result<T> = std::result::Result<T, Error>;
|
||||||
|
|
||||||
pub struct Deserializer<'de, N: NestedValue<D>, D: Domain> {
|
pub struct Deserializer<'de> {
|
||||||
input: &'de N,
|
input: &'de IOValue,
|
||||||
phantom: PhantomData<D>,
|
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn from_value<'a, T, N: NestedValue<D>, D: 'a + Domain>(v: &'a N) ->
|
pub fn from_value<'a, T>(v: &'a IOValue) -> Result<T> where T: Deserialize<'a>
|
||||||
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<D>, D: 'de + Domain> Deserializer<'de, N, D> {
|
impl<'de> Deserializer<'de> {
|
||||||
pub fn from_value(v: &'de N) -> Self {
|
pub fn from_value(v: &'de IOValue) -> Self {
|
||||||
Deserializer{ input: v, phantom: PhantomData }
|
Deserializer { input: v }
|
||||||
}
|
}
|
||||||
|
|
||||||
fn check<'a, T, F>(&'a mut self, f: F, k: ExpectedKind) -> Result<T, D>
|
fn check<'a, T, F>(&'a mut self, f: F, k: ExpectedKind) -> Result<T>
|
||||||
where F: FnOnce(&'de Value<N, D>) -> Option<T>
|
where F: FnOnce(&'de UnwrappedIOValue) -> Option<T>
|
||||||
{
|
{
|
||||||
f(self.input.value()).ok_or_else(|| Error::Expected(k, self.input.copy_via_id()))
|
f(self.input.value()).ok_or_else(|| Error::Expected(k, self.input.clone()))
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'de, 'a, N: NestedValue<D>, D: 'de + Domain> serde::de::Deserializer<'de>
|
impl<'de, 'a> serde::de::Deserializer<'de> for &'a mut Deserializer<'de>
|
||||||
for &'a mut Deserializer<'de, N, D>
|
|
||||||
{
|
{
|
||||||
type Error = Error<D>;
|
type Error = Error;
|
||||||
|
|
||||||
fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, D> where V: Visitor<'de>
|
fn deserialize_any<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>
|
||||||
{
|
{
|
||||||
let v = self.input.value();
|
let v = self.input.value();
|
||||||
match v {
|
match v {
|
||||||
|
@ -123,70 +119,70 @@ impl<'de, 'a, N: NestedValue<D>, D: 'de + Domain> serde::de::Deserializer<'de>
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, D> where V: Visitor<'de>
|
fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value> 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, D> where V: Visitor<'de>
|
fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value> 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, D> where V: Visitor<'de>
|
fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value> 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, D> where V: Visitor<'de>
|
fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value> 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, D> where V: Visitor<'de>
|
fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value> 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, D> where V: Visitor<'de>
|
fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value> 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, D> where V: Visitor<'de>
|
fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value> 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, D> where V: Visitor<'de>
|
fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value> 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, D> where V: Visitor<'de>
|
fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value> 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, D> where V: Visitor<'de>
|
fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value> 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, D> where V: Visitor<'de>
|
fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value> 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, D> where V: Visitor<'de>
|
fn deserialize_char<V>(self, visitor: V) -> Result<V::Value> 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)))?;
|
||||||
|
@ -195,27 +191,27 @@ impl<'de, 'a, N: NestedValue<D>, D: 'de + Domain> serde::de::Deserializer<'de>
|
||||||
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, D> where V: Visitor<'de>
|
fn deserialize_str<V>(self, visitor: V) -> Result<V::Value> 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, D> where V: Visitor<'de>
|
fn deserialize_string<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>
|
||||||
{
|
{
|
||||||
self.deserialize_str(visitor)
|
self.deserialize_str(visitor)
|
||||||
}
|
}
|
||||||
|
|
||||||
fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, D> where V: Visitor<'de>
|
fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value> 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, D> where V: Visitor<'de>
|
fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value> 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, D> where V: Visitor<'de>
|
fn deserialize_option<V>(self, visitor: V) -> Result<V::Value> 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(),
|
||||||
|
@ -229,7 +225,7 @@ impl<'de, 'a, N: NestedValue<D>, D: 'de + Domain> serde::de::Deserializer<'de>
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, D> where V: Visitor<'de>
|
fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value> 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()
|
||||||
|
@ -239,7 +235,7 @@ impl<'de, 'a, N: NestedValue<D>, D: 'de + Domain> serde::de::Deserializer<'de>
|
||||||
}
|
}
|
||||||
|
|
||||||
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, D> where V: Visitor<'de>
|
-> Result<V::Value> 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()
|
||||||
|
@ -249,9 +245,9 @@ impl<'de, 'a, N: NestedValue<D>, D: 'de + Domain> serde::de::Deserializer<'de>
|
||||||
}
|
}
|
||||||
|
|
||||||
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, D> where V: Visitor<'de>
|
-> Result<V::Value> where V: Visitor<'de>
|
||||||
{
|
{
|
||||||
match super::magic::transmit_input_value(name, || self.input.copy_to_null_domain()) {
|
match super::magic::transmit_input_value(name, || self.input.clone()) {
|
||||||
Some(v) => visitor.visit_u64(v),
|
Some(v) => visitor.visit_u64(v),
|
||||||
None => {
|
None => {
|
||||||
let fs = self.check(|v| v.as_simple_record(name, Some(1)),
|
let fs = self.check(|v| v.as_simple_record(name, Some(1)),
|
||||||
|
@ -262,12 +258,12 @@ impl<'de, 'a, N: NestedValue<D>, D: 'de + Domain> serde::de::Deserializer<'de>
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, D> where V: Visitor<'de> {
|
fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value> 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, D> where V: Visitor<'de>
|
fn deserialize_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value> 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)))?;
|
||||||
|
@ -275,14 +271,14 @@ impl<'de, 'a, N: NestedValue<D>, D: 'de + Domain> serde::de::Deserializer<'de>
|
||||||
}
|
}
|
||||||
|
|
||||||
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, D> where V: Visitor<'de>
|
-> Result<V::Value> 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, D> where V: Visitor<'de> {
|
fn deserialize_map<V>(self, visitor: V) -> Result<V::Value> 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))
|
||||||
}
|
}
|
||||||
|
@ -291,7 +287,7 @@ impl<'de, 'a, N: NestedValue<D>, D: 'de + Domain> serde::de::Deserializer<'de>
|
||||||
name: &'static str,
|
name: &'static str,
|
||||||
fields: &'static [&'static str],
|
fields: &'static [&'static str],
|
||||||
visitor: V)
|
visitor: V)
|
||||||
-> Result<V::Value, D> where V: Visitor<'de>
|
-> Result<V::Value> 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())))?;
|
||||||
|
@ -302,39 +298,39 @@ impl<'de, 'a, N: NestedValue<D>, D: 'de + Domain> serde::de::Deserializer<'de>
|
||||||
_name: &'static str,
|
_name: &'static str,
|
||||||
_variants: &'static [&'static str],
|
_variants: &'static [&'static str],
|
||||||
visitor: V)
|
visitor: V)
|
||||||
-> Result<V::Value, D> where V: Visitor<'de>
|
-> Result<V::Value> where V: Visitor<'de>
|
||||||
{
|
{
|
||||||
visitor.visit_enum(self)
|
visitor.visit_enum(self)
|
||||||
}
|
}
|
||||||
|
|
||||||
fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, D> where V: Visitor<'de>
|
fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value> 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, D> where V: Visitor<'de>
|
fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>
|
||||||
{
|
{
|
||||||
visitor.visit_none()
|
visitor.visit_none()
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
pub struct VecSeq<'a, 'de: 'a, N: NestedValue<D>, D: Domain> {
|
pub struct VecSeq<'a, 'de: 'a> {
|
||||||
index: usize,
|
index: usize,
|
||||||
vec: &'de [N],
|
vec: &'de [IOValue],
|
||||||
de: &'a mut Deserializer<'de, N, D>,
|
de: &'a mut Deserializer<'de>,
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'de, 'a, N: NestedValue<D>, D: Domain> VecSeq<'a, 'de, N, D> {
|
impl<'de, 'a> VecSeq<'a, 'de> {
|
||||||
fn new(de: &'a mut Deserializer<'de, N, D>, vec: &'de [N]) -> Self {
|
fn new(de: &'a mut Deserializer<'de>, vec: &'de [IOValue]) -> Self {
|
||||||
VecSeq{ index: 0, vec, de }
|
VecSeq { index: 0, vec, de }
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'de, 'a, N: NestedValue<D>, D: 'de + Domain> SeqAccess<'de> for VecSeq<'a, 'de, N, D> {
|
impl<'de, 'a> SeqAccess<'de> for VecSeq<'a, 'de> {
|
||||||
type Error = Error<D>;
|
type Error = Error;
|
||||||
|
|
||||||
fn next_element_seed<T>(&mut self, seed: T)
|
fn next_element_seed<T>(&mut self, seed: T)
|
||||||
-> Result<Option<T::Value>, D> where T: DeserializeSeed<'de>
|
-> Result<Option<T::Value>> where T: DeserializeSeed<'de>
|
||||||
{
|
{
|
||||||
if self.index == self.vec.len() {
|
if self.index == self.vec.len() {
|
||||||
return Ok(None)
|
return Ok(None)
|
||||||
|
@ -347,23 +343,23 @@ impl<'de, 'a, N: NestedValue<D>, D: 'de + Domain> SeqAccess<'de> for VecSeq<'a,
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
pub struct DictMap<'a, 'de: 'a, N: NestedValue<D>, D: Domain> {
|
pub struct DictMap<'a, 'de: 'a> {
|
||||||
pending: Option<&'de N>,
|
pending: Option<&'de IOValue>,
|
||||||
iter: Box<dyn Iterator<Item = (&'de N, &'de N)> + 'a>,
|
iter: Box<dyn Iterator<Item = (&'de IOValue, &'de IOValue)> + 'a>,
|
||||||
de: &'a mut Deserializer<'de, N, D>,
|
de: &'a mut Deserializer<'de>,
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'de, 'a, N: NestedValue<D>, D: Domain> DictMap<'a, 'de, N, D> {
|
impl<'de, 'a> DictMap<'a, 'de> {
|
||||||
fn new(de: &'a mut Deserializer<'de, N, D>, d: &'de Map<N, N>) -> Self {
|
fn new(de: &'a mut Deserializer<'de>, d: &'de Map<IOValue, IOValue>) -> Self {
|
||||||
DictMap{ pending: None, iter: Box::new(d.iter()), de }
|
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> {
|
impl<'de, 'a> MapAccess<'de> for DictMap<'a, 'de> {
|
||||||
type Error = Error<D>;
|
type Error = Error;
|
||||||
|
|
||||||
fn next_key_seed<K>(&mut self, seed: K)
|
fn next_key_seed<K>(&mut self, seed: K)
|
||||||
-> Result<Option<K::Value>, D> where K: DeserializeSeed<'de>
|
-> Result<Option<K::Value>> where K: DeserializeSeed<'de>
|
||||||
{
|
{
|
||||||
match self.iter.next() {
|
match self.iter.next() {
|
||||||
None => Ok(None),
|
None => Ok(None),
|
||||||
|
@ -375,7 +371,7 @@ impl<'de, 'a, N: NestedValue<D>, D: 'de + Domain> MapAccess<'de> for DictMap<'a,
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, D> where V: DeserializeSeed<'de> {
|
fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value> 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;
|
||||||
|
@ -383,41 +379,41 @@ impl<'de, 'a, N: NestedValue<D>, D: 'de + Domain> MapAccess<'de> for DictMap<'a,
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'a, 'de, N: NestedValue<D>, D: 'de + Domain> EnumAccess<'de> for &'a mut Deserializer<'de, N, D> {
|
impl<'a, 'de> EnumAccess<'de> for &'a mut Deserializer<'de> {
|
||||||
type Error = Error<D>;
|
type Error = Error;
|
||||||
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), D> where V: DeserializeSeed<'de>
|
-> Result<(V::Value, Self::Variant)> where V: DeserializeSeed<'de>
|
||||||
{
|
{
|
||||||
let (lp, _) = self.check(|v| v.as_record(None), ExpectedKind::Record(None))?;
|
let (lp, _) = self.check(|v| v.as_record(None), ExpectedKind::Record(None))?;
|
||||||
let v = self.input;
|
let v = self.input;
|
||||||
self.input = N::boxunwrap(lp);
|
self.input = IOValue::boxunwrap(lp);
|
||||||
let variant = seed.deserialize(&mut *self)?;
|
let variant = seed.deserialize(&mut *self)?;
|
||||||
self.input = v;
|
self.input = v;
|
||||||
Ok((variant, self))
|
Ok((variant, self))
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'a, 'de, N: NestedValue<D>, D: 'de + Domain> VariantAccess<'de> for &'a mut Deserializer<'de, N, D> {
|
impl<'a, 'de> VariantAccess<'de> for &'a mut Deserializer<'de> {
|
||||||
type Error = Error<D>;
|
type Error = Error;
|
||||||
|
|
||||||
fn unit_variant(self) -> Result<(), D> {
|
fn unit_variant(self) -> Result<()> {
|
||||||
Ok(())
|
Ok(())
|
||||||
}
|
}
|
||||||
|
|
||||||
fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, D> where T: DeserializeSeed<'de> {
|
fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value> where T: DeserializeSeed<'de> {
|
||||||
let (_, fs) = self.check(|v| v.as_record(Some(1)), ExpectedKind::Record(Some(1)))?;
|
let (_, fs) = self.check(|v| v.as_record(Some(1)), ExpectedKind::Record(Some(1)))?;
|
||||||
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, D> where V: Visitor<'de> {
|
fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value> where V: Visitor<'de> {
|
||||||
visitor.visit_seq(VecSeq::new(self, &self.input.value().as_record(None).unwrap().1))
|
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)
|
fn struct_variant<V>(self, fields: &'static [&'static str], visitor: V)
|
||||||
-> Result<V::Value, D> where V: Visitor<'de>
|
-> Result<V::Value> where V: Visitor<'de>
|
||||||
{
|
{
|
||||||
visitor.visit_seq(VecSeq::new(self, &self.input.value().as_record(Some(fields.len())).unwrap().1))
|
visitor.visit_seq(VecSeq::new(self, &self.input.value().as_record(Some(fields.len())).unwrap().1))
|
||||||
}
|
}
|
||||||
|
|
|
@ -1,16 +1,16 @@
|
||||||
use super::reader::{Reader, is_eof_error};
|
use super::reader::{Reader, is_eof_error};
|
||||||
use super::value::{NestedValue, Domain};
|
use super::value::IOValue;
|
||||||
|
|
||||||
pub use super::reader::{Result, DecodePlaceholderMap};
|
pub use super::reader::{Result, DecodePlaceholderMap};
|
||||||
|
|
||||||
pub struct Decoder<'a, R: Reader, N: NestedValue<Dom>, Dom: Domain> {
|
pub struct Decoder<'a, R: Reader> {
|
||||||
pub read: R,
|
pub read: R,
|
||||||
placeholders: Option<&'a DecodePlaceholderMap<N, Dom>>,
|
placeholders: Option<&'a DecodePlaceholderMap>,
|
||||||
read_annotations: bool,
|
read_annotations: bool,
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'a, R: Reader, N: NestedValue<D>, D: Domain> Decoder<'a, R, N, D> {
|
impl<'a, R: Reader> Decoder<'a, R> {
|
||||||
pub fn new(read: R, placeholders: Option<&'a DecodePlaceholderMap<N, D>>) ->
|
pub fn new(read: R, placeholders: Option<&'a DecodePlaceholderMap>) ->
|
||||||
Self
|
Self
|
||||||
{
|
{
|
||||||
Decoder {
|
Decoder {
|
||||||
|
@ -24,13 +24,13 @@ impl<'a, R: Reader, N: NestedValue<D>, D: Domain> Decoder<'a, R, N, D> {
|
||||||
self.read_annotations = read_annotations
|
self.read_annotations = read_annotations
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn next_or_err(&mut self) -> Result<N> {
|
pub fn next_or_err(&mut self) -> Result<IOValue> {
|
||||||
self.read.next(self.placeholders, self.read_annotations)
|
self.read.next(self.placeholders, self.read_annotations)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'a, R: Reader, N: NestedValue<D>, D: Domain> std::iter::Iterator for Decoder<'a, R, N, D> {
|
impl<'a, R: Reader> std::iter::Iterator for Decoder<'a, R> {
|
||||||
type Item = Result<N>;
|
type Item = Result<IOValue>;
|
||||||
fn next(&mut self) -> Option<Self::Item> {
|
fn next(&mut self) -> Option<Self::Item> {
|
||||||
match self.next_or_err() {
|
match self.next_or_err() {
|
||||||
Err(e) if is_eof_error(&e) => None,
|
Err(e) if is_eof_error(&e) => None,
|
||||||
|
|
|
@ -1,21 +1,21 @@
|
||||||
use super::value::{Value, NestedValue, Float, Double, Map, Domain};
|
use super::value::{Value, NestedValue, Domain, IOValue, UnwrappedIOValue, Float, Double, Map};
|
||||||
use super::writer::Writer;
|
use super::writer::Writer;
|
||||||
|
|
||||||
pub use super::writer::Result;
|
pub use super::writer::Result;
|
||||||
|
|
||||||
pub type EncodePlaceholderMap<N, D> = Map<Value<N, D>, usize>;
|
pub type EncodePlaceholderMap = Map<UnwrappedIOValue, usize>;
|
||||||
|
|
||||||
pub struct Encoder<'a, 'b, W: Writer, N: NestedValue<D>, D: Domain> {
|
pub struct Encoder<'a, 'b, W: Writer> {
|
||||||
pub write: &'a mut W,
|
pub write: &'a mut W,
|
||||||
pub placeholders: Option<&'b EncodePlaceholderMap<N, D>>,
|
pub placeholders: Option<&'b EncodePlaceholderMap>,
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'a, 'b, W: Writer, N: NestedValue<D>, D: Domain> Encoder<'a, 'b, W, N, D> {
|
impl<'a, 'b, W: Writer> Encoder<'a, 'b, W> {
|
||||||
pub fn new(write: &'a mut W, placeholders: Option<&'b EncodePlaceholderMap<N, D>>) -> Self {
|
pub fn new(write: &'a mut W, placeholders: Option<&'b EncodePlaceholderMap>) -> Self {
|
||||||
Encoder{ write, placeholders }
|
Encoder{ write, placeholders }
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn write(&mut self, v: &N) -> Result {
|
pub fn write(&mut self, v: &IOValue) -> Result {
|
||||||
for ann in v.annotations() {
|
for ann in v.annotations() {
|
||||||
self.write.write_annotation_prefix()?;
|
self.write.write_annotation_prefix()?;
|
||||||
self.write(ann)?;
|
self.write(ann)?;
|
||||||
|
@ -23,7 +23,7 @@ impl<'a, 'b, W: Writer, N: NestedValue<D>, D: Domain> Encoder<'a, 'b, W, N, D> {
|
||||||
self.write_value(v.value())
|
self.write_value(v.value())
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn write_value(&mut self, v: &Value<N, D>) -> Result {
|
pub fn write_value(&mut self, v: &UnwrappedIOValue) -> Result {
|
||||||
match self.placeholders.and_then(|m| m.get(v)) {
|
match self.placeholders.and_then(|m| m.get(v)) {
|
||||||
Some(&n) => self.write.write_placeholder_ref(n),
|
Some(&n) => self.write.write_placeholder_ref(n),
|
||||||
None => match v {
|
None => match v {
|
||||||
|
@ -36,7 +36,7 @@ impl<'a, 'b, W: Writer, N: NestedValue<D>, D: Domain> Encoder<'a, 'b, W, N, D> {
|
||||||
Value::Symbol(ref s) => self.write.write_symbol(s),
|
Value::Symbol(ref s) => self.write.write_symbol(s),
|
||||||
Value::Record((ref l, ref fs)) => {
|
Value::Record((ref l, ref fs)) => {
|
||||||
self.write.open_record(fs.len())?;
|
self.write.open_record(fs.len())?;
|
||||||
self.write(N::boxunwrap(l))?;
|
self.write(IOValue::boxunwrap(l))?;
|
||||||
for f in fs { self.write(f)?; }
|
for f in fs { self.write(f)?; }
|
||||||
self.write.close_record()
|
self.write.close_record()
|
||||||
}
|
}
|
||||||
|
@ -55,7 +55,7 @@ impl<'a, 'b, W: Writer, N: NestedValue<D>, D: Domain> Encoder<'a, 'b, W, N, D> {
|
||||||
for (k, v) in vs { self.write(k)?; self.write(v)?; }
|
for (k, v) in vs { self.write(k)?; self.write(v)?; }
|
||||||
self.write.close_dictionary()
|
self.write.close_dictionary()
|
||||||
}
|
}
|
||||||
Value::Domain(ref d) => d.encode(self),
|
Value::Domain(ref d) => self.write(&d.as_preserves()?)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
|
@ -1,16 +1,9 @@
|
||||||
use super::{
|
use super::value::{
|
||||||
NullDomain,
|
IOValue,
|
||||||
value::{
|
|
||||||
ArcValue,
|
|
||||||
NestedValue,
|
|
||||||
Domain,
|
|
||||||
},
|
|
||||||
};
|
};
|
||||||
|
|
||||||
pub static MAGIC: &str = "$____Preserves_Serde_Magic";
|
pub static MAGIC: &str = "$____Preserves_Serde_Magic";
|
||||||
|
|
||||||
pub type IOValue = ArcValue<NullDomain>;
|
|
||||||
|
|
||||||
struct IOValueVisitor;
|
struct IOValueVisitor;
|
||||||
impl<'de> serde::de::Visitor<'de> for IOValueVisitor {
|
impl<'de> serde::de::Visitor<'de> for IOValueVisitor {
|
||||||
type Value = IOValue;
|
type Value = IOValue;
|
||||||
|
@ -35,12 +28,6 @@ pub fn input_value<'de, D: serde::Deserializer<'de>>(deserializer: D) ->
|
||||||
deserializer.deserialize_newtype_struct(MAGIC, IOValueVisitor)
|
deserializer.deserialize_newtype_struct(MAGIC, IOValueVisitor)
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn input_value_via<'de, D: serde::Deserializer<'de>, N: NestedValue<Dom>, Dom: Domain>(deserializer: D) ->
|
|
||||||
Result<N, D::Error>
|
|
||||||
{
|
|
||||||
Ok(input_value(deserializer)?.copy_via(&|_| unreachable!()))
|
|
||||||
}
|
|
||||||
|
|
||||||
//---------------------------------------------------------------------------
|
//---------------------------------------------------------------------------
|
||||||
|
|
||||||
pub fn receive_output_value<T: ?Sized>(name: &'static str, magic_value: &T) -> Option<IOValue> {
|
pub fn receive_output_value<T: ?Sized>(name: &'static str, magic_value: &T) -> Option<IOValue> {
|
||||||
|
|
|
@ -23,15 +23,18 @@ pub use reader::is_eof_error;
|
||||||
pub use reader::is_syntax_error;
|
pub use reader::is_syntax_error;
|
||||||
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::Value;
|
|
||||||
pub use value::AnnotatedValue;
|
pub use value::AnnotatedValue;
|
||||||
|
pub use value::ArcValue;
|
||||||
|
pub use value::Domain;
|
||||||
|
pub use value::IOValue;
|
||||||
|
pub use value::Map;
|
||||||
|
pub use value::NestedValue;
|
||||||
|
pub use value::NullDomain;
|
||||||
pub use value::PlainValue;
|
pub use value::PlainValue;
|
||||||
pub use value::RcValue;
|
pub use value::RcValue;
|
||||||
pub use value::ArcValue;
|
|
||||||
pub use value::Set;
|
pub use value::Set;
|
||||||
pub use value::Map;
|
pub use value::UnwrappedIOValue;
|
||||||
|
pub use value::Value;
|
||||||
pub use writer::Writer;
|
pub use writer::Writer;
|
||||||
|
|
||||||
pub fn invert_map<A, B>(m: &Map<A, B>) -> Map<B, A>
|
pub fn invert_map<A, B>(m: &Map<A, B>) -> Map<B, A>
|
||||||
|
@ -40,7 +43,3 @@ pub fn invert_map<A, B>(m: &Map<A, B>) -> Map<B, A>
|
||||||
use std::iter::FromIterator;
|
use std::iter::FromIterator;
|
||||||
Map::from_iter(m.iter().map(|(a, b)| (b.clone(), a.clone())))
|
Map::from_iter(m.iter().map(|(a, b)| (b.clone(), a.clone())))
|
||||||
}
|
}
|
||||||
|
|
||||||
#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
|
|
||||||
pub enum NullDomain {}
|
|
||||||
impl Domain for NullDomain {}
|
|
||||||
|
|
|
@ -3,7 +3,7 @@ use std::convert::TryFrom;
|
||||||
use std::convert::TryInto;
|
use std::convert::TryInto;
|
||||||
use std::io::{Read, Error};
|
use std::io::{Read, Error};
|
||||||
use super::constants::{Op, InvalidOp, AtomMinor, CompoundMinor};
|
use super::constants::{Op, InvalidOp, AtomMinor, CompoundMinor};
|
||||||
use super::value::{Value, Domain, NestedValue, Map, Set};
|
use super::value::{Value, NestedValue, IOValue, UnwrappedIOValue, Map, Set};
|
||||||
|
|
||||||
pub type Result<T> = std::result::Result<T, Error>;
|
pub type Result<T> = std::result::Result<T, Error>;
|
||||||
|
|
||||||
|
@ -14,22 +14,22 @@ enum PeekState {
|
||||||
Full(u8),
|
Full(u8),
|
||||||
}
|
}
|
||||||
|
|
||||||
pub type DecodePlaceholderMap<N, D> = Map<usize, Value<N, D>>;
|
pub type DecodePlaceholderMap = Map<usize, UnwrappedIOValue>;
|
||||||
|
|
||||||
pub trait Reader {
|
pub trait Reader {
|
||||||
fn next<N: NestedValue<Dom>, Dom: Domain>(
|
fn next(
|
||||||
&mut self,
|
&mut self,
|
||||||
placeholders: Option<&DecodePlaceholderMap<N, Dom>>,
|
placeholders: Option<&DecodePlaceholderMap>,
|
||||||
read_annotations: bool,
|
read_annotations: bool,
|
||||||
) -> Result<N>;
|
) -> Result<IOValue>;
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'re, R: Reader> Reader for &'re mut R {
|
impl<'re, R: Reader> Reader for &'re mut R {
|
||||||
fn next<N: NestedValue<Dom>, Dom: Domain>(
|
fn next(
|
||||||
&mut self,
|
&mut self,
|
||||||
placeholders: Option<&DecodePlaceholderMap<N, Dom>>,
|
placeholders: Option<&DecodePlaceholderMap>,
|
||||||
read_annotations: bool,
|
read_annotations: bool,
|
||||||
) -> Result<N> {
|
) -> Result<IOValue> {
|
||||||
(*self).next(placeholders, read_annotations)
|
(*self).next(placeholders, read_annotations)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -39,21 +39,20 @@ pub struct BinaryReader<'a, R: Read> {
|
||||||
buf: PeekState,
|
buf: PeekState,
|
||||||
}
|
}
|
||||||
|
|
||||||
struct ConfiguredBinaryReader<'de, 'pl, 'a, R: Read, N: NestedValue<Dom>, Dom: Domain> {
|
struct ConfiguredBinaryReader<'de, 'pl, 'a, R: Read> {
|
||||||
reader: &'de mut BinaryReader<'a, R>,
|
reader: &'de mut BinaryReader<'a, R>,
|
||||||
placeholders: Option<&'pl DecodePlaceholderMap<N, Dom>>,
|
placeholders: Option<&'pl DecodePlaceholderMap>,
|
||||||
read_annotations: bool,
|
read_annotations: bool,
|
||||||
}
|
}
|
||||||
|
|
||||||
struct CountedStream<'de, 'pl, 'a, R: Read, N: NestedValue<Dom>, Dom: Domain> {
|
struct CountedStream<'de, 'pl, 'a, R: Read> {
|
||||||
reader: ConfiguredBinaryReader<'de, 'pl, 'a, R, N, Dom>,
|
reader: ConfiguredBinaryReader<'de, 'pl, 'a, R>,
|
||||||
count: usize,
|
count: usize,
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'de, 'pl, 'a, R: Read, N: NestedValue<Dom>, Dom: Domain> Iterator
|
impl<'de, 'pl, 'a, R: Read> Iterator for CountedStream<'de, 'pl, 'a, R>
|
||||||
for CountedStream<'de, 'pl, 'a, R, N, Dom>
|
|
||||||
{
|
{
|
||||||
type Item = Result<N>;
|
type Item = Result<IOValue>;
|
||||||
fn next(&mut self) -> Option<Self::Item> {
|
fn next(&mut self) -> Option<Self::Item> {
|
||||||
if self.count == 0 { return None }
|
if self.count == 0 { return None }
|
||||||
self.count -= 1;
|
self.count -= 1;
|
||||||
|
@ -61,14 +60,13 @@ impl<'de, 'pl, 'a, R: Read, N: NestedValue<Dom>, Dom: Domain> Iterator
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
struct DelimitedStream<'de, 'pl, 'a, R: Read, N: NestedValue<Dom>, Dom: Domain> {
|
struct DelimitedStream<'de, 'pl, 'a, R: Read> {
|
||||||
reader: ConfiguredBinaryReader<'de, 'pl, 'a, R, N, Dom>,
|
reader: ConfiguredBinaryReader<'de, 'pl, 'a, R>,
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'de, 'pl, 'a, R: Read, N: NestedValue<Dom>, Dom: Domain> Iterator
|
impl<'de, 'pl, 'a, R: Read> Iterator for DelimitedStream<'de, 'pl, 'a, R>
|
||||||
for DelimitedStream<'de, 'pl, 'a, R, N, Dom>
|
|
||||||
{
|
{
|
||||||
type Item = Result<N>;
|
type Item = Result<IOValue>;
|
||||||
fn next(&mut self) -> Option<Self::Item> {
|
fn next(&mut self) -> Option<Self::Item> {
|
||||||
match self.reader.reader.peekend() {
|
match self.reader.reader.peekend() {
|
||||||
Err(e) => Some(Err(e)),
|
Err(e) => Some(Err(e)),
|
||||||
|
@ -90,7 +88,7 @@ pub fn decodestr(bs: &[u8]) -> Result<&str> {
|
||||||
std::str::from_utf8(bs).map_err(|_| err("Invalid UTF-8"))
|
std::str::from_utf8(bs).map_err(|_| err("Invalid UTF-8"))
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn decodebinary<N: NestedValue<Dom>, Dom: Domain>(minor: AtomMinor, bs: Vec<u8>) -> Result<N> {
|
pub fn decodebinary(minor: AtomMinor, bs: Vec<u8>) -> Result<IOValue> {
|
||||||
match minor {
|
match minor {
|
||||||
AtomMinor::SignedInteger => Ok(Value::from(decodeint(&bs)).wrap()),
|
AtomMinor::SignedInteger => Ok(Value::from(decodeint(&bs)).wrap()),
|
||||||
AtomMinor::String => Ok(Value::from(decodestr(&bs)?).wrap()),
|
AtomMinor::String => Ok(Value::from(decodestr(&bs)?).wrap()),
|
||||||
|
@ -99,12 +97,8 @@ pub fn decodebinary<N: NestedValue<Dom>, Dom: Domain>(minor: AtomMinor, bs: Vec<
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
pub fn decodecompound<I: Iterator<Item = Result<IOValue>>>(minor: CompoundMinor, mut iter: I) ->
|
||||||
pub fn decodecompound<N: NestedValue<Dom>, Dom: Domain, I: Iterator<Item = Result<N>>>(
|
Result<IOValue>
|
||||||
minor: CompoundMinor,
|
|
||||||
mut iter: I,
|
|
||||||
) ->
|
|
||||||
Result<N>
|
|
||||||
{
|
{
|
||||||
match minor {
|
match minor {
|
||||||
CompoundMinor::Record =>
|
CompoundMinor::Record =>
|
||||||
|
@ -112,11 +106,11 @@ pub fn decodecompound<N: NestedValue<Dom>, Dom: Domain, I: Iterator<Item = Resul
|
||||||
None => Err(err("Too few elements in encoded record")),
|
None => Err(err("Too few elements in encoded record")),
|
||||||
Some(labelres) => {
|
Some(labelres) => {
|
||||||
let label = labelres?;
|
let label = labelres?;
|
||||||
Ok(Value::record(label, iter.collect::<Result<Vec<N>>>()?).wrap())
|
Ok(Value::record(label, iter.collect::<Result<Vec<IOValue>>>()?).wrap())
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
CompoundMinor::Sequence => {
|
CompoundMinor::Sequence => {
|
||||||
Ok(Value::Sequence(iter.collect::<Result<Vec<N>>>()?).wrap())
|
Ok(Value::Sequence(iter.collect::<Result<Vec<IOValue>>>()?).wrap())
|
||||||
}
|
}
|
||||||
CompoundMinor::Set => {
|
CompoundMinor::Set => {
|
||||||
let mut s = Set::new();
|
let mut s = Set::new();
|
||||||
|
@ -244,12 +238,12 @@ impl<'a, R: Read> BinaryReader<'a, R> {
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'re, 'a, R: Read> Reader for BinaryReader<'a, R> {
|
impl<'re, 'a, R: Read> Reader for BinaryReader<'a, R> {
|
||||||
fn next<N: NestedValue<Dom>, Dom: Domain>(
|
fn next(
|
||||||
&mut self,
|
&mut self,
|
||||||
placeholders: Option<&DecodePlaceholderMap<N, Dom>>,
|
placeholders: Option<&DecodePlaceholderMap>,
|
||||||
read_annotations: bool
|
read_annotations: bool
|
||||||
) ->
|
) ->
|
||||||
Result<N>
|
Result<IOValue>
|
||||||
{
|
{
|
||||||
loop {
|
loop {
|
||||||
return match decodeop(self.read()?)? {
|
return match decodeop(self.read()?)? {
|
||||||
|
@ -274,7 +268,7 @@ impl<'re, 'a, R: Read> Reader for BinaryReader<'a, R> {
|
||||||
}
|
}
|
||||||
let v = self.next(placeholders, read_annotations)?;
|
let v = self.next(placeholders, read_annotations)?;
|
||||||
assert!(v.annotations().is_empty());
|
assert!(v.annotations().is_empty());
|
||||||
Ok(N::wrap_ann(annotations, v.value_owned()))
|
Ok(IOValue::wrap_ann(annotations, v.value_owned()))
|
||||||
} else {
|
} else {
|
||||||
let _ = self.next(placeholders, read_annotations)?;
|
let _ = self.next(placeholders, read_annotations)?;
|
||||||
continue;
|
continue;
|
||||||
|
|
|
@ -1,6 +1,5 @@
|
||||||
use crate::value::{Value, NestedValue, Map, Domain};
|
use crate::value::{Value, Map, IOValue};
|
||||||
use serde::Serialize;
|
use serde::Serialize;
|
||||||
use std::marker::PhantomData;
|
|
||||||
|
|
||||||
#[derive(Debug)]
|
#[derive(Debug)]
|
||||||
pub enum Error {}
|
pub enum Error {}
|
||||||
|
@ -18,37 +17,32 @@ impl std::fmt::Display for Error {
|
||||||
|
|
||||||
type Result<T> = std::result::Result<T, Error>;
|
type Result<T> = std::result::Result<T, Error>;
|
||||||
|
|
||||||
pub struct Serializer<N: NestedValue<D>, D: Domain> {
|
pub struct Serializer;
|
||||||
phantom: PhantomData<(N, D)>,
|
|
||||||
|
pub struct SerializeDictionary {
|
||||||
|
next_key: Option<IOValue>,
|
||||||
|
items: Map<IOValue, IOValue>,
|
||||||
}
|
}
|
||||||
|
|
||||||
pub struct SerializeDictionary<N: NestedValue<D>, D: Domain> {
|
pub struct SerializeRecord {
|
||||||
next_key: Option<N>,
|
|
||||||
items: Map<N,N>,
|
|
||||||
phantom: PhantomData<D>,
|
|
||||||
}
|
|
||||||
|
|
||||||
pub struct SerializeRecord<N: NestedValue<D>, D: Domain> {
|
|
||||||
name: &'static str,
|
name: &'static str,
|
||||||
vec: Vec<N>,
|
vec: Vec<IOValue>,
|
||||||
phantom: PhantomData<D>,
|
|
||||||
}
|
}
|
||||||
|
|
||||||
pub struct SerializeSequence<N: NestedValue<D>, D: Domain> {
|
pub struct SerializeSequence {
|
||||||
vec: Vec<N>,
|
vec: Vec<IOValue>,
|
||||||
phantom: PhantomData<D>,
|
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<N: NestedValue<D>, D: Domain> serde::Serializer for Serializer<N, D> {
|
impl serde::Serializer for Serializer {
|
||||||
type Ok = N;
|
type Ok = IOValue;
|
||||||
type Error = Error;
|
type Error = Error;
|
||||||
type SerializeSeq = SerializeSequence<N, D>;
|
type SerializeSeq = SerializeSequence;
|
||||||
type SerializeTuple = SerializeRecord<N, D>;
|
type SerializeTuple = SerializeRecord;
|
||||||
type SerializeTupleStruct = SerializeRecord<N, D>;
|
type SerializeTupleStruct = SerializeRecord;
|
||||||
type SerializeTupleVariant = SerializeRecord<N, D>;
|
type SerializeTupleVariant = SerializeRecord;
|
||||||
type SerializeMap = SerializeDictionary<N, D>;
|
type SerializeMap = SerializeDictionary;
|
||||||
type SerializeStruct = SerializeRecord<N, D>;
|
type SerializeStruct = SerializeRecord;
|
||||||
type SerializeStructVariant = SerializeRecord<N, D>;
|
type SerializeStructVariant = SerializeRecord;
|
||||||
|
|
||||||
fn serialize_bool(self, v: bool) -> Result<Self::Ok> {
|
fn serialize_bool(self, v: bool) -> Result<Self::Ok> {
|
||||||
Ok(Value::from(v).wrap())
|
Ok(Value::from(v).wrap())
|
||||||
|
@ -135,7 +129,7 @@ impl<N: NestedValue<D>, D: Domain> serde::Serializer for Serializer<N, D> {
|
||||||
Result<Self::Ok> where T: Serialize
|
Result<Self::Ok> where T: Serialize
|
||||||
{
|
{
|
||||||
match super::magic::receive_output_value(name, value) {
|
match super::magic::receive_output_value(name, value) {
|
||||||
Some(v) => Ok(v.copy_via(&|_| unreachable!())),
|
Some(v) => Ok(v),
|
||||||
None => {
|
None => {
|
||||||
// TODO: This is apparently discouraged, and we should apparently just serialize `value`?
|
// TODO: This is apparently discouraged, and we should apparently just serialize `value`?
|
||||||
Ok(Value::simple_record(name, vec![to_value(value)]).wrap())
|
Ok(Value::simple_record(name, vec![to_value(value)]).wrap())
|
||||||
|
@ -155,17 +149,17 @@ impl<N: NestedValue<D>, D: Domain> serde::Serializer for Serializer<N, D> {
|
||||||
|
|
||||||
fn serialize_seq(self, count: Option<usize>) -> Result<Self::SerializeSeq> {
|
fn serialize_seq(self, count: Option<usize>) -> Result<Self::SerializeSeq> {
|
||||||
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, phantom: PhantomData })
|
Ok(SerializeSequence { vec })
|
||||||
}
|
}
|
||||||
|
|
||||||
fn serialize_tuple(self, count: usize) -> Result<Self::SerializeTuple> {
|
fn serialize_tuple(self, count: usize) -> Result<Self::SerializeTuple> {
|
||||||
Ok(SerializeRecord{ name: "tuple", vec: Vec::with_capacity(count), phantom: PhantomData })
|
Ok(SerializeRecord { name: "tuple", vec: Vec::with_capacity(count) })
|
||||||
}
|
}
|
||||||
|
|
||||||
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>
|
||||||
{
|
{
|
||||||
Ok(SerializeRecord{ name, vec: Vec::with_capacity(count), phantom: PhantomData })
|
Ok(SerializeRecord { name, vec: Vec::with_capacity(count) })
|
||||||
}
|
}
|
||||||
|
|
||||||
fn serialize_tuple_variant(self,
|
fn serialize_tuple_variant(self,
|
||||||
|
@ -175,15 +169,15 @@ impl<N: NestedValue<D>, D: Domain> serde::Serializer for Serializer<N, D> {
|
||||||
count: usize) ->
|
count: usize) ->
|
||||||
Result<Self::SerializeTupleVariant>
|
Result<Self::SerializeTupleVariant>
|
||||||
{
|
{
|
||||||
Ok(SerializeRecord{ name: variant_name, vec: Vec::with_capacity(count), phantom: PhantomData })
|
Ok(SerializeRecord { name: variant_name, vec: Vec::with_capacity(count) })
|
||||||
}
|
}
|
||||||
|
|
||||||
fn serialize_map(self, _count: Option<usize>) -> Result<Self::SerializeMap> {
|
fn serialize_map(self, _count: Option<usize>) -> Result<Self::SerializeMap> {
|
||||||
Ok(SerializeDictionary{ next_key: None, items: Map::new(), phantom: PhantomData })
|
Ok(SerializeDictionary { next_key: None, items: Map::new() })
|
||||||
}
|
}
|
||||||
|
|
||||||
fn serialize_struct(self, name: &'static str, count: usize) -> Result<Self::SerializeStruct> {
|
fn serialize_struct(self, name: &'static str, count: usize) -> Result<Self::SerializeStruct> {
|
||||||
Ok(SerializeRecord{ name, vec: Vec::with_capacity(count), phantom: PhantomData })
|
Ok(SerializeRecord { name, vec: Vec::with_capacity(count) })
|
||||||
}
|
}
|
||||||
|
|
||||||
fn serialize_struct_variant(self,
|
fn serialize_struct_variant(self,
|
||||||
|
@ -193,12 +187,12 @@ impl<N: NestedValue<D>, D: Domain> serde::Serializer for Serializer<N, D> {
|
||||||
count: usize) ->
|
count: usize) ->
|
||||||
Result<Self::SerializeStructVariant>
|
Result<Self::SerializeStructVariant>
|
||||||
{
|
{
|
||||||
Ok(SerializeRecord{ name: variant_name, vec: Vec::with_capacity(count), phantom: PhantomData })
|
Ok(SerializeRecord { name: variant_name, vec: Vec::with_capacity(count) })
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<N: NestedValue<D>, D: Domain> serde::ser::SerializeMap for SerializeDictionary<N, D> {
|
impl serde::ser::SerializeMap for SerializeDictionary {
|
||||||
type Ok = N;
|
type Ok = IOValue;
|
||||||
type Error = Error;
|
type Error = Error;
|
||||||
|
|
||||||
fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<()> where T: Serialize {
|
fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<()> where T: Serialize {
|
||||||
|
@ -217,19 +211,19 @@ impl<N: NestedValue<D>, D: Domain> serde::ser::SerializeMap for SerializeDiction
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<N: NestedValue<D>, D: Domain> SerializeRecord<N, D> {
|
impl SerializeRecord {
|
||||||
fn push(&mut self, value: N) -> Result<()> {
|
fn push(&mut self, value: IOValue) -> Result<()> {
|
||||||
self.vec.push(value);
|
self.vec.push(value);
|
||||||
Ok(())
|
Ok(())
|
||||||
}
|
}
|
||||||
|
|
||||||
fn finish(self) -> Result<N> {
|
fn finish(self) -> Result<IOValue> {
|
||||||
Ok(Value::simple_record(self.name, self.vec).wrap())
|
Ok(Value::simple_record(self.name, self.vec).wrap())
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<N: NestedValue<D>, D: Domain> serde::ser::SerializeStruct for SerializeRecord<N, D> {
|
impl serde::ser::SerializeStruct for SerializeRecord {
|
||||||
type Ok = N;
|
type Ok = IOValue;
|
||||||
type Error = Error;
|
type Error = Error;
|
||||||
|
|
||||||
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<()>
|
||||||
|
@ -243,8 +237,8 @@ impl<N: NestedValue<D>, D: Domain> serde::ser::SerializeStruct for SerializeReco
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<N: NestedValue<D>, D: Domain> serde::ser::SerializeStructVariant for SerializeRecord<N, D> {
|
impl serde::ser::SerializeStructVariant for SerializeRecord {
|
||||||
type Ok = N;
|
type Ok = IOValue;
|
||||||
type Error = Error;
|
type Error = Error;
|
||||||
|
|
||||||
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<()>
|
||||||
|
@ -258,8 +252,8 @@ impl<N: NestedValue<D>, D: Domain> serde::ser::SerializeStructVariant for Serial
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<N: NestedValue<D>, D: Domain> serde::ser::SerializeTuple for SerializeRecord<N, D> {
|
impl serde::ser::SerializeTuple for SerializeRecord {
|
||||||
type Ok = N;
|
type Ok = IOValue;
|
||||||
type Error = Error;
|
type Error = Error;
|
||||||
|
|
||||||
fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<()> where T: Serialize {
|
fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<()> where T: Serialize {
|
||||||
|
@ -271,8 +265,8 @@ impl<N: NestedValue<D>, D: Domain> serde::ser::SerializeTuple for SerializeRecor
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<N: NestedValue<D>, D: Domain> serde::ser::SerializeTupleStruct for SerializeRecord<N, D> {
|
impl serde::ser::SerializeTupleStruct for SerializeRecord {
|
||||||
type Ok = N;
|
type Ok = IOValue;
|
||||||
type Error = Error;
|
type Error = Error;
|
||||||
|
|
||||||
fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<()> where T: Serialize {
|
fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<()> where T: Serialize {
|
||||||
|
@ -284,8 +278,8 @@ impl<N: NestedValue<D>, D: Domain> serde::ser::SerializeTupleStruct for Serializ
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<N: NestedValue<D>, D: Domain> serde::ser::SerializeTupleVariant for SerializeRecord<N, D> {
|
impl serde::ser::SerializeTupleVariant for SerializeRecord {
|
||||||
type Ok = N;
|
type Ok = IOValue;
|
||||||
type Error = Error;
|
type Error = Error;
|
||||||
|
|
||||||
fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<()> where T: Serialize {
|
fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<()> where T: Serialize {
|
||||||
|
@ -297,8 +291,8 @@ impl<N: NestedValue<D>, D: Domain> serde::ser::SerializeTupleVariant for Seriali
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<N: NestedValue<D>, D: Domain> serde::ser::SerializeSeq for SerializeSequence<N, D> {
|
impl serde::ser::SerializeSeq for SerializeSequence {
|
||||||
type Ok = N;
|
type Ok = IOValue;
|
||||||
type Error = Error;
|
type Error = Error;
|
||||||
|
|
||||||
fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<()> where T: Serialize {
|
fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<()> where T: Serialize {
|
||||||
|
@ -311,6 +305,6 @@ impl<N: NestedValue<D>, D: Domain> serde::ser::SerializeSeq for SerializeSequenc
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn to_value<T, N, D: Domain>(value: T) -> N where T: Serialize, N: NestedValue<D> {
|
pub fn to_value<T>(value: T) -> IOValue where T: Serialize {
|
||||||
value.serialize(Serializer{ phantom: PhantomData }).unwrap()
|
value.serialize(Serializer).unwrap()
|
||||||
}
|
}
|
||||||
|
|
|
@ -1,25 +1,18 @@
|
||||||
use std::hash::{Hash,Hasher};
|
use num::bigint::BigInt;
|
||||||
|
use num::traits::cast::ToPrimitive;
|
||||||
use std::cmp::{Ordering};
|
use std::cmp::{Ordering};
|
||||||
use std::fmt::Debug;
|
use std::fmt::Debug;
|
||||||
use num::bigint::BigInt;
|
use std::hash::{Hash,Hasher};
|
||||||
use std::vec::Vec;
|
|
||||||
use std::string::String;
|
|
||||||
use std::ops::Index;
|
use std::ops::Index;
|
||||||
use std::ops::IndexMut;
|
use std::ops::IndexMut;
|
||||||
use num::traits::cast::ToPrimitive;
|
use std::string::String;
|
||||||
|
use std::vec::Vec;
|
||||||
|
|
||||||
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 Domain: Sized + Debug + Clone + Eq + Hash + Ord {
|
pub trait Domain: Sized + Debug + Clone + Eq + Hash + Ord {
|
||||||
fn encode<'a, 'b, W: super::writer::Writer, N: NestedValue<Self>>(
|
fn as_preserves(&self) -> Result<IOValue, std::io::Error> {
|
||||||
&self, enc: &mut super::encoder::Encoder<'a, 'b, W, N, Self>) ->
|
|
||||||
super::encoder::Result
|
|
||||||
{
|
|
||||||
enc.write(&self.as_preserves()?)
|
|
||||||
}
|
|
||||||
|
|
||||||
fn as_preserves<N: NestedValue<D>, D: Domain>(&self) -> Result<N, std::io::Error> {
|
|
||||||
Err(std::io::Error::new(std::io::ErrorKind::InvalidData,
|
Err(std::io::Error::new(std::io::ErrorKind::InvalidData,
|
||||||
format!("Cannot Preserves-encode domain-specific value {:?}",
|
format!("Cannot Preserves-encode domain-specific value {:?}",
|
||||||
self)))
|
self)))
|
||||||
|
@ -58,8 +51,12 @@ pub trait NestedValue<D: Domain>: Sized + Debug + Clone + Eq + Hash + Ord {
|
||||||
self.copy_via(&|d| Value::Domain(d.clone()))
|
self.copy_via(&|d| Value::Domain(d.clone()))
|
||||||
}
|
}
|
||||||
|
|
||||||
fn copy_to_null_domain<M: NestedValue<super::NullDomain>>(&self) -> M {
|
fn to_io_value(&self) -> IOValue {
|
||||||
self.copy_via(&|d| d.as_preserves::<M, super::NullDomain>().unwrap().value_owned())
|
self.copy_via(&|d| d.as_preserves().unwrap().value().clone())
|
||||||
|
}
|
||||||
|
|
||||||
|
fn from_io_value(v: &IOValue) -> Self {
|
||||||
|
v.copy_via(&|_| unreachable!())
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -537,10 +534,6 @@ impl<N: NestedValue<D>, D: Domain> Value<N, D> {
|
||||||
Value::Domain(d) => f(d),
|
Value::Domain(d) => f(d),
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn copy_to_null_domain<M: NestedValue<super::NullDomain>>(&self) -> Value<M, super::NullDomain> {
|
|
||||||
self.copy_via(&|d| d.as_preserves::<M, super::NullDomain>().unwrap().value_owned())
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<N: NestedValue<D>, D: Domain> Index<usize> for Value<N, D> {
|
impl<N: NestedValue<D>, D: Domain> Index<usize> for Value<N, D> {
|
||||||
|
@ -568,28 +561,28 @@ impl<N: NestedValue<D>, D: Domain> Index<&N> for Value<N, D> {
|
||||||
//---------------------------------------------------------------------------
|
//---------------------------------------------------------------------------
|
||||||
// This part is a terrible hack
|
// This part is a terrible hack
|
||||||
|
|
||||||
impl<N: NestedValue<D>, D: Domain> serde::Serialize for Value<N, D> {
|
impl serde::Serialize for UnwrappedIOValue {
|
||||||
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 {
|
||||||
super::magic::output_value(serializer, self.copy_to_null_domain().wrap())
|
super::magic::output_value(serializer, self.clone().wrap())
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'de, N: NestedValue<Dom>, Dom: Domain> serde::Deserialize<'de> for Value<N, Dom> {
|
impl<'de> serde::Deserialize<'de> for UnwrappedIOValue {
|
||||||
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> {
|
||||||
Ok(super::magic::input_value_via::<'de, D, N, Dom>(deserializer)?.value_owned())
|
Ok(super::magic::input_value::<'de, D>(deserializer)?.value_owned())
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn serialize_nested_value<S, N, D: Domain>(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<D> + serde::Serialize
|
Result<S::Ok, S::Error> where S: serde::Serializer, N: NestedValue<D> + serde::Serialize
|
||||||
{
|
{
|
||||||
super::magic::output_value(serializer, v.copy_to_null_domain())
|
super::magic::output_value(serializer, v.to_io_value())
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn deserialize_nested_value<'de, D, N, Dom: Domain>(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<Dom> + serde::Deserialize<'de>
|
Result<N, D::Error> where D: serde::Deserializer<'de>, N: NestedValue<Dom> + serde::Deserialize<'de>
|
||||||
{
|
{
|
||||||
super::magic::input_value_via(deserializer)
|
Ok(N::from_io_value(&super::magic::input_value(deserializer)?))
|
||||||
}
|
}
|
||||||
|
|
||||||
//---------------------------------------------------------------------------
|
//---------------------------------------------------------------------------
|
||||||
|
@ -803,3 +796,74 @@ impl<'de, Dom: Domain> serde::Deserialize<'de> for ArcValue<Dom> {
|
||||||
deserialize_nested_value(deserializer)
|
deserialize_nested_value(deserializer)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
//---------------------------------------------------------------------------
|
||||||
|
|
||||||
|
#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
|
||||||
|
pub enum NullDomain {}
|
||||||
|
impl Domain for NullDomain {}
|
||||||
|
|
||||||
|
#[derive(Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
|
||||||
|
pub struct IOValue(Arc<AnnotatedValue<IOValue, NullDomain>>);
|
||||||
|
pub type UnwrappedIOValue = Value<IOValue, NullDomain>;
|
||||||
|
|
||||||
|
impl NestedValue<NullDomain> for IOValue {
|
||||||
|
type BoxType = Self;
|
||||||
|
|
||||||
|
fn wrap(v: Value<Self, NullDomain>) -> Self {
|
||||||
|
Self::wrap_ann(Vec::new(), v)
|
||||||
|
}
|
||||||
|
|
||||||
|
fn wrap_ann(anns: Vec<Self>, v: Value<Self, NullDomain>) -> Self {
|
||||||
|
IOValue(Arc::new(AnnotatedValue(anns, v)))
|
||||||
|
}
|
||||||
|
|
||||||
|
fn boxwrap(self) -> Self::BoxType {
|
||||||
|
self
|
||||||
|
}
|
||||||
|
|
||||||
|
fn boxunwrap(b: &Self::BoxType) -> &Self {
|
||||||
|
b
|
||||||
|
}
|
||||||
|
|
||||||
|
fn annotations(&self) -> &[Self] {
|
||||||
|
&(self.0).0
|
||||||
|
}
|
||||||
|
|
||||||
|
fn value(&self) -> &Value<Self, NullDomain> {
|
||||||
|
&(self.0).1
|
||||||
|
}
|
||||||
|
|
||||||
|
fn value_owned(self) -> Value<Self, NullDomain> {
|
||||||
|
match Arc::try_unwrap(self.0) {
|
||||||
|
Ok(AnnotatedValue(_anns, v)) => v,
|
||||||
|
Err(r) => r.1.clone(),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn to_io_value(&self) -> IOValue {
|
||||||
|
self.clone()
|
||||||
|
}
|
||||||
|
|
||||||
|
fn from_io_value(v: &IOValue) -> Self {
|
||||||
|
v.clone()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Debug for IOValue {
|
||||||
|
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||||
|
self.debug_fmt(f)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl serde::Serialize for IOValue {
|
||||||
|
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: serde::Serializer {
|
||||||
|
serialize_nested_value(self, serializer)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<'de> serde::Deserialize<'de> for IOValue {
|
||||||
|
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: serde::Deserializer<'de> {
|
||||||
|
deserialize_nested_value(deserializer)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
Loading…
Reference in New Issue