2020-05-26 09:01:33 +00:00
|
|
|
use num::bigint::BigInt;
|
|
|
|
use num::traits::cast::ToPrimitive;
|
2020-06-15 10:48:53 +00:00
|
|
|
use std::borrow::Cow;
|
2020-05-27 07:04:55 +00:00
|
|
|
use std::cmp::Ordering;
|
|
|
|
use std::convert::TryFrom;
|
2020-06-15 10:48:53 +00:00
|
|
|
use std::convert::TryInto;
|
2019-10-12 14:40:35 +00:00
|
|
|
use std::fmt::Debug;
|
2020-05-27 07:04:55 +00:00
|
|
|
use std::hash::{Hash, Hasher};
|
2020-06-17 00:39:01 +00:00
|
|
|
use std::marker::PhantomData;
|
2019-09-09 13:46:53 +00:00
|
|
|
use std::ops::Index;
|
|
|
|
use std::ops::IndexMut;
|
2020-05-26 09:01:33 +00:00
|
|
|
use std::string::String;
|
|
|
|
use std::vec::Vec;
|
2019-06-29 22:02:27 +00:00
|
|
|
|
2019-10-12 20:50:24 +00:00
|
|
|
pub use std::collections::BTreeSet as Set;
|
|
|
|
pub use std::collections::BTreeMap as Map;
|
|
|
|
|
2020-06-15 10:48:53 +00:00
|
|
|
use super::signed_integer::SignedInteger;
|
2020-05-27 07:04:55 +00:00
|
|
|
use crate::error::{Error, ExpectedKind, Received};
|
|
|
|
|
2019-10-23 21:58:36 +00:00
|
|
|
pub trait Domain: Sized + Debug + Clone + Eq + Hash + Ord {
|
2020-05-26 09:01:33 +00:00
|
|
|
fn as_preserves(&self) -> Result<IOValue, std::io::Error> {
|
2019-10-23 21:58:36 +00:00
|
|
|
Err(std::io::Error::new(std::io::ErrorKind::InvalidData,
|
|
|
|
format!("Cannot Preserves-encode domain-specific value {:?}",
|
|
|
|
self)))
|
|
|
|
}
|
|
|
|
}
|
2019-10-22 21:36:01 +00:00
|
|
|
|
|
|
|
pub trait NestedValue<D: Domain>: Sized + Debug + Clone + Eq + Hash + Ord {
|
2020-06-17 00:39:01 +00:00
|
|
|
fn wrap(anns: Annotations<Self, D>, v: Value<Self, D>) -> Self;
|
2019-10-12 14:40:35 +00:00
|
|
|
|
2020-06-17 00:39:01 +00:00
|
|
|
fn annotations(&self) -> &Annotations<Self, D>;
|
2019-10-22 21:36:01 +00:00
|
|
|
fn value(&self) -> &Value<Self, D>;
|
2020-06-17 00:39:01 +00:00
|
|
|
fn pieces(self) -> (Annotations<Self, D>, Value<Self, D>);
|
2019-10-22 21:36:01 +00:00
|
|
|
fn value_owned(self) -> Value<Self, D>;
|
2019-10-12 14:40:35 +00:00
|
|
|
|
|
|
|
fn debug_fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
2020-06-17 00:39:01 +00:00
|
|
|
for ann in self.annotations().slice() {
|
2019-10-12 14:40:35 +00:00
|
|
|
write!(f, "@{:?} ", ann)?;
|
|
|
|
}
|
|
|
|
self.value().fmt(f)
|
|
|
|
}
|
|
|
|
|
2020-05-25 18:11:54 +00:00
|
|
|
fn copy_via<M: NestedValue<E>, E: Domain, F>(&self, f: &F) -> M
|
|
|
|
where
|
|
|
|
F: Fn(&D) -> Value<M, E>
|
|
|
|
{
|
2020-06-17 00:39:01 +00:00
|
|
|
M::wrap(self.annotations().copy_via(f), self.value().copy_via(f))
|
2020-05-25 18:11:54 +00:00
|
|
|
}
|
|
|
|
|
2020-05-26 09:01:33 +00:00
|
|
|
fn to_io_value(&self) -> IOValue {
|
|
|
|
self.copy_via(&|d| d.as_preserves().unwrap().value().clone())
|
|
|
|
}
|
|
|
|
|
|
|
|
fn from_io_value(v: &IOValue) -> Self {
|
|
|
|
v.copy_via(&|_| unreachable!())
|
2020-05-26 07:08:17 +00:00
|
|
|
}
|
2019-10-12 14:40:35 +00:00
|
|
|
}
|
|
|
|
|
2019-09-09 13:46:53 +00:00
|
|
|
/// The `Value`s from the specification.
|
2019-09-15 11:25:23 +00:00
|
|
|
#[derive(Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
|
2019-10-22 21:36:01 +00:00
|
|
|
pub enum Value<N, D> where N: NestedValue<D>, D: Domain {
|
2019-06-29 22:02:27 +00:00
|
|
|
Boolean(bool),
|
|
|
|
Float(Float),
|
|
|
|
Double(Double),
|
2020-06-15 10:48:53 +00:00
|
|
|
SignedInteger(SignedInteger),
|
2019-09-09 13:46:53 +00:00
|
|
|
String(String),
|
|
|
|
ByteString(Vec<u8>),
|
|
|
|
Symbol(String),
|
2020-06-15 10:48:53 +00:00
|
|
|
Record(Record<N>),
|
2019-10-12 14:40:35 +00:00
|
|
|
Sequence(Vec<N>),
|
|
|
|
Set(Set<N>),
|
|
|
|
Dictionary(Map<N, N>),
|
2019-10-22 21:36:01 +00:00
|
|
|
Domain(D),
|
2019-06-29 22:02:27 +00:00
|
|
|
}
|
|
|
|
|
2019-09-09 13:46:53 +00:00
|
|
|
/// Single-precision IEEE 754 Value
|
2019-06-29 22:02:27 +00:00
|
|
|
#[derive(Clone, Debug)]
|
2019-09-09 21:08:26 +00:00
|
|
|
pub struct Float(pub f32);
|
2019-06-29 22:02:27 +00:00
|
|
|
|
2019-09-09 13:46:53 +00:00
|
|
|
/// Double-precision IEEE 754 Value
|
2019-06-29 22:02:27 +00:00
|
|
|
#[derive(Clone, Debug)]
|
2019-09-09 21:08:26 +00:00
|
|
|
pub struct Double(pub f64);
|
2019-06-29 22:02:27 +00:00
|
|
|
|
2020-06-15 10:48:53 +00:00
|
|
|
/// A Record `Value` -- INVARIANT: length always non-zero
|
|
|
|
#[derive(Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
|
|
|
|
pub struct Record<N>(pub Vec<N>);
|
|
|
|
|
|
|
|
impl<N> Record<N> {
|
|
|
|
pub fn label(&self) -> &N {
|
|
|
|
&self.0[0]
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn label_mut(&mut self) -> &mut N {
|
|
|
|
&mut self.0[0]
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn arity(&self) -> usize {
|
|
|
|
self.0.len() - 1
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn fields(&self) -> &[N] {
|
|
|
|
&self.0[1..]
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn fields_mut(&mut self) -> &mut [N] {
|
|
|
|
&mut self.0[1..]
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn fields_vec(&self) -> &Vec<N> {
|
|
|
|
&self.0
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn fields_vec_mut(&mut self) -> &mut Vec<N> {
|
|
|
|
&mut self.0
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn finish<D: Domain>(self) -> Value<N, D> where N: NestedValue<D> {
|
|
|
|
Value::Record(self)
|
|
|
|
}
|
|
|
|
}
|
2019-09-09 21:08:26 +00:00
|
|
|
|
2019-06-29 22:02:27 +00:00
|
|
|
impl From<f32> for Float {
|
|
|
|
fn from(v: f32) -> Self {
|
|
|
|
Float(v)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl From<Float> for f32 {
|
|
|
|
fn from(v: Float) -> Self {
|
|
|
|
v.0
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl Hash for Float {
|
|
|
|
fn hash<H: Hasher>(&self, state: &mut H) {
|
|
|
|
self.0.to_bits().hash(state);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl PartialEq for Float {
|
|
|
|
fn eq(&self, other: &Self) -> bool {
|
|
|
|
self.0.to_bits() == other.0.to_bits()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl Ord for Float {
|
|
|
|
fn cmp(&self, other: &Self) -> Ordering {
|
2019-07-04 09:47:32 +00:00
|
|
|
let mut a: u32 = self.0.to_bits();
|
|
|
|
let mut b: u32 = other.0.to_bits();
|
2019-10-20 12:57:04 +00:00
|
|
|
if a & 0x8000_0000 != 0 { a ^= 0x7fff_ffff; }
|
|
|
|
if b & 0x8000_0000 != 0 { b ^= 0x7fff_ffff; }
|
2019-06-30 22:43:32 +00:00
|
|
|
(a as i32).cmp(&(b as i32))
|
2019-06-29 22:02:27 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl PartialOrd for Float {
|
|
|
|
fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
|
|
|
|
Some(self.cmp(other))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl Eq for Float {}
|
|
|
|
|
|
|
|
impl From<f64> for Double {
|
|
|
|
fn from(v: f64) -> Self {
|
|
|
|
Double(v)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl From<Double> for f64 {
|
|
|
|
fn from(v: Double) -> Self {
|
|
|
|
v.0
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl Hash for Double {
|
|
|
|
fn hash<H: Hasher>(&self, state: &mut H) {
|
|
|
|
self.0.to_bits().hash(state);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl PartialEq for Double {
|
|
|
|
fn eq(&self, other: &Self) -> bool {
|
2019-10-20 12:57:04 +00:00
|
|
|
self.0.to_bits() == other.0.to_bits()
|
2019-06-29 22:02:27 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl Ord for Double {
|
|
|
|
fn cmp(&self, other: &Self) -> Ordering {
|
2019-07-04 09:47:32 +00:00
|
|
|
let mut a: u64 = self.0.to_bits();
|
|
|
|
let mut b: u64 = other.0.to_bits();
|
2019-10-20 12:57:04 +00:00
|
|
|
if a & 0x8000_0000_0000_0000 != 0 { a ^= 0x7fff_ffff_ffff_ffff; }
|
|
|
|
if b & 0x8000_0000_0000_0000 != 0 { b ^= 0x7fff_ffff_ffff_ffff; }
|
2019-06-30 22:43:32 +00:00
|
|
|
(a as i64).cmp(&(b as i64))
|
2019-06-29 22:02:27 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl PartialOrd for Double {
|
|
|
|
fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
|
|
|
|
Some(self.cmp(other))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl Eq for Double {}
|
|
|
|
|
2019-10-22 21:36:01 +00:00
|
|
|
impl<N: NestedValue<D>, D: Domain> From<bool> for Value<N, D> { fn from(v: bool) -> Self { Value::Boolean(v) } }
|
2019-06-29 22:02:27 +00:00
|
|
|
|
2019-10-22 21:36:01 +00:00
|
|
|
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<f64> for Value<N, D> { fn from(v: f64) -> Self { Value::Double(Double::from(v)) } }
|
2019-06-29 22:02:27 +00:00
|
|
|
|
2019-10-22 21:36:01 +00:00
|
|
|
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)) } }
|
2020-06-15 10:48:53 +00:00
|
|
|
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))) } }
|
2019-06-29 22:02:27 +00:00
|
|
|
|
2019-10-22 21:36:01 +00:00
|
|
|
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) } }
|
2019-09-09 13:46:53 +00:00
|
|
|
|
2019-10-22 21:36:01 +00:00
|
|
|
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) } }
|
2019-09-09 13:46:53 +00:00
|
|
|
|
2019-10-22 21:36:01 +00:00
|
|
|
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) } }
|
2019-09-09 21:08:26 +00:00
|
|
|
|
2019-10-22 21:36:01 +00:00
|
|
|
impl<N: NestedValue<D>, D: Domain> Debug for Value<N, D> {
|
2019-09-15 11:25:23 +00:00
|
|
|
// 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 {
|
|
|
|
match self {
|
2021-01-06 16:42:02 +00:00
|
|
|
Value::Boolean(false) => f.write_str("#f"),
|
|
|
|
Value::Boolean(true) => f.write_str("#t"),
|
2019-09-15 11:25:23 +00:00
|
|
|
Value::Float(Float(v)) => write!(f, "{:?}f", v),
|
|
|
|
Value::Double(Double(v)) => write!(f, "{:?}", v),
|
|
|
|
Value::SignedInteger(v) => write!(f, "{}", v),
|
|
|
|
Value::String(ref v) => write!(f, "{:?}", v), // TODO: proper escaping!
|
|
|
|
Value::ByteString(ref v) => {
|
2021-01-06 16:42:02 +00:00
|
|
|
f.write_str("#x\"")?;
|
2019-09-15 11:25:23 +00:00
|
|
|
for b in v { write!(f, "{:02x}", b)? }
|
2021-01-06 16:42:02 +00:00
|
|
|
f.write_str("\"")
|
2019-09-15 11:25:23 +00:00
|
|
|
}
|
|
|
|
Value::Symbol(ref v) => {
|
|
|
|
// TODO: proper escaping!
|
2019-10-20 12:57:04 +00:00
|
|
|
if v.is_empty() {
|
2019-09-15 11:25:23 +00:00
|
|
|
f.write_str("||")
|
|
|
|
} else {
|
|
|
|
write!(f, "{}", v)
|
|
|
|
}
|
|
|
|
}
|
2020-06-15 10:48:53 +00:00
|
|
|
Value::Record(ref r) => {
|
2019-09-15 11:25:23 +00:00
|
|
|
f.write_str("<")?;
|
2020-06-15 10:48:53 +00:00
|
|
|
r.label().fmt(f)?;
|
|
|
|
for v in r.fields() {
|
2019-09-15 11:25:23 +00:00
|
|
|
f.write_str(" ")?;
|
|
|
|
v.fmt(f)?;
|
|
|
|
}
|
|
|
|
f.write_str(">")
|
|
|
|
}
|
|
|
|
Value::Sequence(ref v) => v.fmt(f),
|
|
|
|
Value::Set(ref v) => {
|
2021-01-06 16:42:02 +00:00
|
|
|
f.write_str("#")?;
|
2019-09-15 11:25:23 +00:00
|
|
|
f.debug_set().entries(v.iter()).finish()
|
|
|
|
}
|
2019-10-22 21:36:01 +00:00
|
|
|
Value::Dictionary(ref v) => f.debug_map().entries(v.iter()).finish(),
|
|
|
|
Value::Domain(ref d) => write!(f, "{:?}", d),
|
2019-09-15 11:25:23 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-09-09 13:46:53 +00:00
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
|
2019-10-22 21:36:01 +00:00
|
|
|
impl<N: NestedValue<D>, D: Domain> Value<N, D> {
|
2019-10-12 14:40:35 +00:00
|
|
|
pub fn wrap(self) -> N {
|
2020-06-17 00:39:01 +00:00
|
|
|
N::wrap(Annotations::empty(), self)
|
2019-09-09 13:46:53 +00:00
|
|
|
}
|
|
|
|
|
2020-05-27 07:04:55 +00:00
|
|
|
fn expected(&self, k: ExpectedKind) -> Error {
|
|
|
|
Error::Expected(k, Received::ReceivedOtherValue(self.clone().wrap().to_io_value()))
|
|
|
|
}
|
|
|
|
|
2019-09-09 13:46:53 +00:00
|
|
|
pub fn is_boolean(&self) -> bool {
|
|
|
|
self.as_boolean().is_some()
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn as_boolean(&self) -> Option<bool> {
|
|
|
|
if let Value::Boolean(b) = *self {
|
|
|
|
Some(b)
|
|
|
|
} else {
|
|
|
|
None
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn as_boolean_mut(&mut self) -> Option<&mut bool> {
|
|
|
|
if let Value::Boolean(ref mut b) = *self {
|
|
|
|
Some(b)
|
|
|
|
} else {
|
|
|
|
None
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-05-27 07:04:55 +00:00
|
|
|
pub fn to_boolean(&self) -> Result<bool, Error> {
|
|
|
|
self.as_boolean().ok_or_else(|| self.expected(ExpectedKind::Boolean))
|
|
|
|
}
|
|
|
|
|
2019-09-09 13:46:53 +00:00
|
|
|
pub fn is_float(&self) -> bool {
|
|
|
|
self.as_float().is_some()
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn as_float(&self) -> Option<f32> {
|
|
|
|
if let Value::Float(Float(f)) = *self {
|
|
|
|
Some(f)
|
|
|
|
} else {
|
|
|
|
None
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn as_float_mut(&mut self) -> Option<&mut f32> {
|
|
|
|
if let Value::Float(Float(ref mut f)) = *self {
|
|
|
|
Some(f)
|
|
|
|
} else {
|
|
|
|
None
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-05-27 07:04:55 +00:00
|
|
|
pub fn to_float(&self) -> Result<f32, Error> {
|
|
|
|
self.as_float().ok_or_else(|| self.expected(ExpectedKind::Float))
|
|
|
|
}
|
|
|
|
|
2019-09-09 13:46:53 +00:00
|
|
|
pub fn is_double(&self) -> bool {
|
|
|
|
self.as_double().is_some()
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn as_double(&self) -> Option<f64> {
|
|
|
|
if let Value::Double(Double(f)) = *self {
|
|
|
|
Some(f)
|
|
|
|
} else {
|
|
|
|
None
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn as_double_mut(&mut self) -> Option<&mut f64> {
|
|
|
|
if let Value::Double(Double(ref mut f)) = *self {
|
|
|
|
Some(f)
|
|
|
|
} else {
|
|
|
|
None
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-05-27 07:04:55 +00:00
|
|
|
pub fn to_double(&self) -> Result<f64, Error> {
|
|
|
|
self.as_double().ok_or_else(|| self.expected(ExpectedKind::Double))
|
|
|
|
}
|
|
|
|
|
2019-09-09 13:46:53 +00:00
|
|
|
pub fn is_signedinteger(&self) -> bool {
|
|
|
|
self.as_signedinteger().is_some()
|
|
|
|
}
|
|
|
|
|
2020-06-15 10:48:53 +00:00
|
|
|
pub fn as_signedinteger(&self) -> Option<&SignedInteger> {
|
|
|
|
if let Value::SignedInteger(ref n) = *self {
|
|
|
|
Some(n)
|
2019-09-09 13:46:53 +00:00
|
|
|
} else {
|
|
|
|
None
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-06-15 10:48:53 +00:00
|
|
|
pub fn as_signedinteger_mut(&mut self) -> Option<&mut SignedInteger> {
|
|
|
|
if let Value::SignedInteger(ref mut n) = *self {
|
|
|
|
Some(n)
|
2019-09-09 13:46:53 +00:00
|
|
|
} else {
|
|
|
|
None
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-06-15 10:48:53 +00:00
|
|
|
pub fn to_signedinteger(&self) -> Result<&SignedInteger, Error> {
|
2020-05-27 07:04:55 +00:00
|
|
|
self.as_signedinteger().ok_or_else(|| self.expected(ExpectedKind::SignedInteger))
|
|
|
|
}
|
|
|
|
|
2020-06-15 10:48:53 +00:00
|
|
|
pub fn is_i(&self) -> bool {
|
|
|
|
self.as_i().is_some()
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn as_i(&self) -> Option<i128> {
|
|
|
|
self.as_signedinteger().and_then(|n| n.try_into().ok())
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn to_i(&self) -> Result<i128, Error> {
|
|
|
|
self.as_i().ok_or_else(|| self.expected(ExpectedKind::SignedIntegerI128))
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn is_u(&self) -> bool {
|
|
|
|
self.as_u().is_some()
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn as_u(&self) -> Option<u128> {
|
|
|
|
self.as_signedinteger().and_then(|n| n.try_into().ok())
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn to_u(&self) -> Result<u128, Error> {
|
|
|
|
self.as_u().ok_or_else(|| self.expected(ExpectedKind::SignedIntegerU128))
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn as_u8(&self) -> Option<u8> { self.as_u().and_then(|i| i.to_u8()) }
|
|
|
|
pub fn as_i8(&self) -> Option<i8> { self.as_i().and_then(|i| i.to_i8()) }
|
|
|
|
pub fn as_u16(&self) -> Option<u16> { self.as_u().and_then(|i| i.to_u16()) }
|
|
|
|
pub fn as_i16(&self) -> Option<i16> { self.as_i().and_then(|i| i.to_i16()) }
|
|
|
|
pub fn as_u32(&self) -> Option<u32> { self.as_u().and_then(|i| i.to_u32()) }
|
|
|
|
pub fn as_i32(&self) -> Option<i32> { self.as_i().and_then(|i| i.to_i32()) }
|
|
|
|
pub fn as_u64(&self) -> Option<u64> { self.as_u().and_then(|i| i.to_u64()) }
|
|
|
|
pub fn as_i64(&self) -> Option<i64> { self.as_i().and_then(|i| i.to_i64()) }
|
|
|
|
pub fn as_u128(&self) -> Option<u128> { self.as_u().and_then(|i| i.to_u128()) }
|
|
|
|
pub fn as_i128(&self) -> Option<i128> { self.as_i().and_then(|i| i.to_i128()) }
|
2019-09-16 23:58:32 +00:00
|
|
|
|
2020-05-27 07:04:55 +00:00
|
|
|
pub fn to_i8(&self) -> Result<i8, Error> {
|
2020-06-15 10:48:53 +00:00
|
|
|
match self.as_i() {
|
|
|
|
Some(i) => i.to_i8().ok_or_else(|| Error::NumberOutOfRange(BigInt::from(i))),
|
|
|
|
None => Err(self.expected(ExpectedKind::SignedInteger)),
|
|
|
|
}
|
2020-05-27 07:04:55 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
pub fn to_u8(&self) -> Result<u8, Error> {
|
2020-06-15 10:48:53 +00:00
|
|
|
match self.as_u() {
|
|
|
|
Some(i) => i.to_u8().ok_or_else(|| Error::NumberOutOfRange(BigInt::from(i))),
|
|
|
|
None => Err(self.expected(ExpectedKind::SignedInteger)),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn to_i16(&self) -> Result<i16, Error> {
|
|
|
|
match self.as_i() {
|
|
|
|
Some(i) => i.to_i16().ok_or_else(|| Error::NumberOutOfRange(BigInt::from(i))),
|
|
|
|
None => Err(self.expected(ExpectedKind::SignedInteger)),
|
|
|
|
}
|
2020-05-27 07:04:55 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
pub fn to_u16(&self) -> Result<u16, Error> {
|
2020-06-15 10:48:53 +00:00
|
|
|
match self.as_u() {
|
|
|
|
Some(i) => i.to_u16().ok_or_else(|| Error::NumberOutOfRange(BigInt::from(i))),
|
|
|
|
None => Err(self.expected(ExpectedKind::SignedInteger)),
|
|
|
|
}
|
2020-05-27 07:04:55 +00:00
|
|
|
}
|
|
|
|
|
2020-06-15 10:48:53 +00:00
|
|
|
pub fn to_i32(&self) -> Result<i32, Error> {
|
|
|
|
match self.as_i() {
|
|
|
|
Some(i) => i.to_i32().ok_or_else(|| Error::NumberOutOfRange(BigInt::from(i))),
|
|
|
|
None => Err(self.expected(ExpectedKind::SignedInteger)),
|
|
|
|
}
|
2020-05-27 07:04:55 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
pub fn to_u32(&self) -> Result<u32, Error> {
|
2020-06-15 10:48:53 +00:00
|
|
|
match self.as_u() {
|
|
|
|
Some(i) => i.to_u32().ok_or_else(|| Error::NumberOutOfRange(BigInt::from(i))),
|
|
|
|
None => Err(self.expected(ExpectedKind::SignedInteger)),
|
|
|
|
}
|
2020-05-27 07:04:55 +00:00
|
|
|
}
|
|
|
|
|
2020-06-15 10:48:53 +00:00
|
|
|
pub fn to_i64(&self) -> Result<i64, Error> {
|
|
|
|
match self.as_i() {
|
|
|
|
Some(i) => i.to_i64().ok_or_else(|| Error::NumberOutOfRange(BigInt::from(i))),
|
|
|
|
None => Err(self.expected(ExpectedKind::SignedInteger)),
|
|
|
|
}
|
2020-05-27 07:04:55 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
pub fn to_u64(&self) -> Result<u64, Error> {
|
2020-06-15 10:48:53 +00:00
|
|
|
match self.as_u() {
|
|
|
|
Some(i) => i.to_u64().ok_or_else(|| Error::NumberOutOfRange(BigInt::from(i))),
|
|
|
|
None => Err(self.expected(ExpectedKind::SignedInteger)),
|
|
|
|
}
|
2020-05-27 07:04:55 +00:00
|
|
|
}
|
|
|
|
|
2020-06-15 10:48:53 +00:00
|
|
|
pub fn to_i128(&self) -> Result<i128, Error> {
|
|
|
|
match self.as_i() {
|
|
|
|
Some(i) => i.to_i128().ok_or_else(|| Error::NumberOutOfRange(BigInt::from(i))),
|
|
|
|
None => Err(self.expected(ExpectedKind::SignedInteger)),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn to_u128(&self) -> Result<u128, Error> {
|
|
|
|
match self.as_u() {
|
|
|
|
Some(i) => i.to_u128().ok_or_else(|| Error::NumberOutOfRange(BigInt::from(i))),
|
|
|
|
None => Err(self.expected(ExpectedKind::SignedInteger)),
|
|
|
|
}
|
2020-05-27 07:04:55 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
pub fn to_char(&self) -> Result<char, Error> {
|
|
|
|
let fs = self.to_simple_record("UnicodeScalar", Some(1))?;
|
|
|
|
let c = fs[0].value().to_u32()?;
|
|
|
|
char::try_from(c).or_else(|_| Err(Error::InvalidUnicodeScalar(c)))
|
|
|
|
}
|
|
|
|
|
2019-09-09 13:46:53 +00:00
|
|
|
pub fn is_string(&self) -> bool {
|
|
|
|
self.as_string().is_some()
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn as_string(&self) -> Option<&String> {
|
|
|
|
if let Value::String(ref s) = *self {
|
|
|
|
Some(s)
|
|
|
|
} else {
|
|
|
|
None
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn as_string_mut(&mut self) -> Option<&mut String> {
|
|
|
|
if let Value::String(ref mut s) = *self {
|
|
|
|
Some(s)
|
|
|
|
} else {
|
|
|
|
None
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-05-27 07:04:55 +00:00
|
|
|
pub fn to_string(&self) -> Result<&String, Error> {
|
|
|
|
self.as_string().ok_or_else(|| self.expected(ExpectedKind::String))
|
|
|
|
}
|
|
|
|
|
2019-09-09 13:46:53 +00:00
|
|
|
pub fn is_bytestring(&self) -> bool {
|
|
|
|
self.as_bytestring().is_some()
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn as_bytestring(&self) -> Option<&Vec<u8>> {
|
|
|
|
if let Value::ByteString(ref s) = *self {
|
|
|
|
Some(s)
|
|
|
|
} else {
|
|
|
|
None
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn as_bytestring_mut(&mut self) -> Option<&mut Vec<u8>> {
|
|
|
|
if let Value::ByteString(ref mut s) = *self {
|
|
|
|
Some(s)
|
|
|
|
} else {
|
|
|
|
None
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-05-27 07:04:55 +00:00
|
|
|
pub fn to_bytestring(&self) -> Result<&Vec<u8>, Error> {
|
|
|
|
self.as_bytestring().ok_or_else(|| self.expected(ExpectedKind::ByteString))
|
|
|
|
}
|
|
|
|
|
2019-10-22 21:36:01 +00:00
|
|
|
pub fn symbol(s: &str) -> Value<N, D> {
|
2019-09-09 13:46:53 +00:00
|
|
|
Value::Symbol(s.to_string())
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn is_symbol(&self) -> bool {
|
|
|
|
self.as_symbol().is_some()
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn as_symbol(&self) -> Option<&String> {
|
|
|
|
if let Value::Symbol(ref s) = *self {
|
|
|
|
Some(s)
|
|
|
|
} else {
|
|
|
|
None
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn as_symbol_mut(&mut self) -> Option<&mut String> {
|
|
|
|
if let Value::Symbol(ref mut s) = *self {
|
|
|
|
Some(s)
|
|
|
|
} else {
|
|
|
|
None
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-05-27 07:04:55 +00:00
|
|
|
pub fn to_symbol(&self) -> Result<&String, Error> {
|
|
|
|
self.as_symbol().ok_or_else(|| self.expected(ExpectedKind::Symbol))
|
|
|
|
}
|
|
|
|
|
2020-06-15 10:48:53 +00:00
|
|
|
pub fn record(label: N, expected_arity: usize) -> Record<N> {
|
|
|
|
let mut v = Vec::with_capacity(expected_arity + 1);
|
|
|
|
v.push(label);
|
|
|
|
Record(v)
|
2019-09-09 13:46:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
pub fn is_record(&self) -> bool {
|
2020-06-15 10:48:53 +00:00
|
|
|
if let Value::Record(_) = *self {
|
|
|
|
true
|
|
|
|
} else {
|
|
|
|
false
|
|
|
|
}
|
2019-09-09 13:46:53 +00:00
|
|
|
}
|
|
|
|
|
2020-06-15 10:48:53 +00:00
|
|
|
pub fn as_record(&self, arity: Option<usize>) -> Option<&Record<N>> {
|
2019-09-09 13:46:53 +00:00
|
|
|
if let Value::Record(ref r) = *self {
|
2020-05-18 14:42:59 +00:00
|
|
|
match arity {
|
2020-06-15 10:48:53 +00:00
|
|
|
Some(expected) if r.arity() == expected => Some(r),
|
2020-05-18 14:42:59 +00:00
|
|
|
Some(_other) => None,
|
|
|
|
None => Some(r)
|
|
|
|
}
|
2019-09-09 13:46:53 +00:00
|
|
|
} else {
|
|
|
|
None
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-06-15 10:48:53 +00:00
|
|
|
pub fn as_record_mut(&mut self, arity: Option<usize>) -> Option<&mut Record<N>> {
|
2019-09-09 13:46:53 +00:00
|
|
|
if let Value::Record(ref mut r) = *self {
|
2020-05-18 14:42:59 +00:00
|
|
|
match arity {
|
2020-06-15 10:48:53 +00:00
|
|
|
Some(expected) if r.arity() == expected => Some(r),
|
2020-05-18 14:42:59 +00:00
|
|
|
Some(_other) => None,
|
|
|
|
None => Some(r)
|
|
|
|
}
|
2019-09-09 13:46:53 +00:00
|
|
|
} else {
|
|
|
|
None
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-06-15 10:48:53 +00:00
|
|
|
pub fn to_record(&self, arity: Option<usize>) -> Result<&Record<N>, Error> {
|
2020-05-27 07:04:55 +00:00
|
|
|
self.as_record(arity).ok_or_else(|| self.expected(ExpectedKind::Record(arity)))
|
|
|
|
}
|
|
|
|
|
2020-06-15 10:48:53 +00:00
|
|
|
pub fn simple_record(label: &str, expected_arity: usize) -> Record<N> {
|
|
|
|
Self::record(Value::symbol(label).wrap(), expected_arity)
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn simple_record0(label: &str) -> Value<N, D> {
|
|
|
|
Self::simple_record(label, 0).finish()
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn simple_record1(label: &str, field: N) -> Value<N, D> {
|
|
|
|
let mut r = Self::simple_record(label, 1);
|
|
|
|
r.fields_vec_mut().push(field);
|
|
|
|
r.finish()
|
2019-09-16 23:58:32 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
pub fn is_simple_record(&self, label: &str, arity: Option<usize>) -> bool {
|
|
|
|
self.as_simple_record(label, arity).is_some()
|
|
|
|
}
|
|
|
|
|
2020-06-15 10:48:53 +00:00
|
|
|
pub fn as_simple_record(&self, label: &str, arity: Option<usize>) -> Option<&[N]> {
|
|
|
|
self.as_record(arity).and_then(|r| {
|
|
|
|
match r.label().value() {
|
|
|
|
Value::Symbol(ref s) if s == label => Some(r.fields()),
|
2019-09-16 23:58:32 +00:00
|
|
|
_ => None
|
|
|
|
}
|
|
|
|
})
|
|
|
|
}
|
|
|
|
|
2020-06-15 10:48:53 +00:00
|
|
|
pub fn to_simple_record(&self, label: &str, arity: Option<usize>) ->
|
|
|
|
Result<&[N], Error>
|
2020-05-27 07:04:55 +00:00
|
|
|
{
|
|
|
|
self.as_simple_record(label, arity)
|
2020-06-15 10:48:53 +00:00
|
|
|
.ok_or_else(|| self.expected(ExpectedKind::SimpleRecord(label.to_owned(), arity)))
|
2020-05-27 07:04:55 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
pub fn to_option(&self) -> Result<Option<&N>, Error> {
|
|
|
|
match self.as_simple_record("None", Some(0)) {
|
|
|
|
Some(_fs) => Ok(None),
|
|
|
|
None => match self.as_simple_record("Some", Some(1)) {
|
|
|
|
Some(fs) => Ok(Some(&fs[0])),
|
|
|
|
None => Err(self.expected(ExpectedKind::Option))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-09-09 13:46:53 +00:00
|
|
|
pub fn is_sequence(&self) -> bool {
|
|
|
|
self.as_sequence().is_some()
|
|
|
|
}
|
|
|
|
|
2019-10-12 14:40:35 +00:00
|
|
|
pub fn as_sequence(&self) -> Option<&Vec<N>> {
|
2019-09-09 13:46:53 +00:00
|
|
|
if let Value::Sequence(ref s) = *self {
|
|
|
|
Some(s)
|
|
|
|
} else {
|
|
|
|
None
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-10-12 14:40:35 +00:00
|
|
|
pub fn as_sequence_mut(&mut self) -> Option<&mut Vec<N>> {
|
2019-09-09 13:46:53 +00:00
|
|
|
if let Value::Sequence(ref mut s) = *self {
|
|
|
|
Some(s)
|
|
|
|
} else {
|
|
|
|
None
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-05-27 07:04:55 +00:00
|
|
|
pub fn to_sequence(&self) -> Result<&Vec<N>, Error> {
|
|
|
|
self.as_sequence().ok_or_else(|| self.expected(ExpectedKind::Sequence))
|
|
|
|
}
|
|
|
|
|
2019-09-09 13:46:53 +00:00
|
|
|
pub fn is_set(&self) -> bool {
|
|
|
|
self.as_set().is_some()
|
|
|
|
}
|
|
|
|
|
2019-10-12 14:40:35 +00:00
|
|
|
pub fn as_set(&self) -> Option<&Set<N>> {
|
2019-09-09 13:46:53 +00:00
|
|
|
if let Value::Set(ref s) = *self {
|
|
|
|
Some(s)
|
|
|
|
} else {
|
|
|
|
None
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-10-12 14:40:35 +00:00
|
|
|
pub fn as_set_mut(&mut self) -> Option<&mut Set<N>> {
|
2019-09-09 13:46:53 +00:00
|
|
|
if let Value::Set(ref mut s) = *self {
|
|
|
|
Some(s)
|
|
|
|
} else {
|
|
|
|
None
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-05-27 07:04:55 +00:00
|
|
|
pub fn to_set(&self) -> Result<&Set<N>, Error> {
|
|
|
|
self.as_set().ok_or_else(|| self.expected(ExpectedKind::Set))
|
|
|
|
}
|
|
|
|
|
2019-09-09 13:46:53 +00:00
|
|
|
pub fn is_dictionary(&self) -> bool {
|
|
|
|
self.as_dictionary().is_some()
|
|
|
|
}
|
|
|
|
|
2019-10-12 14:40:35 +00:00
|
|
|
pub fn as_dictionary(&self) -> Option<&Map<N, N>> {
|
2019-09-09 13:46:53 +00:00
|
|
|
if let Value::Dictionary(ref s) = *self {
|
|
|
|
Some(s)
|
|
|
|
} else {
|
|
|
|
None
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-10-12 14:40:35 +00:00
|
|
|
pub fn as_dictionary_mut(&mut self) -> Option<&mut Map<N, N>> {
|
2019-09-09 13:46:53 +00:00
|
|
|
if let Value::Dictionary(ref mut s) = *self {
|
|
|
|
Some(s)
|
|
|
|
} else {
|
|
|
|
None
|
|
|
|
}
|
|
|
|
}
|
2019-10-12 14:40:35 +00:00
|
|
|
|
2020-05-27 07:04:55 +00:00
|
|
|
pub fn to_dictionary(&self) -> Result<&Map<N, N>, Error> {
|
|
|
|
self.as_dictionary().ok_or_else(|| self.expected(ExpectedKind::Dictionary))
|
|
|
|
}
|
|
|
|
|
2020-05-25 18:11:54 +00:00
|
|
|
pub fn copy_via<M: NestedValue<E>, E: Domain, F>(&self, f: &F) -> Value<M, E>
|
|
|
|
where
|
|
|
|
F: Fn(&D) -> Value<M, E>
|
|
|
|
{
|
2019-10-12 14:40:35 +00:00
|
|
|
match self {
|
|
|
|
Value::Boolean(b) => Value::Boolean(*b),
|
|
|
|
Value::Float(f) => Value::Float(f.clone()),
|
|
|
|
Value::Double(d) => Value::Double(d.clone()),
|
2020-06-15 10:48:53 +00:00
|
|
|
Value::SignedInteger(ref n) => Value::SignedInteger(n.clone()),
|
2019-10-12 14:40:35 +00:00
|
|
|
Value::String(ref s) => Value::String(s.clone()),
|
|
|
|
Value::ByteString(ref v) => Value::ByteString(v.clone()),
|
2020-05-18 14:42:34 +00:00
|
|
|
Value::Symbol(ref v) => Value::Symbol(v.clone()),
|
2020-06-15 10:48:53 +00:00
|
|
|
Value::Record(ref r) =>
|
|
|
|
Value::Record(Record(r.fields_vec().iter().map(|a| a.copy_via(f)).collect())),
|
2020-05-25 18:11:54 +00:00
|
|
|
Value::Sequence(ref v) => Value::Sequence(v.iter().map(|a| a.copy_via(f)).collect()),
|
|
|
|
Value::Set(ref v) => Value::Set(v.iter().map(|a| a.copy_via(f)).collect()),
|
2019-10-12 14:40:35 +00:00
|
|
|
Value::Dictionary(ref v) =>
|
2020-05-25 18:11:54 +00:00
|
|
|
Value::Dictionary(v.iter().map(|(a,b)| (a.copy_via(f), b.copy_via(f))).collect()),
|
|
|
|
Value::Domain(d) => f(d),
|
2019-10-12 14:40:35 +00:00
|
|
|
}
|
|
|
|
}
|
2019-09-09 13:46:53 +00:00
|
|
|
}
|
|
|
|
|
2019-10-22 21:36:01 +00:00
|
|
|
impl<N: NestedValue<D>, D: Domain> Index<usize> for Value<N, D> {
|
2019-10-12 14:40:35 +00:00
|
|
|
type Output = N;
|
2019-09-09 13:46:53 +00:00
|
|
|
|
|
|
|
fn index(&self, i: usize) -> &Self::Output {
|
|
|
|
&self.as_sequence().unwrap()[i]
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-10-22 21:36:01 +00:00
|
|
|
impl<N: NestedValue<D>, D: Domain> IndexMut<usize> for Value<N, D> {
|
2019-09-09 13:46:53 +00:00
|
|
|
fn index_mut(&mut self, i: usize) -> &mut Self::Output {
|
|
|
|
&mut self.as_sequence_mut().unwrap()[i]
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-10-22 21:36:01 +00:00
|
|
|
impl<N: NestedValue<D>, D: Domain> Index<&N> for Value<N, D> {
|
2019-10-12 14:40:35 +00:00
|
|
|
type Output = N;
|
2019-09-09 13:46:53 +00:00
|
|
|
|
2019-10-12 14:40:35 +00:00
|
|
|
fn index(&self, i: &N) -> &Self::Output {
|
|
|
|
&(*self.as_dictionary().unwrap())[i]
|
2019-09-09 13:46:53 +00:00
|
|
|
}
|
|
|
|
}
|
2019-09-16 23:58:32 +00:00
|
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
// This part is a terrible hack
|
|
|
|
|
2020-05-26 09:01:33 +00:00
|
|
|
impl serde::Serialize for UnwrappedIOValue {
|
2020-05-24 11:47:42 +00:00
|
|
|
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: serde::Serializer {
|
2020-05-26 09:01:33 +00:00
|
|
|
super::magic::output_value(serializer, self.clone().wrap())
|
2019-09-16 23:58:32 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-05-26 09:01:33 +00:00
|
|
|
impl<'de> serde::Deserialize<'de> for UnwrappedIOValue {
|
2019-09-16 23:58:32 +00:00
|
|
|
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: serde::Deserializer<'de> {
|
2020-05-26 09:01:33 +00:00
|
|
|
Ok(super::magic::input_value::<'de, D>(deserializer)?.value_owned())
|
2019-09-16 23:58:32 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-10-22 21:36:01 +00:00
|
|
|
pub fn serialize_nested_value<S, N, D: Domain>(v: &N, serializer: S) ->
|
2020-05-24 11:47:42 +00:00
|
|
|
Result<S::Ok, S::Error> where S: serde::Serializer, N: NestedValue<D> + serde::Serialize
|
2019-10-12 20:50:24 +00:00
|
|
|
{
|
2020-05-26 09:01:33 +00:00
|
|
|
super::magic::output_value(serializer, v.to_io_value())
|
2019-10-12 20:50:24 +00:00
|
|
|
}
|
|
|
|
|
2019-10-22 21:36:01 +00:00
|
|
|
pub fn deserialize_nested_value<'de, D, N, Dom: Domain>(deserializer: D) ->
|
2020-05-24 11:47:42 +00:00
|
|
|
Result<N, D::Error> where D: serde::Deserializer<'de>, N: NestedValue<Dom> + serde::Deserialize<'de>
|
2019-10-12 20:50:24 +00:00
|
|
|
{
|
2020-05-26 09:01:33 +00:00
|
|
|
Ok(N::from_io_value(&super::magic::input_value(deserializer)?))
|
2019-10-12 20:50:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
|
2020-06-17 00:39:01 +00:00
|
|
|
#[derive(Clone)]
|
|
|
|
pub struct Annotations<N: NestedValue<D>, D: Domain>(Option<Box<Vec<N>>>, PhantomData<D>);
|
|
|
|
|
|
|
|
impl<N: NestedValue<D>, D: Domain> Annotations<N, D> {
|
|
|
|
pub fn empty() -> Self {
|
|
|
|
Annotations(None,
|
|
|
|
PhantomData)
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn new(anns: Option<Vec<N>>) -> Self {
|
|
|
|
Annotations(anns.and_then(|v| if v.is_empty() { None } else { Some(Box::new(v)) }),
|
|
|
|
PhantomData)
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn maybe_slice(&self) -> Option<&[N]> {
|
|
|
|
match self.0 {
|
|
|
|
None => None,
|
|
|
|
Some(ref b) => Some(&&b[..]),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn slice(&self) -> &[N] {
|
|
|
|
self.maybe_slice().unwrap_or(&[])
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn modify<F>(&mut self, f: F) -> &mut Self
|
|
|
|
where
|
|
|
|
F: FnOnce(&mut Vec<N>)
|
|
|
|
{
|
|
|
|
let mut v: Vec<N> = self.0.take().map_or_else(|| vec![], |b| *b);
|
|
|
|
f(&mut v);
|
|
|
|
self.0 = if v.is_empty() { None } else { Some(Box::new(v)) };
|
|
|
|
self
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn copy_via<M: NestedValue<E>, E: Domain, F>(&self, f: &F) -> Annotations<M, E>
|
|
|
|
where
|
|
|
|
F: Fn(&D) -> Value<M, E>
|
|
|
|
{
|
|
|
|
match self.0 {
|
|
|
|
None =>
|
|
|
|
Annotations(None, PhantomData),
|
|
|
|
Some(ref b) =>
|
|
|
|
Annotations(Some(Box::new(b.iter().map(|a| a.copy_via(f)).collect())), PhantomData),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-01-06 16:42:02 +00:00
|
|
|
/// A possibly-annotated Value, with annotations (themselves
|
2019-10-12 20:50:24 +00:00
|
|
|
/// possibly-annotated) in order of appearance.
|
|
|
|
#[derive(Clone)]
|
2020-06-17 00:39:01 +00:00
|
|
|
pub struct AnnotatedValue<N: NestedValue<D>, D: Domain>(pub Annotations<N, D>, pub Value<N, D>);
|
|
|
|
|
|
|
|
impl<N: NestedValue<D>, D: Domain> AnnotatedValue<N, D> {
|
|
|
|
fn new(anns: Annotations<N, D>, value: Value<N, D>) -> Self {
|
|
|
|
AnnotatedValue(anns, value)
|
|
|
|
}
|
|
|
|
}
|
2019-10-12 20:50:24 +00:00
|
|
|
|
2019-10-22 21:36:01 +00:00
|
|
|
impl<N: NestedValue<D>, D: Domain> PartialEq for AnnotatedValue<N, D> {
|
2019-10-12 20:50:24 +00:00
|
|
|
fn eq(&self, other: &Self) -> bool {
|
|
|
|
self.1.eq(&other.1)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-10-22 21:36:01 +00:00
|
|
|
impl<N: NestedValue<D>, D: Domain> Eq for AnnotatedValue<N, D> {}
|
2019-10-12 20:50:24 +00:00
|
|
|
|
2019-10-22 21:36:01 +00:00
|
|
|
impl<N: NestedValue<D>, D: Domain> Hash for AnnotatedValue<N, D> {
|
2019-10-12 20:50:24 +00:00
|
|
|
fn hash<H: Hasher>(&self, state: &mut H) {
|
|
|
|
self.1.hash(state);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-10-22 21:36:01 +00:00
|
|
|
impl<N: NestedValue<D>, D: Domain> PartialOrd for AnnotatedValue<N, D> {
|
2019-10-12 20:50:24 +00:00
|
|
|
fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
|
|
|
|
Some(self.cmp(other))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-10-22 21:36:01 +00:00
|
|
|
impl<N: NestedValue<D>, D: Domain> Ord for AnnotatedValue<N, D> {
|
2019-10-12 20:50:24 +00:00
|
|
|
fn cmp(&self, other: &Self) -> Ordering {
|
|
|
|
self.1.cmp(&other.1)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
|
|
|
|
#[derive(Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
|
2019-10-22 21:36:01 +00:00
|
|
|
pub struct PlainValue<D: Domain>(AnnotatedValue<PlainValue<D>, D>);
|
2019-10-12 20:50:24 +00:00
|
|
|
|
2019-10-22 21:36:01 +00:00
|
|
|
impl<D: Domain> PlainValue<D> {
|
2020-06-17 00:39:01 +00:00
|
|
|
pub fn annotations_mut(&mut self) -> &mut Annotations<Self, D> {
|
2019-10-12 21:51:25 +00:00
|
|
|
&mut (self.0).0
|
|
|
|
}
|
|
|
|
|
2019-10-22 21:36:01 +00:00
|
|
|
pub fn value_mut(&mut self) -> &mut Value<Self, D> {
|
2019-10-12 21:51:25 +00:00
|
|
|
&mut (self.0).1
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-10-22 21:36:01 +00:00
|
|
|
impl<D: Domain> NestedValue<D> for PlainValue<D> {
|
2020-06-17 00:39:01 +00:00
|
|
|
fn wrap(anns: Annotations<Self, D>, v: Value<Self, D>) -> Self {
|
|
|
|
PlainValue(AnnotatedValue::new(anns, v))
|
2019-10-12 20:50:24 +00:00
|
|
|
}
|
|
|
|
|
2020-06-17 00:39:01 +00:00
|
|
|
fn annotations(&self) -> &Annotations<Self, D> {
|
2019-10-12 20:50:24 +00:00
|
|
|
&(self.0).0
|
|
|
|
}
|
|
|
|
|
2019-10-22 21:36:01 +00:00
|
|
|
fn value(&self) -> &Value<Self, D> {
|
2019-10-12 20:50:24 +00:00
|
|
|
&(self.0).1
|
|
|
|
}
|
|
|
|
|
2020-06-17 00:39:01 +00:00
|
|
|
fn pieces(self) -> (Annotations<Self, D>, Value<Self, D>) {
|
2020-05-27 07:04:55 +00:00
|
|
|
let AnnotatedValue(anns, v) = self.0;
|
|
|
|
(anns, v)
|
|
|
|
}
|
|
|
|
|
2019-10-22 21:36:01 +00:00
|
|
|
fn value_owned(self) -> Value<Self, D> {
|
2019-10-12 20:50:24 +00:00
|
|
|
(self.0).1
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-10-22 21:36:01 +00:00
|
|
|
impl<D: Domain> Debug for PlainValue<D> {
|
2019-10-12 20:50:24 +00:00
|
|
|
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
|
|
|
self.debug_fmt(f)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-10-22 21:36:01 +00:00
|
|
|
impl<D: Domain> serde::Serialize for PlainValue<D> {
|
2019-10-12 20:50:24 +00:00
|
|
|
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: serde::Serializer {
|
|
|
|
serialize_nested_value(self, serializer)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-10-22 21:36:01 +00:00
|
|
|
impl<'de, Dom: Domain> serde::Deserialize<'de> for PlainValue<Dom> {
|
2019-09-16 23:58:32 +00:00
|
|
|
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: serde::Deserializer<'de> {
|
2019-10-12 20:50:24 +00:00
|
|
|
deserialize_nested_value(deserializer)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
|
|
|
|
use std::rc::Rc;
|
|
|
|
|
2019-10-19 22:31:00 +00:00
|
|
|
#[derive(Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
|
2019-10-22 21:36:01 +00:00
|
|
|
pub struct RcValue<D: Domain>(Rc<AnnotatedValue<RcValue<D>, D>>);
|
2019-10-12 20:50:24 +00:00
|
|
|
|
2019-10-22 21:36:01 +00:00
|
|
|
impl<D: Domain> NestedValue<D> for RcValue<D> {
|
2020-06-17 00:39:01 +00:00
|
|
|
fn wrap(anns: Annotations<Self, D>, v: Value<Self, D>) -> Self {
|
|
|
|
RcValue(Rc::new(AnnotatedValue::new(anns, v)))
|
2019-10-12 20:50:24 +00:00
|
|
|
}
|
|
|
|
|
2020-06-17 00:39:01 +00:00
|
|
|
fn annotations(&self) -> &Annotations<Self, D> {
|
2019-10-12 20:50:24 +00:00
|
|
|
&(self.0).0
|
|
|
|
}
|
|
|
|
|
2019-10-22 21:36:01 +00:00
|
|
|
fn value(&self) -> &Value<Self, D> {
|
2019-10-12 20:50:24 +00:00
|
|
|
&(self.0).1
|
|
|
|
}
|
|
|
|
|
2020-06-17 00:39:01 +00:00
|
|
|
fn pieces(self) -> (Annotations<Self, D>, Value<Self, D>) {
|
2020-05-27 07:04:55 +00:00
|
|
|
match Rc::try_unwrap(self.0) {
|
|
|
|
Ok(AnnotatedValue(anns, v)) => (anns, v),
|
|
|
|
Err(r) => (r.0.clone(), r.1.clone()),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-10-22 21:36:01 +00:00
|
|
|
fn value_owned(self) -> Value<Self, D> {
|
2019-10-12 20:50:24 +00:00
|
|
|
Rc::try_unwrap(self.0).unwrap_or_else(|_| panic!("value_owned on RcValue with refcount greater than one")).1
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-10-22 21:36:01 +00:00
|
|
|
impl<D: Domain> Debug for RcValue<D> {
|
2019-10-12 20:50:24 +00:00
|
|
|
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
|
|
|
self.debug_fmt(f)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-10-22 21:36:01 +00:00
|
|
|
impl<D: Domain> serde::Serialize for RcValue<D> {
|
2019-10-12 20:50:24 +00:00
|
|
|
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: serde::Serializer {
|
|
|
|
serialize_nested_value(self, serializer)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-10-22 21:36:01 +00:00
|
|
|
impl<'de, Dom: Domain> serde::Deserialize<'de> for RcValue<Dom> {
|
2019-10-12 20:50:24 +00:00
|
|
|
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: serde::Deserializer<'de> {
|
|
|
|
deserialize_nested_value(deserializer)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
|
|
|
|
use std::sync::Arc;
|
|
|
|
|
2019-10-19 22:31:00 +00:00
|
|
|
#[derive(Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
|
2019-10-22 21:36:01 +00:00
|
|
|
pub struct ArcValue<D: Domain>(Arc<AnnotatedValue<ArcValue<D>, D>>);
|
2019-10-12 20:50:24 +00:00
|
|
|
|
2019-10-22 21:36:01 +00:00
|
|
|
impl<D: Domain> NestedValue<D> for ArcValue<D> {
|
2020-06-17 00:39:01 +00:00
|
|
|
fn wrap(anns: Annotations<Self, D>, v: Value<Self, D>) -> Self {
|
|
|
|
ArcValue(Arc::new(AnnotatedValue::new(anns, v)))
|
2019-10-12 20:50:24 +00:00
|
|
|
}
|
|
|
|
|
2020-06-17 00:39:01 +00:00
|
|
|
fn annotations(&self) -> &Annotations<Self, D> {
|
2019-10-12 20:50:24 +00:00
|
|
|
&(self.0).0
|
|
|
|
}
|
|
|
|
|
2019-10-22 21:36:01 +00:00
|
|
|
fn value(&self) -> &Value<Self, D> {
|
2019-10-12 20:50:24 +00:00
|
|
|
&(self.0).1
|
|
|
|
}
|
|
|
|
|
2020-06-17 00:39:01 +00:00
|
|
|
fn pieces(self) -> (Annotations<Self, D>, Value<Self, D>) {
|
2020-05-27 07:04:55 +00:00
|
|
|
match Arc::try_unwrap(self.0) {
|
|
|
|
Ok(AnnotatedValue(anns, v)) => (anns, v),
|
|
|
|
Err(r) => (r.0.clone(), r.1.clone()),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-10-22 21:36:01 +00:00
|
|
|
fn value_owned(self) -> Value<Self, D> {
|
2019-10-12 20:50:24 +00:00
|
|
|
Arc::try_unwrap(self.0).unwrap_or_else(|_| panic!("value_owned on ArcValue with refcount greater than one")).1
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-10-22 21:36:01 +00:00
|
|
|
impl<D: Domain> Debug for ArcValue<D> {
|
2019-10-12 20:50:24 +00:00
|
|
|
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
|
|
|
self.debug_fmt(f)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-10-22 21:36:01 +00:00
|
|
|
impl<D: Domain> serde::Serialize for ArcValue<D> {
|
2019-10-12 20:50:24 +00:00
|
|
|
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: serde::Serializer {
|
|
|
|
serialize_nested_value(self, serializer)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-10-22 21:36:01 +00:00
|
|
|
impl<'de, Dom: Domain> serde::Deserialize<'de> for ArcValue<Dom> {
|
2019-10-12 20:50:24 +00:00
|
|
|
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: serde::Deserializer<'de> {
|
|
|
|
deserialize_nested_value(deserializer)
|
2019-09-16 23:58:32 +00:00
|
|
|
}
|
|
|
|
}
|
2020-05-26 09:01:33 +00:00
|
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
|
|
|
|
#[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>;
|
|
|
|
|
2020-05-27 07:04:55 +00:00
|
|
|
lazy_static! {
|
2020-06-17 00:39:01 +00:00
|
|
|
pub static ref FALSE: IOValue = IOValue(Arc::new(AnnotatedValue(Annotations::empty(), Value::Boolean(false))));
|
|
|
|
pub static ref TRUE: IOValue = IOValue(Arc::new(AnnotatedValue(Annotations::empty(), Value::Boolean(true))));
|
|
|
|
pub static ref EMPTY_SEQ: IOValue = IOValue(Arc::new(AnnotatedValue(Annotations::empty(), Value::Sequence(Vec::new()))));
|
2020-05-27 07:04:55 +00:00
|
|
|
}
|
|
|
|
|
2020-05-26 09:01:33 +00:00
|
|
|
impl NestedValue<NullDomain> for IOValue {
|
2020-06-17 00:39:01 +00:00
|
|
|
fn wrap(anns: Annotations<Self, NullDomain>, v: Value<Self, NullDomain>) -> Self {
|
|
|
|
IOValue(Arc::new(AnnotatedValue::new(anns, v)))
|
2020-05-26 09:01:33 +00:00
|
|
|
}
|
|
|
|
|
2020-06-17 00:39:01 +00:00
|
|
|
fn annotations(&self) -> &Annotations<Self, NullDomain> {
|
2020-05-26 09:01:33 +00:00
|
|
|
&(self.0).0
|
|
|
|
}
|
|
|
|
|
|
|
|
fn value(&self) -> &Value<Self, NullDomain> {
|
|
|
|
&(self.0).1
|
|
|
|
}
|
|
|
|
|
2020-06-17 00:39:01 +00:00
|
|
|
fn pieces(self) -> (Annotations<Self, NullDomain>, Value<Self, NullDomain>) {
|
2020-05-27 07:04:55 +00:00
|
|
|
match Arc::try_unwrap(self.0) {
|
|
|
|
Ok(AnnotatedValue(anns, v)) => (anns, v),
|
|
|
|
Err(r) => (r.0.clone(), r.1.clone()),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-05-26 09:01:33 +00:00
|
|
|
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)
|
|
|
|
}
|
|
|
|
}
|