|
|
|
@ -21,15 +21,15 @@ use super::IOResult;
|
|
|
|
|
use super::signed_integer::SignedInteger;
|
|
|
|
|
use crate::error::{Error, ExpectedKind, Received};
|
|
|
|
|
|
|
|
|
|
pub trait PreDomain: Sized + Debug + Eq + Hash + Ord {
|
|
|
|
|
pub trait Domain: Sized + Debug + Eq + Hash + Ord {
|
|
|
|
|
fn from_preserves(v: IOValue) -> IOResult<Self>;
|
|
|
|
|
fn as_preserves(&self) -> IOValue;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
pub trait Domain: PreDomain + Clone {}
|
|
|
|
|
pub trait Embeddable: Domain + Clone {}
|
|
|
|
|
impl<T> Embeddable for T where T: Domain + Clone {}
|
|
|
|
|
|
|
|
|
|
impl<D: PreDomain> Domain for Arc<D> {}
|
|
|
|
|
impl<D: PreDomain> PreDomain for Arc<D> {
|
|
|
|
|
impl<D: Domain> Domain for Arc<D> {
|
|
|
|
|
fn from_preserves(v: IOValue) -> IOResult<Self> {
|
|
|
|
|
Ok(Arc::new(D::from_preserves(v)?))
|
|
|
|
|
}
|
|
|
|
@ -39,7 +39,7 @@ impl<D: PreDomain> PreDomain for Arc<D> {
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
pub trait NestedValue<D: Domain>: Sized + Debug + Clone + Eq + Hash + Ord {
|
|
|
|
|
pub trait NestedValue<D: Embeddable>: Sized + Debug + Clone + Eq + Hash + Ord {
|
|
|
|
|
fn wrap(anns: Annotations<Self, D>, v: Value<Self, D>) -> Self;
|
|
|
|
|
|
|
|
|
|
fn annotations(&self) -> &Annotations<Self, D>;
|
|
|
|
@ -54,7 +54,7 @@ pub trait NestedValue<D: Domain>: Sized + Debug + Clone + Eq + Hash + Ord {
|
|
|
|
|
self.value().fmt(f)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
fn copy_via<M: NestedValue<E>, E: Domain, F>(&self, f: &F) -> IOResult<M>
|
|
|
|
|
fn copy_via<M: NestedValue<E>, E: Embeddable, F>(&self, f: &F) -> IOResult<M>
|
|
|
|
|
where
|
|
|
|
|
F: Fn(&D) -> IOResult<Value<M, E>>
|
|
|
|
|
{
|
|
|
|
@ -66,13 +66,13 @@ pub trait NestedValue<D: Domain>: Sized + Debug + Clone + Eq + Hash + Ord {
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
fn from_io_value(v: &IOValue) -> IOResult<Self> {
|
|
|
|
|
v.copy_via(&|d| Ok(Value::Domain(D::from_preserves(d.clone())?)))
|
|
|
|
|
v.copy_via(&|d| Ok(Value::Embedded(D::from_preserves(d.clone())?)))
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// The `Value`s from the specification.
|
|
|
|
|
#[derive(Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
|
|
|
|
|
pub enum Value<N, D> where N: NestedValue<D>, D: Domain {
|
|
|
|
|
pub enum Value<N, D> where N: NestedValue<D>, D: Embeddable {
|
|
|
|
|
Boolean(bool),
|
|
|
|
|
Float(Float),
|
|
|
|
|
Double(Double),
|
|
|
|
@ -84,7 +84,7 @@ pub enum Value<N, D> where N: NestedValue<D>, D: Domain {
|
|
|
|
|
Sequence(Vec<N>),
|
|
|
|
|
Set(Set<N>),
|
|
|
|
|
Dictionary(Map<N, N>),
|
|
|
|
|
Domain(D),
|
|
|
|
|
Embedded(D),
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// Single-precision IEEE 754 Value
|
|
|
|
@ -128,7 +128,7 @@ impl<N> Record<N> {
|
|
|
|
|
&mut self.0
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
pub fn finish<D: Domain>(self) -> Value<N, D> where N: NestedValue<D> {
|
|
|
|
|
pub fn finish<D: Embeddable>(self) -> Value<N, D> where N: NestedValue<D> {
|
|
|
|
|
Value::Record(self)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
@ -217,38 +217,38 @@ impl PartialOrd for Double {
|
|
|
|
|
|
|
|
|
|
impl Eq for Double {}
|
|
|
|
|
|
|
|
|
|
impl<N: NestedValue<D>, D: Domain> From<bool> for Value<N, D> { fn from(v: bool) -> Self { Value::Boolean(v) } }
|
|
|
|
|
impl<N: NestedValue<D>, D: Embeddable> From<bool> for Value<N, D> { fn from(v: bool) -> Self { Value::Boolean(v) } }
|
|
|
|
|
|
|
|
|
|
impl<N: NestedValue<D>, D: Domain> From<f32> for Value<N, D> { fn from(v: f32) -> Self { Value::Float(Float::from(v)) } }
|
|
|
|
|
impl<N: NestedValue<D>, D: Domain> From<&Float> for Value<N, D> { fn from(v: &Float) -> Self { Value::Float(v.clone()) } }
|
|
|
|
|
impl<N: NestedValue<D>, D: Domain> From<f64> for Value<N, D> { fn from(v: f64) -> Self { Value::Double(Double::from(v)) } }
|
|
|
|
|
impl<N: NestedValue<D>, D: Domain> From<&Double> for Value<N, D> { fn from(v: &Double) -> Self { Value::Double(v.clone()) } }
|
|
|
|
|
impl<N: NestedValue<D>, D: Embeddable> From<f32> for Value<N, D> { fn from(v: f32) -> Self { Value::Float(Float::from(v)) } }
|
|
|
|
|
impl<N: NestedValue<D>, D: Embeddable> From<&Float> for Value<N, D> { fn from(v: &Float) -> Self { Value::Float(v.clone()) } }
|
|
|
|
|
impl<N: NestedValue<D>, D: Embeddable> From<f64> for Value<N, D> { fn from(v: f64) -> Self { Value::Double(Double::from(v)) } }
|
|
|
|
|
impl<N: NestedValue<D>, D: Embeddable> From<&Double> for Value<N, D> { fn from(v: &Double) -> Self { Value::Double(v.clone()) } }
|
|
|
|
|
|
|
|
|
|
impl<N: NestedValue<D>, D: Domain> From<u8> for Value<N, D> { fn from(v: u8) -> Self { Value::from(i128::from(v)) } }
|
|
|
|
|
impl<N: NestedValue<D>, D: Domain> From<i8> for Value<N, D> { fn from(v: i8) -> Self { Value::from(i128::from(v)) } }
|
|
|
|
|
impl<N: NestedValue<D>, D: Domain> From<u16> for Value<N, D> { fn from(v: u16) -> Self { Value::from(i128::from(v)) } }
|
|
|
|
|
impl<N: NestedValue<D>, D: Domain> From<i16> for Value<N, D> { fn from(v: i16) -> Self { Value::from(i128::from(v)) } }
|
|
|
|
|
impl<N: NestedValue<D>, D: Domain> From<u32> for Value<N, D> { fn from(v: u32) -> Self { Value::from(i128::from(v)) } }
|
|
|
|
|
impl<N: NestedValue<D>, D: Domain> From<i32> for Value<N, D> { fn from(v: i32) -> Self { Value::from(i128::from(v)) } }
|
|
|
|
|
impl<N: NestedValue<D>, D: Domain> From<u64> for Value<N, D> { fn from(v: u64) -> Self { Value::from(i128::from(v)) } }
|
|
|
|
|
impl<N: NestedValue<D>, D: Domain> From<i64> for Value<N, D> { fn from(v: i64) -> Self { Value::from(i128::from(v)) } }
|
|
|
|
|
impl<N: NestedValue<D>, D: Domain> From<u128> for Value<N, D> { fn from(v: u128) -> Self { Value::SignedInteger(SignedInteger::from(v)) } }
|
|
|
|
|
impl<N: NestedValue<D>, D: Domain> From<i128> for Value<N, D> { fn from(v: i128) -> Self { Value::SignedInteger(SignedInteger::from(v)) } }
|
|
|
|
|
impl<N: NestedValue<D>, D: Domain> From<&BigInt> for Value<N, D> { fn from(v: &BigInt) -> Self { Value::SignedInteger(SignedInteger::from(Cow::Borrowed(v))) } }
|
|
|
|
|
impl<N: NestedValue<D>, D: Domain> From<&SignedInteger> for Value<N, D> { fn from(v: &SignedInteger) -> Self { Value::SignedInteger(v.clone()) } }
|
|
|
|
|
impl<N: NestedValue<D>, D: Embeddable> From<u8> for Value<N, D> { fn from(v: u8) -> Self { Value::from(i128::from(v)) } }
|
|
|
|
|
impl<N: NestedValue<D>, D: Embeddable> From<i8> for Value<N, D> { fn from(v: i8) -> Self { Value::from(i128::from(v)) } }
|
|
|
|
|
impl<N: NestedValue<D>, D: Embeddable> From<u16> for Value<N, D> { fn from(v: u16) -> Self { Value::from(i128::from(v)) } }
|
|
|
|
|
impl<N: NestedValue<D>, D: Embeddable> From<i16> for Value<N, D> { fn from(v: i16) -> Self { Value::from(i128::from(v)) } }
|
|
|
|
|
impl<N: NestedValue<D>, D: Embeddable> From<u32> for Value<N, D> { fn from(v: u32) -> Self { Value::from(i128::from(v)) } }
|
|
|
|
|
impl<N: NestedValue<D>, D: Embeddable> From<i32> for Value<N, D> { fn from(v: i32) -> Self { Value::from(i128::from(v)) } }
|
|
|
|
|
impl<N: NestedValue<D>, D: Embeddable> From<u64> for Value<N, D> { fn from(v: u64) -> Self { Value::from(i128::from(v)) } }
|
|
|
|
|
impl<N: NestedValue<D>, D: Embeddable> From<i64> for Value<N, D> { fn from(v: i64) -> Self { Value::from(i128::from(v)) } }
|
|
|
|
|
impl<N: NestedValue<D>, D: Embeddable> From<u128> for Value<N, D> { fn from(v: u128) -> Self { Value::SignedInteger(SignedInteger::from(v)) } }
|
|
|
|
|
impl<N: NestedValue<D>, D: Embeddable> From<i128> for Value<N, D> { fn from(v: i128) -> Self { Value::SignedInteger(SignedInteger::from(v)) } }
|
|
|
|
|
impl<N: NestedValue<D>, D: Embeddable> From<&BigInt> for Value<N, D> { fn from(v: &BigInt) -> Self { Value::SignedInteger(SignedInteger::from(Cow::Borrowed(v))) } }
|
|
|
|
|
impl<N: NestedValue<D>, D: Embeddable> From<&SignedInteger> for Value<N, D> { fn from(v: &SignedInteger) -> Self { Value::SignedInteger(v.clone()) } }
|
|
|
|
|
|
|
|
|
|
impl<N: NestedValue<D>, D: Domain> From<&str> for Value<N, D> { fn from(v: &str) -> Self { Value::String(String::from(v)) } }
|
|
|
|
|
impl<N: NestedValue<D>, D: Domain> From<String> for Value<N, D> { fn from(v: String) -> Self { Value::String(v) } }
|
|
|
|
|
impl<N: NestedValue<D>, D: Domain> From<&String> for Value<N, D> { fn from(v: &String) -> Self { Value::String(v.to_owned()) } }
|
|
|
|
|
impl<N: NestedValue<D>, D: Embeddable> From<&str> for Value<N, D> { fn from(v: &str) -> Self { Value::String(String::from(v)) } }
|
|
|
|
|
impl<N: NestedValue<D>, D: Embeddable> From<String> for Value<N, D> { fn from(v: String) -> Self { Value::String(v) } }
|
|
|
|
|
impl<N: NestedValue<D>, D: Embeddable> From<&String> for Value<N, D> { fn from(v: &String) -> Self { Value::String(v.to_owned()) } }
|
|
|
|
|
|
|
|
|
|
impl<N: NestedValue<D>, D: Domain> From<&[u8]> for Value<N, D> { fn from(v: &[u8]) -> Self { Value::ByteString(Vec::from(v)) } }
|
|
|
|
|
// impl<N: NestedValue<D>, D: Domain> From<Vec<u8>> for Value<N, D> { fn from(v: Vec<u8>) -> Self { Value::ByteString(v) } }
|
|
|
|
|
impl<N: NestedValue<D>, D: Embeddable> From<&[u8]> for Value<N, D> { fn from(v: &[u8]) -> Self { Value::ByteString(Vec::from(v)) } }
|
|
|
|
|
// impl<N: NestedValue<D>, D: Embeddable> From<Vec<u8>> for Value<N, D> { fn from(v: Vec<u8>) -> Self { Value::ByteString(v) } }
|
|
|
|
|
|
|
|
|
|
impl<N: NestedValue<D>, D: Domain> From<Vec<N>> for Value<N, D> { fn from(v: Vec<N>) -> Self { Value::Sequence(v) } }
|
|
|
|
|
impl<N: NestedValue<D>, D: Domain> From<Set<N>> for Value<N, D> { fn from(v: Set<N>) -> Self { Value::Set(v) } }
|
|
|
|
|
impl<N: NestedValue<D>, D: Domain> From<Map<N, N>> for Value<N, D> { fn from(v: Map<N, N>) -> Self { Value::Dictionary(v) } }
|
|
|
|
|
impl<N: NestedValue<D>, D: Embeddable> From<Vec<N>> for Value<N, D> { fn from(v: Vec<N>) -> Self { Value::Sequence(v) } }
|
|
|
|
|
impl<N: NestedValue<D>, D: Embeddable> From<Set<N>> for Value<N, D> { fn from(v: Set<N>) -> Self { Value::Set(v) } }
|
|
|
|
|
impl<N: NestedValue<D>, D: Embeddable> From<Map<N, N>> for Value<N, D> { fn from(v: Map<N, N>) -> Self { Value::Dictionary(v) } }
|
|
|
|
|
|
|
|
|
|
impl<N: NestedValue<D>, D: Domain> Debug for Value<N, D> {
|
|
|
|
|
impl<N: NestedValue<D>, D: Embeddable> Debug for Value<N, D> {
|
|
|
|
|
// Not *quite* a formatter for the Preserves text syntax, since it
|
|
|
|
|
// doesn't escape strings/symbols properly.
|
|
|
|
|
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
|
|
|
@ -287,14 +287,14 @@ impl<N: NestedValue<D>, D: Domain> Debug for Value<N, D> {
|
|
|
|
|
f.debug_set().entries(v.iter()).finish()
|
|
|
|
|
}
|
|
|
|
|
Value::Dictionary(v) => f.debug_map().entries(v.iter()).finish(),
|
|
|
|
|
Value::Domain(d) => write!(f, "#!{:?}", d),
|
|
|
|
|
Value::Embedded(d) => write!(f, "#!{:?}", d),
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
|
|
|
|
|
|
impl<N: NestedValue<D>, D: Domain> Value<N, D> {
|
|
|
|
|
impl<N: NestedValue<D>, D: Embeddable> Value<N, D> {
|
|
|
|
|
pub fn wrap(self) -> N {
|
|
|
|
|
N::wrap(Annotations::empty(), self)
|
|
|
|
|
}
|
|
|
|
@ -777,7 +777,7 @@ impl<N: NestedValue<D>, D: Domain> Value<N, D> {
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
pub fn as_embedded(&self) -> Option<&D> {
|
|
|
|
|
if let Value::Domain(d) = self {
|
|
|
|
|
if let Value::Embedded(d) = self {
|
|
|
|
|
Some(d)
|
|
|
|
|
} else {
|
|
|
|
|
None
|
|
|
|
@ -788,7 +788,7 @@ impl<N: NestedValue<D>, D: Domain> Value<N, D> {
|
|
|
|
|
self.as_embedded().ok_or_else(|| self.expected(ExpectedKind::Embedded))
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
pub fn copy_via<M: NestedValue<E>, E: Domain, F>(&self, f: &F) -> IOResult<Value<M, E>>
|
|
|
|
|
pub fn copy_via<M: NestedValue<E>, E: Embeddable, F>(&self, f: &F) -> IOResult<Value<M, E>>
|
|
|
|
|
where
|
|
|
|
|
F: Fn(&D) -> IOResult<Value<M, E>>
|
|
|
|
|
{
|
|
|
|
@ -810,12 +810,12 @@ impl<N: NestedValue<D>, D: Domain> Value<N, D> {
|
|
|
|
|
Value::Dictionary(v) =>
|
|
|
|
|
Value::Dictionary(v.iter().map(|(a,b)| Ok((a.copy_via(f)?, b.copy_via(f)?)))
|
|
|
|
|
.collect::<IOResult<Map<_, _>>>()?),
|
|
|
|
|
Value::Domain(d) => f(d)?,
|
|
|
|
|
Value::Embedded(d) => f(d)?,
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
impl<N: NestedValue<D>, D: Domain> Index<usize> for Value<N, D> {
|
|
|
|
|
impl<N: NestedValue<D>, D: Embeddable> Index<usize> for Value<N, D> {
|
|
|
|
|
type Output = N;
|
|
|
|
|
|
|
|
|
|
fn index(&self, i: usize) -> &Self::Output {
|
|
|
|
@ -823,13 +823,13 @@ impl<N: NestedValue<D>, D: Domain> Index<usize> for Value<N, D> {
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
impl<N: NestedValue<D>, D: Domain> IndexMut<usize> for Value<N, D> {
|
|
|
|
|
impl<N: NestedValue<D>, D: Embeddable> IndexMut<usize> for Value<N, D> {
|
|
|
|
|
fn index_mut(&mut self, i: usize) -> &mut Self::Output {
|
|
|
|
|
&mut self.as_sequence_mut().unwrap()[i]
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
impl<N: NestedValue<D>, D: Domain> Index<&N> for Value<N, D> {
|
|
|
|
|
impl<N: NestedValue<D>, D: Embeddable> Index<&N> for Value<N, D> {
|
|
|
|
|
type Output = N;
|
|
|
|
|
|
|
|
|
|
fn index(&self, i: &N) -> &Self::Output {
|
|
|
|
@ -852,13 +852,13 @@ impl<'de> serde::Deserialize<'de> for UnwrappedIOValue {
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
pub fn serialize_nested_value<S, N, D: Domain>(v: &N, serializer: S) ->
|
|
|
|
|
pub fn serialize_nested_value<S, N, D: Embeddable>(v: &N, serializer: S) ->
|
|
|
|
|
Result<S::Ok, S::Error> where S: serde::Serializer, N: NestedValue<D> + serde::Serialize
|
|
|
|
|
{
|
|
|
|
|
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: Embeddable>(deserializer: D) ->
|
|
|
|
|
Result<N, D::Error> where D: serde::Deserializer<'de>, N: NestedValue<Dom> + serde::Deserialize<'de>
|
|
|
|
|
{
|
|
|
|
|
N::from_io_value(&super::magic::input_value(deserializer)?)
|
|
|
|
@ -868,9 +868,9 @@ pub fn deserialize_nested_value<'de, D, N, Dom: Domain>(deserializer: D) ->
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
|
|
|
|
|
|
#[derive(Clone)]
|
|
|
|
|
pub struct Annotations<N: NestedValue<D>, D: Domain>(Option<Vec<N>>, PhantomData<D>);
|
|
|
|
|
pub struct Annotations<N: NestedValue<D>, D: Embeddable>(Option<Vec<N>>, PhantomData<D>);
|
|
|
|
|
|
|
|
|
|
impl<N: NestedValue<D>, D: Domain> Annotations<N, D> {
|
|
|
|
|
impl<N: NestedValue<D>, D: Embeddable> Annotations<N, D> {
|
|
|
|
|
pub fn empty() -> Self {
|
|
|
|
|
Annotations(None,
|
|
|
|
|
PhantomData)
|
|
|
|
@ -901,7 +901,7 @@ impl<N: NestedValue<D>, D: Domain> Annotations<N, D> {
|
|
|
|
|
self
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
pub fn copy_via<M: NestedValue<E>, E: Domain, F>(&self, f: &F) -> IOResult<Annotations<M, E>>
|
|
|
|
|
pub fn copy_via<M: NestedValue<E>, E: Embeddable, F>(&self, f: &F) -> IOResult<Annotations<M, E>>
|
|
|
|
|
where
|
|
|
|
|
F: Fn(&D) -> IOResult<Value<M, E>>
|
|
|
|
|
{
|
|
|
|
@ -918,35 +918,35 @@ impl<N: NestedValue<D>, D: Domain> Annotations<N, D> {
|
|
|
|
|
/// A possibly-annotated Value, with annotations (themselves
|
|
|
|
|
/// possibly-annotated) in order of appearance.
|
|
|
|
|
#[derive(Clone)]
|
|
|
|
|
pub struct AnnotatedValue<N: NestedValue<D>, D: Domain>(pub Annotations<N, D>, pub Value<N, D>);
|
|
|
|
|
pub struct AnnotatedValue<N: NestedValue<D>, D: Embeddable>(pub Annotations<N, D>, pub Value<N, D>);
|
|
|
|
|
|
|
|
|
|
impl<N: NestedValue<D>, D: Domain> AnnotatedValue<N, D> {
|
|
|
|
|
impl<N: NestedValue<D>, D: Embeddable> AnnotatedValue<N, D> {
|
|
|
|
|
fn new(anns: Annotations<N, D>, value: Value<N, D>) -> Self {
|
|
|
|
|
AnnotatedValue(anns, value)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
impl<N: NestedValue<D>, D: Domain> PartialEq for AnnotatedValue<N, D> {
|
|
|
|
|
impl<N: NestedValue<D>, D: Embeddable> PartialEq for AnnotatedValue<N, D> {
|
|
|
|
|
fn eq(&self, other: &Self) -> bool {
|
|
|
|
|
self.1.eq(&other.1)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
impl<N: NestedValue<D>, D: Domain> Eq for AnnotatedValue<N, D> {}
|
|
|
|
|
impl<N: NestedValue<D>, D: Embeddable> Eq for AnnotatedValue<N, D> {}
|
|
|
|
|
|
|
|
|
|
impl<N: NestedValue<D>, D: Domain> Hash for AnnotatedValue<N, D> {
|
|
|
|
|
impl<N: NestedValue<D>, D: Embeddable> Hash for AnnotatedValue<N, D> {
|
|
|
|
|
fn hash<H: Hasher>(&self, state: &mut H) {
|
|
|
|
|
self.1.hash(state);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
impl<N: NestedValue<D>, D: Domain> PartialOrd for AnnotatedValue<N, D> {
|
|
|
|
|
impl<N: NestedValue<D>, D: Embeddable> PartialOrd for AnnotatedValue<N, D> {
|
|
|
|
|
fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
|
|
|
|
|
Some(self.cmp(other))
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
impl<N: NestedValue<D>, D: Domain> Ord for AnnotatedValue<N, D> {
|
|
|
|
|
impl<N: NestedValue<D>, D: Embeddable> Ord for AnnotatedValue<N, D> {
|
|
|
|
|
fn cmp(&self, other: &Self) -> Ordering {
|
|
|
|
|
self.1.cmp(&other.1)
|
|
|
|
|
}
|
|
|
|
@ -955,9 +955,9 @@ impl<N: NestedValue<D>, D: Domain> Ord for AnnotatedValue<N, D> {
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
|
|
|
|
|
|
#[derive(Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
|
|
|
|
|
pub struct PlainValue<D: Domain>(AnnotatedValue<PlainValue<D>, D>);
|
|
|
|
|
pub struct PlainValue<D: Embeddable>(AnnotatedValue<PlainValue<D>, D>);
|
|
|
|
|
|
|
|
|
|
impl<D: Domain> PlainValue<D> {
|
|
|
|
|
impl<D: Embeddable> PlainValue<D> {
|
|
|
|
|
pub fn annotations_mut(&mut self) -> &mut Annotations<Self, D> {
|
|
|
|
|
&mut (self.0).0
|
|
|
|
|
}
|
|
|
|
@ -967,7 +967,7 @@ impl<D: Domain> PlainValue<D> {
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
impl<D: Domain> NestedValue<D> for PlainValue<D> {
|
|
|
|
|
impl<D: Embeddable> NestedValue<D> for PlainValue<D> {
|
|
|
|
|
fn wrap(anns: Annotations<Self, D>, v: Value<Self, D>) -> Self {
|
|
|
|
|
PlainValue(AnnotatedValue::new(anns, v))
|
|
|
|
|
}
|
|
|
|
@ -990,19 +990,19 @@ impl<D: Domain> NestedValue<D> for PlainValue<D> {
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
impl<D: Domain> Debug for PlainValue<D> {
|
|
|
|
|
impl<D: Embeddable> Debug for PlainValue<D> {
|
|
|
|
|
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
|
|
|
|
self.debug_fmt(f)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
impl<D: Domain> serde::Serialize for PlainValue<D> {
|
|
|
|
|
impl<D: Embeddable> serde::Serialize for PlainValue<D> {
|
|
|
|
|
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: serde::Serializer {
|
|
|
|
|
serialize_nested_value(self, serializer)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
impl<'de, Dom: Domain> serde::Deserialize<'de> for PlainValue<Dom> {
|
|
|
|
|
impl<'de, Dom: Embeddable> serde::Deserialize<'de> for PlainValue<Dom> {
|
|
|
|
|
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: serde::Deserializer<'de> {
|
|
|
|
|
deserialize_nested_value(deserializer)
|
|
|
|
|
}
|
|
|
|
@ -1013,9 +1013,9 @@ impl<'de, Dom: Domain> serde::Deserialize<'de> for PlainValue<Dom> {
|
|
|
|
|
use std::rc::Rc;
|
|
|
|
|
|
|
|
|
|
#[derive(Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
|
|
|
|
|
pub struct RcValue<D: Domain>(Rc<AnnotatedValue<RcValue<D>, D>>);
|
|
|
|
|
pub struct RcValue<D: Embeddable>(Rc<AnnotatedValue<RcValue<D>, D>>);
|
|
|
|
|
|
|
|
|
|
impl<D: Domain> NestedValue<D> for RcValue<D> {
|
|
|
|
|
impl<D: Embeddable> NestedValue<D> for RcValue<D> {
|
|
|
|
|
fn wrap(anns: Annotations<Self, D>, v: Value<Self, D>) -> Self {
|
|
|
|
|
RcValue(Rc::new(AnnotatedValue::new(anns, v)))
|
|
|
|
|
}
|
|
|
|
@ -1040,19 +1040,19 @@ impl<D: Domain> NestedValue<D> for RcValue<D> {
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
impl<D: Domain> Debug for RcValue<D> {
|
|
|
|
|
impl<D: Embeddable> Debug for RcValue<D> {
|
|
|
|
|
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
|
|
|
|
self.debug_fmt(f)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
impl<D: Domain> serde::Serialize for RcValue<D> {
|
|
|
|
|
impl<D: Embeddable> serde::Serialize for RcValue<D> {
|
|
|
|
|
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: serde::Serializer {
|
|
|
|
|
serialize_nested_value(self, serializer)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
impl<'de, Dom: Domain> serde::Deserialize<'de> for RcValue<Dom> {
|
|
|
|
|
impl<'de, Dom: Embeddable> serde::Deserialize<'de> for RcValue<Dom> {
|
|
|
|
|
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: serde::Deserializer<'de> {
|
|
|
|
|
deserialize_nested_value(deserializer)
|
|
|
|
|
}
|
|
|
|
@ -1061,9 +1061,9 @@ impl<'de, Dom: Domain> serde::Deserialize<'de> for RcValue<Dom> {
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
|
|
|
|
|
|
#[derive(Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
|
|
|
|
|
pub struct ArcValue<D: Domain>(Arc<AnnotatedValue<ArcValue<D>, D>>);
|
|
|
|
|
pub struct ArcValue<D: Embeddable>(Arc<AnnotatedValue<ArcValue<D>, D>>);
|
|
|
|
|
|
|
|
|
|
impl<D: Domain> NestedValue<D> for ArcValue<D> {
|
|
|
|
|
impl<D: Embeddable> NestedValue<D> for ArcValue<D> {
|
|
|
|
|
fn wrap(anns: Annotations<Self, D>, v: Value<Self, D>) -> Self {
|
|
|
|
|
ArcValue(Arc::new(AnnotatedValue::new(anns, v)))
|
|
|
|
|
}
|
|
|
|
@ -1088,19 +1088,19 @@ impl<D: Domain> NestedValue<D> for ArcValue<D> {
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
impl<D: Domain> Debug for ArcValue<D> {
|
|
|
|
|
impl<D: Embeddable> Debug for ArcValue<D> {
|
|
|
|
|
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
|
|
|
|
self.debug_fmt(f)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
impl<D: Domain> serde::Serialize for ArcValue<D> {
|
|
|
|
|
impl<D: Embeddable> serde::Serialize for ArcValue<D> {
|
|
|
|
|
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: serde::Serializer {
|
|
|
|
|
serialize_nested_value(self, serializer)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
impl<'de, Dom: Domain> serde::Deserialize<'de> for ArcValue<Dom> {
|
|
|
|
|
impl<'de, Dom: Embeddable> serde::Deserialize<'de> for ArcValue<Dom> {
|
|
|
|
|
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: serde::Deserializer<'de> {
|
|
|
|
|
deserialize_nested_value(deserializer)
|
|
|
|
|
}
|
|
|
|
@ -1112,8 +1112,7 @@ impl<'de, Dom: Domain> serde::Deserialize<'de> for ArcValue<Dom> {
|
|
|
|
|
pub struct IOValue(Arc<AnnotatedValue<IOValue, IOValue>>);
|
|
|
|
|
pub type UnwrappedIOValue = Value<IOValue, IOValue>;
|
|
|
|
|
|
|
|
|
|
impl Domain for IOValue {}
|
|
|
|
|
impl PreDomain for IOValue {
|
|
|
|
|
impl Domain for IOValue {
|
|
|
|
|
fn from_preserves(v: IOValue) -> IOResult<Self> {
|
|
|
|
|
Ok(v)
|
|
|
|
|
}
|
|
|
|
|