From 54d1e349b3efea1760c7d3adb26114907dd1bac3 Mon Sep 17 00:00:00 2001 From: Tony Garnock-Jones Date: Sat, 12 Oct 2019 21:50:24 +0100 Subject: [PATCH] AValue -> PlainValue, RcValue and ArcValue --- implementations/rust/src/lib.rs | 37 ++- implementations/rust/src/symbol.rs | 8 +- implementations/rust/src/value/de.rs | 5 +- implementations/rust/src/value/decoder.rs | 12 +- implementations/rust/src/value/encoder.rs | 6 +- implementations/rust/src/value/error.rs | 4 +- implementations/rust/src/value/mod.rs | 14 +- implementations/rust/src/value/ser.rs | 83 +++--- implementations/rust/src/value/value.rs | 334 +++++++++++++++------- 9 files changed, 320 insertions(+), 183 deletions(-) diff --git a/implementations/rust/src/lib.rs b/implementations/rust/src/lib.rs index 63c0f55..d15bd24 100644 --- a/implementations/rust/src/lib.rs +++ b/implementations/rust/src/lib.rs @@ -5,9 +5,9 @@ pub mod symbol; mod ieee754_section_5_10_total_order_tests { use std::cmp::Ordering::{Less, Equal, Greater}; - use crate::value::{Value, AValue}; - fn f(val: f32) -> Value { Value::from(val) } - fn d(val: f64) -> Value { Value::from(val) } + use crate::value::{Value, PlainValue}; + fn f(val: f32) -> Value { Value::from(val) } + fn d(val: f64) -> Value { Value::from(val) } // TODO: Test cases with a few different signalling and non-signalling NaNs @@ -97,10 +97,10 @@ mod ieee754_section_5_10_total_order_tests { #[cfg(test)] mod value_tests { - use crate::value::{Value, AValue}; + use crate::value::{Value, PlainValue}; use num::bigint::BigInt; - type VV = Value; + type VV = Value; #[test] fn boolean_mut() { let mut b = VV::Boolean(true); @@ -178,11 +178,11 @@ mod value_tests { #[cfg(test)] mod decoder_tests { use crate::value::Decoder; - use crate::value::{Value, AValue, NestedValue}; + use crate::value::{Value, PlainValue, NestedValue}; #[test] fn read_123() { let mut buf = &b"abc"[..]; - let mut d = Decoder::<_, AValue>::new(&mut buf, None); + let mut d = Decoder::<_, PlainValue>::new(&mut buf, None); assert_eq!(d.read().ok(), Some(97)); assert_eq!(d.read().ok(), Some(98)); assert_eq!(d.read().ok(), Some(99)); @@ -191,7 +191,7 @@ mod decoder_tests { #[test] fn skip_annotations_noskip() { let mut buf = &b"\x0521"[..]; - let mut d = Decoder::<_, AValue>::new(&mut buf, None); + let mut d = Decoder::<_, PlainValue>::new(&mut buf, None); let v = d.next().unwrap(); assert_eq!(v.annotations().len(), 1); assert_eq!(v.annotations()[0], Value::from(2).wrap()); @@ -200,7 +200,7 @@ mod decoder_tests { #[test] fn skip_annotations_skip() { let mut buf = &b"\x0521"[..]; - let mut d = Decoder::<_, AValue>::new(&mut buf, None); + let mut d = Decoder::<_, PlainValue>::new(&mut buf, None); d.set_read_annotations(false); let v = d.next().unwrap(); assert_eq!(v.annotations().len(), 0); @@ -212,26 +212,25 @@ mod decoder_tests { mod samples_tests { use crate::symbol::Symbol; use crate::value::{Codec, Decoder, codec}; - use crate::value::{Value, AValue}; + use crate::value::{Value, PlainValue, Map}; use crate::value::DecodePlaceholderMap; use crate::value::to_value; use crate::value::from_value; - use std::collections::BTreeMap; #[derive(Debug, serde::Serialize, serde::Deserialize)] - struct ExpectedPlaceholderMapping(DecodePlaceholderMap); + struct ExpectedPlaceholderMapping(DecodePlaceholderMap); #[derive(Debug, serde::Serialize, serde::Deserialize)] struct TestCases { decode_placeholders: ExpectedPlaceholderMapping, - tests: BTreeMap + tests: Map } #[derive(Debug, serde::Serialize, serde::Deserialize)] enum TestCase { - Test(#[serde(with = "serde_bytes")] Vec, AValue), - NondeterministicTest(#[serde(with = "serde_bytes")] Vec, AValue), - StreamingTest(#[serde(with = "serde_bytes")] Vec, AValue), + Test(#[serde(with = "serde_bytes")] Vec, PlainValue), + NondeterministicTest(#[serde(with = "serde_bytes")] Vec, PlainValue), + StreamingTest(#[serde(with = "serde_bytes")] Vec, PlainValue), ParseError(String), ParseShort(String), DecodeError(#[serde(with = "serde_bytes")] Vec), @@ -240,7 +239,7 @@ mod samples_tests { #[test] fn run() -> codec::Result<()> { let mut fh = std::fs::File::open("../../tests/samples.bin").unwrap(); - let mut d = Decoder::<_, AValue>::new(&mut fh, None); + let mut d = Decoder::<_, PlainValue>::new(&mut fh, None); let tests: TestCases = from_value(&d.next().unwrap()).unwrap(); // println!("{:#?}", tests); @@ -296,7 +295,7 @@ mod samples_tests { #[serde(with = "serde_bytes")] &'a [u8], #[serde(with = "serde_bytes")] Vec, i16, - AValue); + PlainValue); let v = SimpleValue("hello".to_string(), "sym1".to_string(), Symbol("sym2".to_string()), @@ -306,7 +305,7 @@ mod samples_tests { 12345, Value::from("hi").wrap()); println!("{:#?}", v); - let w = to_value(&v).unwrap(); + let w: PlainValue = to_value(&v).unwrap(); println!("{:#?}", w); let x = from_value(&w).unwrap(); println!("{:#?}", &x); diff --git a/implementations/rust/src/symbol.rs b/implementations/rust/src/symbol.rs index 5b98462..67f1603 100644 --- a/implementations/rust/src/symbol.rs +++ b/implementations/rust/src/symbol.rs @@ -1,18 +1,18 @@ -use crate::value::{Value, AValue}; +use crate::value::{Value, PlainValue, NestedValue}; #[derive(Debug, PartialEq, Eq, PartialOrd, Ord)] pub struct Symbol(pub String); impl serde::Serialize for Symbol { fn serialize(&self, serializer: S) -> Result where S: serde::Serializer { - Value::::symbol(&self.0).serialize(serializer) + Value::::symbol(&self.0).wrap().serialize(serializer) } } impl<'de> serde::Deserialize<'de> for Symbol { fn deserialize(deserializer: D) -> Result where D: serde::Deserializer<'de> { - let v = Value::::deserialize(deserializer)?; - let s = v.as_symbol().ok_or(serde::de::Error::custom("Expected symbol"))?; + let v = PlainValue::deserialize(deserializer)?; + let s = v.value().as_symbol().ok_or(serde::de::Error::custom("Expected symbol"))?; Ok(Symbol(s.clone())) } } diff --git a/implementations/rust/src/value/de.rs b/implementations/rust/src/value/de.rs index 1e582a8..a3a0775 100644 --- a/implementations/rust/src/value/de.rs +++ b/implementations/rust/src/value/de.rs @@ -1,4 +1,4 @@ -use crate::value::{Value, NestedValue}; +use crate::value::{Value, NestedValue, Map}; use crate::value::value::{Float, Double}; use crate::value::error::{Error, Result, ExpectedKind}; use num::traits::cast::ToPrimitive; @@ -6,7 +6,6 @@ use serde::Deserialize; use serde::de::{Visitor, SeqAccess, MapAccess, EnumAccess, VariantAccess, DeserializeSeed}; use std::convert::TryFrom; use std::iter::Iterator; -use std::collections::BTreeMap as Map; pub struct Deserializer<'de, N: NestedValue> { input: &'de N, @@ -342,7 +341,7 @@ impl<'a, 'de, N: NestedValue> EnumAccess<'de> for &'a mut Deserializer<'de, N> { { let (lp, _) = self.check(|v| v.as_record(), ExpectedKind::Record)?; let v = self.input; - self.input = lp; + self.input = N::boxunwrap(lp); let variant = seed.deserialize(&mut *self)?; self.input = v; Ok((variant, self)) diff --git a/implementations/rust/src/value/decoder.rs b/implementations/rust/src/value/decoder.rs index 31744ba..0592cbb 100644 --- a/implementations/rust/src/value/decoder.rs +++ b/implementations/rust/src/value/decoder.rs @@ -1,9 +1,7 @@ use std::io::{Read, ErrorKind}; -use std::collections::BTreeSet as Set; -use std::collections::BTreeMap as Map; use std::convert::TryInto; use std::convert::TryFrom; -use crate::value::{Value, NestedValue}; +use crate::value::{Value, NestedValue, Set, Map}; use num::bigint::BigInt; use crate::value::constants::{Op, InvalidOp, AtomMinor, CompoundMinor}; @@ -50,7 +48,7 @@ impl Error { pub fn is_eof(&self) -> bool { if let Error::Eof = *self { true } else { false } } } -pub type DecodePlaceholderMap = std::collections::BTreeMap>; +pub type DecodePlaceholderMap = Map>; pub struct Decoder<'a, 'b, R: Read, N: NestedValue> { read: &'a mut R, @@ -255,9 +253,9 @@ impl<'a, 'b, R: Read, N: NestedValue> Decoder<'a, 'b, R, N> { self.skip()?; annotations.push(self.next()?); } - let mut v = self.next()?; - v.annotations_mut().extend(annotations); - Ok(v) + let v = self.next()?; + assert!(v.annotations().len() == 0); + Ok(N::wrap_ann(annotations, v.value_owned())) } else { self.next()?; self.next() diff --git a/implementations/rust/src/value/encoder.rs b/implementations/rust/src/value/encoder.rs index 1888007..f3e8ff0 100644 --- a/implementations/rust/src/value/encoder.rs +++ b/implementations/rust/src/value/encoder.rs @@ -1,5 +1,5 @@ use std::io::Write; -use crate::value::value::{Value, NestedValue, Float, Double}; +use crate::value::value::{Value, NestedValue, Float, Double, Map}; use num::bigint::BigInt; use num::cast::ToPrimitive; use crate::value::constants::{Op, AtomMinor, CompoundMinor}; @@ -7,7 +7,7 @@ use crate::value::constants::{Op, AtomMinor, CompoundMinor}; pub type Error = std::io::Error; pub type Result = std::result::Result<(), Error>; -pub type EncodePlaceholderMap = std::collections::BTreeMap, usize>; +pub type EncodePlaceholderMap = Map, usize>; pub struct Encoder<'a, 'b, W: Write, N: NestedValue> { write: &'a mut W, @@ -98,7 +98,7 @@ impl<'a, 'b, W: Write, N: NestedValue> Encoder<'a, 'b, W, N> { Value::Symbol(ref s) => self.write_atom(AtomMinor::Symbol, s.as_bytes()), Value::Record((ref l, ref fs)) => { self.write_header(Op::Compound(CompoundMinor::Record), fs.len() + 1)?; - self.write(l)?; + self.write(N::boxunwrap(l))?; Ok(for f in fs { self.write(f)?; }) } Value::Sequence(ref vs) => { diff --git a/implementations/rust/src/value/error.rs b/implementations/rust/src/value/error.rs index 42df502..a88bce3 100644 --- a/implementations/rust/src/value/error.rs +++ b/implementations/rust/src/value/error.rs @@ -1,5 +1,5 @@ use num::bigint::BigInt; -use crate::value::AValue; +use crate::value::PlainValue; #[derive(Debug)] pub enum Error { @@ -7,7 +7,7 @@ pub enum Error { InvalidUnicodeScalar(u32), NumberTooLarge(BigInt), CannotDeserializeAny, - Expected(ExpectedKind, AValue), + Expected(ExpectedKind, PlainValue), InternalMagicError, } diff --git a/implementations/rust/src/value/mod.rs b/implementations/rust/src/value/mod.rs index 3b067d4..e04548b 100644 --- a/implementations/rust/src/value/mod.rs +++ b/implementations/rust/src/value/mod.rs @@ -18,14 +18,16 @@ pub use ser::Serializer; pub use ser::to_value; pub use value::NestedValue; pub use value::Value; -pub use value::AValue; +pub use value::AnnotatedValue; +pub use value::PlainValue; +pub use value::RcValue; +pub use value::ArcValue; +pub use value::Set; +pub use value::Map; -pub type Set = std::collections::BTreeSet; -pub type Dictionary = std::collections::BTreeMap; - -pub fn invert_map(m: &std::collections::BTreeMap) -> std::collections::BTreeMap +pub fn invert_map(m: &Map) -> Map where A: Clone, B: Clone + Ord { use std::iter::FromIterator; - std::collections::BTreeMap::from_iter(m.iter().map(|(a, b)| (b.clone(), a.clone()))) + Map::from_iter(m.iter().map(|(a, b)| (b.clone(), a.clone()))) } diff --git a/implementations/rust/src/value/ser.rs b/implementations/rust/src/value/ser.rs index 23f395d..c9853d0 100644 --- a/implementations/rust/src/value/ser.rs +++ b/implementations/rust/src/value/ser.rs @@ -1,33 +1,36 @@ -use crate::value::{Value, AValue, NestedValue, Dictionary}; +use crate::value::{Value, NestedValue, Map}; use serde::Serialize; use crate::value::error::{Error, Result}; +use std::marker::PhantomData; -pub struct Serializer; - -pub struct SerializeDictionary { - next_key: Option, - items: Dictionary, +pub struct Serializer { + phantom: PhantomData } -pub struct SerializeRecord { +pub struct SerializeDictionary { + next_key: Option, + items: Map, +} + +pub struct SerializeRecord { name: &'static str, - vec: Vec, + vec: Vec, } -pub struct SerializeSequence { - vec: Vec, +pub struct SerializeSequence { + vec: Vec, } -impl serde::Serializer for Serializer { - type Ok = AValue; +impl serde::Serializer for Serializer { + type Ok = N; type Error = Error; - type SerializeSeq = SerializeSequence; - type SerializeTuple = SerializeRecord; - type SerializeTupleStruct = SerializeRecord; - type SerializeTupleVariant = SerializeRecord; - type SerializeMap = SerializeDictionary; - type SerializeStruct = SerializeRecord; - type SerializeStructVariant = SerializeRecord; + type SerializeSeq = SerializeSequence; + type SerializeTuple = SerializeRecord; + type SerializeTupleStruct = SerializeRecord; + type SerializeTupleVariant = SerializeRecord; + type SerializeMap = SerializeDictionary; + type SerializeStruct = SerializeRecord; + type SerializeStructVariant = SerializeRecord; fn serialize_bool(self, v: bool) -> Result { Ok(Value::from(v).wrap()) @@ -114,7 +117,7 @@ impl serde::Serializer for Serializer { Result where T: Serialize { if name == crate::value::value::MAGIC { - let v = to_value(value)?; + let v: crate::value::PlainValue = to_value(value)?; let mut buf: &[u8] = v.value().as_bytestring().ok_or(Error::InternalMagicError)?; crate::value::Decoder::new(&mut buf, None).next().or(Err(Error::InternalMagicError)) } else { @@ -159,7 +162,7 @@ impl serde::Serializer for Serializer { } fn serialize_map(self, _count: Option) -> Result { - Ok(SerializeDictionary{ next_key: None, items: Dictionary::new() }) + Ok(SerializeDictionary{ next_key: None, items: Map::new() }) } fn serialize_struct(self, name: &'static str, count: usize) -> Result { @@ -177,8 +180,8 @@ impl serde::Serializer for Serializer { } } -impl serde::ser::SerializeMap for SerializeDictionary { - type Ok = AValue; +impl serde::ser::SerializeMap for SerializeDictionary { + type Ok = N; type Error = Error; fn serialize_key(&mut self, key: &T) -> Result<()> where T: Serialize { @@ -197,19 +200,19 @@ impl serde::ser::SerializeMap for SerializeDictionary { } } -impl SerializeRecord { - fn push(&mut self, value: AValue) -> Result<()> { +impl SerializeRecord { + fn push(&mut self, value: N) -> Result<()> { self.vec.push(value); Ok(()) } - fn finish(self) -> Result { + fn finish(self) -> Result { Ok(Value::simple_record(self.name, self.vec).wrap()) } } -impl serde::ser::SerializeStruct for SerializeRecord { - type Ok = AValue; +impl serde::ser::SerializeStruct for SerializeRecord { + type Ok = N; type Error = Error; fn serialize_field(&mut self, _name: &'static str, value: &T) -> Result<()> @@ -223,8 +226,8 @@ impl serde::ser::SerializeStruct for SerializeRecord { } } -impl serde::ser::SerializeStructVariant for SerializeRecord { - type Ok = AValue; +impl serde::ser::SerializeStructVariant for SerializeRecord { + type Ok = N; type Error = Error; fn serialize_field(&mut self, _name: &'static str, value: &T) -> Result<()> @@ -238,8 +241,8 @@ impl serde::ser::SerializeStructVariant for SerializeRecord { } } -impl serde::ser::SerializeTuple for SerializeRecord { - type Ok = AValue; +impl serde::ser::SerializeTuple for SerializeRecord { + type Ok = N; type Error = Error; fn serialize_element(&mut self, value: &T) -> Result<()> where T: Serialize { @@ -251,8 +254,8 @@ impl serde::ser::SerializeTuple for SerializeRecord { } } -impl serde::ser::SerializeTupleStruct for SerializeRecord { - type Ok = AValue; +impl serde::ser::SerializeTupleStruct for SerializeRecord { + type Ok = N; type Error = Error; fn serialize_field(&mut self, value: &T) -> Result<()> where T: Serialize { @@ -264,8 +267,8 @@ impl serde::ser::SerializeTupleStruct for SerializeRecord { } } -impl serde::ser::SerializeTupleVariant for SerializeRecord { - type Ok = AValue; +impl serde::ser::SerializeTupleVariant for SerializeRecord { + type Ok = N; type Error = Error; fn serialize_field(&mut self, value: &T) -> Result<()> where T: Serialize { @@ -277,8 +280,8 @@ impl serde::ser::SerializeTupleVariant for SerializeRecord { } } -impl serde::ser::SerializeSeq for SerializeSequence { - type Ok = AValue; +impl serde::ser::SerializeSeq for SerializeSequence { + type Ok = N; type Error = Error; fn serialize_element(&mut self, value: &T) -> Result<()> where T: Serialize { @@ -291,6 +294,6 @@ impl serde::ser::SerializeSeq for SerializeSequence { } } -pub fn to_value(value: T) -> Result where T: Serialize { - value.serialize(Serializer) +pub fn to_value(value: T) -> Result where T: Serialize, N: NestedValue { + value.serialize(Serializer{ phantom: PhantomData }) } diff --git a/implementations/rust/src/value/value.rs b/implementations/rust/src/value/value.rs index b3d4789..11dd4a4 100644 --- a/implementations/rust/src/value/value.rs +++ b/implementations/rust/src/value/value.rs @@ -4,15 +4,15 @@ use std::fmt::Debug; use num::bigint::BigInt; use std::vec::Vec; use std::string::String; -use std::collections::BTreeSet as Set; -use std::collections::BTreeMap as Map; -use std::ops::Deref; use std::ops::Index; use std::ops::IndexMut; use num::traits::cast::ToPrimitive; +pub use std::collections::BTreeSet as Set; +pub use std::collections::BTreeMap as Map; + pub trait NestedValue: Sized + Debug + Clone + Eq + Hash + Ord { - type BoxType: Sized + Debug + Clone + Eq + Hash + Ord + Deref; + type BoxType: Sized + Debug + Clone + Eq + Hash + Ord; fn wrap(v: Value) -> Self; fn wrap_ann(anns: Vec, v: Value) -> Self; @@ -21,10 +21,7 @@ pub trait NestedValue: Sized + Debug + Clone + Eq + Hash + Ord { fn boxunwrap(b: &Self::BoxType) -> &Self; fn annotations(&self) -> &Vec; - fn annotations_mut(&mut self) -> &mut Vec; - fn value(&self) -> &Value; - fn value_mut(&mut self) -> &mut Value; fn value_owned(self) -> Value; fn debug_fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { @@ -56,51 +53,6 @@ pub enum Value where N: NestedValue { Dictionary(Map), } -/// An possibly-annotated Value, with annotations (themselves -/// possibly-annotated) in order of appearance. -#[derive(Clone)] -pub struct AValue(pub Vec, pub Value); - -impl NestedValue for AValue { - type BoxType = Box; - - fn wrap(v: Value) -> Self { - Self::wrap_ann(Vec::new(), v) - } - - fn wrap_ann(anns: Vec, v: Value) -> Self { - AValue(anns, v) - } - - fn boxwrap(self) -> Self::BoxType { - Box::new(self) - } - - fn boxunwrap(b: &Self::BoxType) -> &Self { - &**b - } - - fn annotations(&self) -> &Vec { - &self.0 - } - - fn annotations_mut(&mut self) -> &mut Vec { - &mut self.0 - } - - fn value(&self) -> &Value { - &self.1 - } - - fn value_mut(&mut self) -> &mut Value { - &mut self.1 - } - - fn value_owned(self) -> Value { - self.1 - } -} - /// Single-precision IEEE 754 Value #[derive(Clone, Debug)] pub struct Float(pub f32); @@ -196,38 +148,6 @@ impl PartialOrd for Double { impl Eq for Double {} -impl PartialEq for AValue { - fn eq(&self, other: &Self) -> bool { - self.value().eq(other.value()) - } -} - -impl Eq for AValue {} - -impl Hash for AValue { - fn hash(&self, state: &mut H) { - self.1.hash(state); - } -} - -impl PartialOrd for AValue { - fn partial_cmp(&self, other: &Self) -> Option { - Some(self.cmp(other)) - } -} - -impl Ord for AValue { - fn cmp(&self, other: &Self) -> Ordering { - self.value().cmp(&other.value()) - } -} - -impl Debug for AValue { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - self.debug_fmt(f) - } -} - impl From for Value { fn from(v: bool) -> Self { Value::Boolean(v) } } impl From for Value { fn from(v: f32) -> Self { Value::Float(Float::from(v)) } } @@ -492,7 +412,7 @@ impl Value { pub fn as_simple_record(&self, label: &str, arity: Option) -> Option<&Vec> { self.as_record().and_then(|(lp,fs)| { - match *lp.value() { + match N::boxunwrap(lp).value() { Value::Symbol(ref s) if s == label => match arity { Some(expected) if fs.len() == expected => Some(fs), @@ -643,15 +563,6 @@ impl serde::Serialize for Value { } } -impl serde::Serialize for AValue { - fn serialize(&self, serializer: S) -> Result where S: serde::Serializer { - let mut buf: Vec = Vec::new(); - crate::value::Encoder::new(&mut buf, None).write(self) - .or(Err(serde::ser::Error::custom("Internal error")))?; - ValueWrapper(buf).serialize(serializer) - } -} - impl<'de, N: NestedValue> serde::Deserialize<'de> for Value { fn deserialize(deserializer: D) -> Result where D: serde::Deserializer<'de> { let ValueWrapper(buf) = ValueWrapper::deserialize(deserializer)?; @@ -661,10 +572,235 @@ impl<'de, N: NestedValue> serde::Deserialize<'de> for Value { } } -impl<'de> serde::Deserialize<'de> for AValue { - fn deserialize(deserializer: D) -> Result where D: serde::Deserializer<'de> { - let ValueWrapper(buf) = ValueWrapper::deserialize(deserializer)?; - crate::value::Decoder::new(&mut &buf[..], None).next() - .or(Err(serde::de::Error::custom("Internal error"))) +pub fn serialize_nested_value<'de, S, N>(v: &N, serializer: S) -> + Result where S: serde::Serializer, N: NestedValue +{ + use serde::Serialize; + let mut buf: Vec = Vec::new(); + crate::value::Encoder::new(&mut buf, None).write(v) + .or(Err(serde::ser::Error::custom("Internal error")))?; + ValueWrapper(buf).serialize(serializer) +} + +pub fn deserialize_nested_value<'de, D, N>(deserializer: D) -> + Result where D: serde::Deserializer<'de>, N: NestedValue +{ + use serde::Deserialize; + let ValueWrapper(buf) = ValueWrapper::deserialize(deserializer)?; + crate::value::Decoder::new(&mut &buf[..], None).next() + .or(Err(serde::de::Error::custom("Internal error"))) +} + +//--------------------------------------------------------------------------- + +/// An possibly-annotated Value, with annotations (themselves +/// possibly-annotated) in order of appearance. +#[derive(Clone)] +pub struct AnnotatedValue(pub Vec, pub Value); + +impl PartialEq for AnnotatedValue { + fn eq(&self, other: &Self) -> bool { + self.1.eq(&other.1) + } +} + +impl Eq for AnnotatedValue {} + +impl Hash for AnnotatedValue { + fn hash(&self, state: &mut H) { + self.1.hash(state); + } +} + +impl PartialOrd for AnnotatedValue { + fn partial_cmp(&self, other: &Self) -> Option { + Some(self.cmp(other)) + } +} + +impl Ord for AnnotatedValue { + fn cmp(&self, other: &Self) -> Ordering { + self.1.cmp(&other.1) + } +} + +//--------------------------------------------------------------------------- + +#[derive(Clone, PartialEq, Eq, Hash, PartialOrd, Ord)] +pub struct PlainValue(AnnotatedValue); + +impl NestedValue for PlainValue { + type BoxType = Box; + + fn wrap(v: Value) -> Self { + Self::wrap_ann(Vec::new(), v) + } + + fn wrap_ann(anns: Vec, v: Value) -> Self { + PlainValue(AnnotatedValue(anns, v)) + } + + fn boxwrap(self) -> Self::BoxType { + Box::new(self) + } + + fn boxunwrap(b: &Self::BoxType) -> &Self { + &**b + } + + fn annotations(&self) -> &Vec { + &(self.0).0 + } + + fn value(&self) -> &Value { + &(self.0).1 + } + + fn value_owned(self) -> Value { + (self.0).1 + } +} + +impl Debug for PlainValue { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + self.debug_fmt(f) + } +} + +impl serde::Serialize for PlainValue { + fn serialize(&self, serializer: S) -> Result where S: serde::Serializer { + serialize_nested_value(self, serializer) + } +} + +impl<'de> serde::Deserialize<'de> for PlainValue { + fn deserialize(deserializer: D) -> Result where D: serde::Deserializer<'de> { + deserialize_nested_value(deserializer) + } +} + +//--------------------------------------------------------------------------- + +use std::rc::Rc; + +#[derive(Clone, PartialEq, Eq, PartialOrd, Ord)] +pub struct RcValue(Rc>); + +impl NestedValue for RcValue { + type BoxType = Self; + + fn wrap(v: Value) -> Self { + Self::wrap_ann(Vec::new(), v) + } + + fn wrap_ann(anns: Vec, v: Value) -> Self { + RcValue(Rc::new(AnnotatedValue(anns, v))) + } + + fn boxwrap(self) -> Self::BoxType { + self + } + + fn boxunwrap(b: &Self::BoxType) -> &Self { + b + } + + fn annotations(&self) -> &Vec { + &(self.0).0 + } + + fn value(&self) -> &Value { + &(self.0).1 + } + + fn value_owned(self) -> Value { + Rc::try_unwrap(self.0).unwrap_or_else(|_| panic!("value_owned on RcValue with refcount greater than one")).1 + } +} + +impl Hash for RcValue { + fn hash(&self, state: &mut H) { + (self.0).1.hash(state) + } +} + +impl Debug for RcValue { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + self.debug_fmt(f) + } +} + +impl serde::Serialize for RcValue { + fn serialize(&self, serializer: S) -> Result where S: serde::Serializer { + serialize_nested_value(self, serializer) + } +} + +impl<'de> serde::Deserialize<'de> for RcValue { + fn deserialize(deserializer: D) -> Result where D: serde::Deserializer<'de> { + deserialize_nested_value(deserializer) + } +} + +//--------------------------------------------------------------------------- + +use std::sync::Arc; + +#[derive(Clone, PartialEq, Eq, PartialOrd, Ord)] +pub struct ArcValue(Arc>); + +impl NestedValue for ArcValue { + type BoxType = Self; + + fn wrap(v: Value) -> Self { + Self::wrap_ann(Vec::new(), v) + } + + fn wrap_ann(anns: Vec, v: Value) -> Self { + ArcValue(Arc::new(AnnotatedValue(anns, v))) + } + + fn boxwrap(self) -> Self::BoxType { + self + } + + fn boxunwrap(b: &Self::BoxType) -> &Self { + b + } + + fn annotations(&self) -> &Vec { + &(self.0).0 + } + + fn value(&self) -> &Value { + &(self.0).1 + } + + fn value_owned(self) -> Value { + Arc::try_unwrap(self.0).unwrap_or_else(|_| panic!("value_owned on ArcValue with refcount greater than one")).1 + } +} + +impl Hash for ArcValue { + fn hash(&self, state: &mut H) { + (self.0).1.hash(state) + } +} + +impl Debug for ArcValue { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + self.debug_fmt(f) + } +} + +impl serde::Serialize for ArcValue { + fn serialize(&self, serializer: S) -> Result where S: serde::Serializer { + serialize_nested_value(self, serializer) + } +} + +impl<'de> serde::Deserialize<'de> for ArcValue { + fn deserialize(deserializer: D) -> Result where D: serde::Deserializer<'de> { + deserialize_nested_value(deserializer) } }