syndicate-lang
/
preserves
mirror of https://gitlab.com/preserves/preserves.git
1
0
Fork 1
Code Releases Activity

Rename Value -> ValueImpl

This commit is contained in:
Tony Garnock-Jones 2022-11-09 09:37:00 +01:00
parent 554812df0e
commit 8369d9c4f6
8 changed files with 116 additions and 116 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
implementations/rust/oo/benches/codec.rs
View File

@ -6,7 +6,7 @@ use oo::IOValueDomainCodec;
use oo::IOValues;
use oo::PackedWriter;
use oo::Reader;
use oo::Value;
use oo::ValueImpl;
use oo::packed::annotated_iovalue_from_bytes;
use std::fs::File;
use std::io::Read;

2
implementations/rust/oo/src/domain.rs
View File

@ -3,7 +3,7 @@ use std::io;
use super::IOValue;
use super::Reader;
use super::Writer;
use super::Value;
use super::ValueImpl;
pub trait Domain: std::fmt::Debug + Eq + std::hash::Hash + Ord + Clone {
type Decode: DomainDecode<Self> + Default;

6
implementations/rust/oo/src/lib.rs
View File

@ -33,7 +33,7 @@ pub use repr::NoValue;
pub use repr::Record;
pub use repr::Set;
pub use repr::Symbol;
pub use repr::Value;
pub use repr::ValueImpl;
pub use repr::copy_via;
pub use repr::iovalue;
pub use repr::owned;
@ -58,7 +58,7 @@ pub use writer::write_value;
mod demo {
use crate::*;
fn getit<'a>(d: &'a dyn Value<NoValue>, k: &str) -> Option<&'a dyn Value<NoValue>> {
fn getit<'a>(d: &'a dyn ValueImpl<NoValue>, k: &str) -> Option<&'a dyn ValueImpl<NoValue>> {
d.get(&k)
}
@ -74,7 +74,7 @@ mod demo {
v.insert(owned(vec![1, 2, 3]), "{a: 1, b: 2}".parse().unwrap());
v.insert(owned(r2), "bbb".parse().unwrap());
v.insert(owned(r), "<foo bar zot>".parse().unwrap());
let w: &dyn Value<NoValue> = &v;
let w: &dyn ValueImpl<NoValue> = &v;
println!("GETw abc {:?}", w.get(&"abc"));
println!("GETw 123 {:?}", w.get(&123));
println!("GETw qqq {:?}", w.get(&"qqq"));

4
implementations/rust/oo/src/packed/writer.rs
View File

@ -4,7 +4,7 @@ use std::convert::TryInto;
use std::io;
use std::io::Write;
use super::constants::Tag;
use crate::{boundary as B, Value, Domain, DomainEncode, IOValue, IOValueDomainCodec, Writer};
use crate::{boundary as B, ValueImpl, Domain, DomainEncode, IOValue, IOValueDomainCodec, Writer};
struct Buffers<W: io::Write> {
base: W,
@ -38,7 +38,7 @@ impl PackedWriter<&mut Vec<u8>> {
#[inline(always)]
pub fn encode<D: Domain, Enc: DomainEncode<D>>(
enc: &mut Enc,
v: &dyn Value<D>,
v: &dyn ValueImpl<D>,
) -> io::Result<Vec<u8>> {
let mut buf: Vec<u8> = Vec::new();
v.write(&mut PackedWriter::new(&mut buf), enc)?;

4
implementations/rust/oo/src/reader.rs
View File

@ -20,7 +20,7 @@ use crate::repr::IOValue;
use crate::repr::Map;
use crate::repr::Record;
use crate::repr::Set;
use crate::repr::Value;
use crate::repr::ValueImpl;
use crate::repr::owned;
pub type ReaderResult<T> = std::result::Result<T, Error>;
@ -146,7 +146,7 @@ pub trait Reader<'de> {
&mut self,
read_annotations: bool,
dec: &mut Dec,
) -> io::Result<Box<dyn Value<D>>>
) -> io::Result<Box<dyn ValueImpl<D>>>
{
let (anns, v) = match read_annotations {
true => self.gather_annotations()?.ok_or_else(io_eof)?,

204
implementations/rust/oo/src/repr.rs
View File

@ -25,10 +25,10 @@ use crate::domain::{NoEmbeddedDomainCodec, DomainEncode, IOValueDomainCodec};
use super::float::{eq_f32, eq_f64, cmp_f32, cmp_f64};
pub type PlainValue<'a, D = IOValue> = Box<dyn Value<D> + 'a>;
pub type PlainValue<'a, D = IOValue> = Box<dyn ValueImpl<D> + 'a>;
/// Atomic values from the specification.
pub trait Value<D: Domain> {
pub trait ValueImpl<D: Domain> {
fn write(&self, w: &mut dyn Writer, enc: &mut dyn DomainEncode<D>) -> io::Result<()> {
write_value(w, self, enc)
}
@ -48,19 +48,19 @@ pub trait Value<D: Domain> {
fn as_symbol(&self) -> Option<Cow<'_, str>> { None }
fn is_record(&self) -> bool { false }
fn label(&self) -> &dyn Value<D> { panic!("Not a record") }
fn label(&self) -> &dyn ValueImpl<D> { panic!("Not a record") }
fn is_sequence(&self) -> bool { false }
fn len(&self) -> usize { panic!("Has no length") }
fn index(&self, _i: usize) -> &dyn Value<D> { panic!("Not indexable") }
fn iter(&self) -> Box<dyn Iterator<Item = &dyn Value<D>> + '_> { panic!("Not iterable") }
fn index(&self, _i: usize) -> &dyn ValueImpl<D> { panic!("Not indexable") }
fn iter(&self) -> Box<dyn Iterator<Item = &dyn ValueImpl<D>> + '_> { panic!("Not iterable") }
fn is_set(&self) -> bool { false }
fn has(&self, _v: &dyn Value<D>) -> bool { false }
fn has(&self, _v: &dyn ValueImpl<D>) -> bool { false }
fn is_dictionary(&self) -> bool { false }
fn get(&self, _k: &dyn Value<D>) -> Option<&dyn Value<D>> { None }
fn entries(&self) -> Box<dyn Iterator<Item = (&dyn Value<D>, &dyn Value<D>)> + '_> { panic!("Not a dictionary") }
fn get(&self, _k: &dyn ValueImpl<D>) -> Option<&dyn ValueImpl<D>> { None }
fn entries(&self) -> Box<dyn Iterator<Item = (&dyn ValueImpl<D>, &dyn ValueImpl<D>)> + '_> { panic!("Not a dictionary") }
fn is_embedded(&self) -> bool { false }
fn embedded(&self) -> Cow<'_, D> { panic!("Not an embedded value") }
@ -70,24 +70,24 @@ pub trait Value<D: Domain> {
fn specialized(&self) -> Option<&dyn Any> { None }
}
pub fn value<D: Domain, V: Value<D>>(v: &V) -> &dyn Value<D> {
pub fn value<D: Domain, V: ValueImpl<D>>(v: &V) -> &dyn ValueImpl<D> {
v
}
pub fn owned<D: Domain, V: Value<D> + 'static>(v: V) -> PlainValue<'static, D> {
pub fn owned<D: Domain, V: ValueImpl<D> + 'static>(v: V) -> PlainValue<'static, D> {
Box::new(v)
}
pub fn arcvalue<D: Domain, V: Value<D> + 'static>(v: V) -> ArcValue<D> {
pub fn arcvalue<D: Domain, V: ValueImpl<D> + 'static>(v: V) -> ArcValue<D> {
ArcValue(Arc::new(v))
}
pub fn iovalue<V: Value<IOValue> + 'static>(v: V) -> IOValue {
pub fn iovalue<V: ValueImpl<IOValue> + 'static>(v: V) -> IOValue {
IOValue(arcvalue(v))
}
pub fn copy_via<D: Domain, E: Domain + 'static, F, Err>(
v: &dyn Value<D>,
v: &dyn ValueImpl<D>,
f: &mut F,
) -> Result<PlainValue<'static, E>, Err>
where
@ -120,13 +120,13 @@ where
}
}
impl<'a, D: Domain + 'static> From<&'a dyn Value<D>> for PlainValue<'static, D> {
fn from(v: &'a dyn Value<D>) -> Self {
impl<'a, D: Domain + 'static> From<&'a dyn ValueImpl<D>> for PlainValue<'static, D> {
fn from(v: &'a dyn ValueImpl<D>) -> Self {
v.value_clone()
}
}
impl<'a, D: Domain, V: Value<D> + ?Sized> Value<D> for &'a V {
impl<'a, D: Domain, V: ValueImpl<D> + ?Sized> ValueImpl<D> for &'a V {
fn write(&self, w: &mut dyn Writer, enc: &mut dyn DomainEncode<D>) -> io::Result<()> { (*self).write(w, enc) }
fn value_clone(&self) -> PlainValue<'static, D> where D: 'static { (*self).value_clone() }
fn value_class(&self) -> ValueClass { (*self).value_class() }
@ -139,22 +139,22 @@ impl<'a, D: Domain, V: Value<D> + ?Sized> Value<D> for &'a V {
fn as_bytestring(&self) -> Option<Cow<'_, [u8]>> { (*self).as_bytestring() }
fn as_symbol(&self) -> Option<Cow<'_, str>> { (*self).as_symbol() }
fn is_record(&self) -> bool { (*self).is_record() }
fn label(&self) -> &dyn Value<D> { (*self).label() }
fn label(&self) -> &dyn ValueImpl<D> { (*self).label() }
fn is_sequence(&self) -> bool { (*self).is_sequence() }
fn len(&self) -> usize { (*self).len() }
fn index(&self, i: usize) -> &dyn Value<D> { (*self).index(i) }
fn iter(&self) -> Box<dyn Iterator<Item = &dyn Value<D>> + '_> { (*self).iter() }
fn index(&self, i: usize) -> &dyn ValueImpl<D> { (*self).index(i) }
fn iter(&self) -> Box<dyn Iterator<Item = &dyn ValueImpl<D>> + '_> { (*self).iter() }
fn is_set(&self) -> bool { (*self).is_set() }
fn has(&self, v: &dyn Value<D>) -> bool { (*self).has(v) }
fn has(&self, v: &dyn ValueImpl<D>) -> bool { (*self).has(v) }
fn is_dictionary(&self) -> bool { (*self).is_dictionary() }
fn get<'value>(&'value self, k: &dyn Value<D>) -> Option<&'value dyn Value<D>> { (*self).get(k) }
fn entries(&self) -> Box<dyn Iterator<Item = (&dyn Value<D>, &dyn Value<D>)> + '_> { (*self).entries() }
fn get<'value>(&'value self, k: &dyn ValueImpl<D>) -> Option<&'value dyn ValueImpl<D>> { (*self).get(k) }
fn entries(&self) -> Box<dyn Iterator<Item = (&dyn ValueImpl<D>, &dyn ValueImpl<D>)> + '_> { (*self).entries() }
fn is_embedded(&self) -> bool { (*self).is_embedded() }
fn embedded(&self) -> Cow<'_, D> { (*self).embedded() }
fn annotations(&self) -> Option<&[IOValue]> { (*self).annotations() }
}
impl<'a, D: Domain> Value<D> for PlainValue<'a, D> {
impl<'a, D: Domain> ValueImpl<D> for PlainValue<'a, D> {
fn write(&self, w: &mut dyn Writer, enc: &mut dyn DomainEncode<D>) -> io::Result<()> { self.as_ref().write(w, enc) }
fn value_clone(&self) -> PlainValue<'static, D> where D: 'static { self.as_ref().value_clone() }
fn value_class(&self) -> ValueClass { self.as_ref().value_class() }
@ -167,22 +167,22 @@ impl<'a, D: Domain> Value<D> for PlainValue<'a, D> {
fn as_bytestring(&self) -> Option<Cow<'_, [u8]>> { self.as_ref().as_bytestring() }
fn as_symbol(&self) -> Option<Cow<'_, str>> { self.as_ref().as_symbol() }
fn is_record(&self) -> bool { self.as_ref().is_record() }
fn label(&self) -> &dyn Value<D> { self.as_ref().label() }
fn label(&self) -> &dyn ValueImpl<D> { self.as_ref().label() }
fn is_sequence(&self) -> bool { self.as_ref().is_sequence() }
fn len(&self) -> usize { self.as_ref().len() }
fn index(&self, i: usize) -> &dyn Value<D> { self.as_ref().index(i) }
fn iter(&self) -> Box<dyn Iterator<Item = &dyn Value<D>> + '_> { self.as_ref().iter() }
fn index(&self, i: usize) -> &dyn ValueImpl<D> { self.as_ref().index(i) }
fn iter(&self) -> Box<dyn Iterator<Item = &dyn ValueImpl<D>> + '_> { self.as_ref().iter() }
fn is_set(&self) -> bool { self.as_ref().is_set() }
fn has(&self, v: &dyn Value<D>) -> bool { self.as_ref().has(v) }
fn has(&self, v: &dyn ValueImpl<D>) -> bool { self.as_ref().has(v) }
fn is_dictionary(&self) -> bool { self.as_ref().is_dictionary() }
fn get<'value>(&'value self, k: &dyn Value<D>) -> Option<&'value dyn Value<D>> { self.as_ref().get(k) }
fn entries(&self) -> Box<dyn Iterator<Item = (&dyn Value<D>, &dyn Value<D>)> + '_> { self.as_ref().entries() }
fn get<'value>(&'value self, k: &dyn ValueImpl<D>) -> Option<&'value dyn ValueImpl<D>> { self.as_ref().get(k) }
fn entries(&self) -> Box<dyn Iterator<Item = (&dyn ValueImpl<D>, &dyn ValueImpl<D>)> + '_> { self.as_ref().entries() }
fn is_embedded(&self) -> bool { self.as_ref().is_embedded() }
fn embedded(&self) -> Cow<'_, D> { self.as_ref().embedded() }
fn annotations(&self) -> Option<&[IOValue]> { self.as_ref().annotations() }
}
impl<'a, D: Domain> Debug for dyn Value<D> + 'a {
impl<'a, D: Domain> Debug for dyn ValueImpl<D> + 'a {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
TextWriter::fmt_value(f, &mut DefaultDomainCodec, self).map_err(|_| std::fmt::Error)
}
@ -196,7 +196,7 @@ impl<'a, Err: Into<io::Error>, D: Domain + FromStr<Err = Err> + 'static> FromStr
}
}
impl<'a, D: Domain> Hash for dyn Value<D> + 'a {
impl<'a, D: Domain> Hash for dyn ValueImpl<D> + 'a {
fn hash<H: Hasher>(&self, state: &mut H) {
match self.value_class() {
ValueClass::Atomic(a) => match a {
@ -233,8 +233,8 @@ impl<'a, D: Domain> Hash for dyn Value<D> + 'a {
}
fn iters_eq<'a, D: Domain>(
mut i1: Box<dyn Iterator<Item = &dyn Value<D>> + 'a>,
mut i2: Box<dyn Iterator<Item = &dyn Value<D>> + 'a>,
mut i1: Box<dyn Iterator<Item = &dyn ValueImpl<D>> + 'a>,
mut i2: Box<dyn Iterator<Item = &dyn ValueImpl<D>> + 'a>,
) -> bool {
loop {
match i1.next() {
@ -247,7 +247,7 @@ fn iters_eq<'a, D: Domain>(
}
}
impl<'a, D: Domain> PartialEq for dyn Value<D> + 'a {
impl<'a, D: Domain> PartialEq for dyn ValueImpl<D> + 'a {
fn eq(&self, other: &Self) -> bool {
let cls = self.value_class();
if cls != other.value_class() { return false; }
@ -293,8 +293,8 @@ impl<'a, D: Domain> PartialEq for dyn Value<D> + 'a {
}
fn iters_cmp<'a, D: Domain>(
mut i1: Box<dyn Iterator<Item = &dyn Value<D>> + 'a>,
mut i2: Box<dyn Iterator<Item = &dyn Value<D>> + 'a>,
mut i1: Box<dyn Iterator<Item = &dyn ValueImpl<D>> + 'a>,
mut i2: Box<dyn Iterator<Item = &dyn ValueImpl<D>> + 'a>,
) -> Ordering {
loop {
match i1.next() {
@ -313,7 +313,7 @@ fn iters_cmp<'a, D: Domain>(
}
}
impl<'a, D: Domain> Ord for dyn Value<D> + 'a {
impl<'a, D: Domain> Ord for dyn ValueImpl<D> + 'a {
fn cmp(&self, other: &Self) -> Ordering {
let cls = self.value_class();
cls.cmp(&other.value_class()).then_with(|| match cls {
@ -354,9 +354,9 @@ impl<'a, D: Domain> Ord for dyn Value<D> + 'a {
}
}
impl<'a, D: Domain> Eq for dyn Value<D> + 'a {}
impl<'a, D: Domain> Eq for dyn ValueImpl<D> + 'a {}
impl<'a, D: Domain> PartialOrd for dyn Value<D> + 'a {
impl<'a, D: Domain> PartialOrd for dyn ValueImpl<D> + 'a {
fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
Some(self.cmp(other))
}
@ -401,7 +401,7 @@ impl<'r, 'a> From<&'r Atom<'a>> for AtomClass {
}
}
impl<'a, D: Domain> Value<D> for Atom<'a> {
impl<'a, D: Domain> ValueImpl<D> for Atom<'a> {
fn write(&self, w: &mut dyn Writer, _enc: &mut dyn DomainEncode<D>) -> io::Result<()> {
match self {
Atom::Boolean(b) => w.write_bool(*b),
@ -468,20 +468,20 @@ impl FromStr for NoValue {
}
}
impl<D: Domain> Value<D> for NoValue {
impl<D: Domain> ValueImpl<D> for NoValue {
fn write(&self, _w: &mut dyn Writer, _enc: &mut dyn DomainEncode<D>) -> io::Result<()> { unreachable!() }
fn value_clone(&self) -> PlainValue<'static, D> where D: 'static { unreachable!() }
fn value_class(&self) -> ValueClass { unreachable!() }
}
impl<D: Domain> Value<D> for bool {
impl<D: Domain> ValueImpl<D> for bool {
fn write(&self, w: &mut dyn Writer, __enc: &mut dyn DomainEncode<D>) -> io::Result<()> { w.write_bool(*self) }
fn value_clone(&self) -> PlainValue<'static, D> where D: 'static { Box::new(*self) }
fn value_class(&self) -> ValueClass { ValueClass::Atomic(AtomClass::Boolean) }
fn as_boolean(&self) -> Option<bool> { Some(*self) }
}
impl<D: Domain> Value<D> for u64 {
impl<D: Domain> ValueImpl<D> for u64 {
fn write(&self, w: &mut dyn Writer, _enc: &mut dyn DomainEncode<D>) -> io::Result<()> { w.write_u64(*self) }
fn value_clone(&self) -> PlainValue<'static, D> where D: 'static { Box::new(*self) }
fn value_class(&self) -> ValueClass { ValueClass::Atomic(AtomClass::SignedInteger) }
@ -490,7 +490,7 @@ impl<D: Domain> Value<D> for u64 {
}
}
impl<D: Domain> Value<D> for SignedInteger {
impl<D: Domain> ValueImpl<D> for SignedInteger {
fn write(&self, w: &mut dyn Writer, _enc: &mut dyn DomainEncode<D>) -> io::Result<()> { w.write_signed_integer(self) }
fn value_clone(&self) -> PlainValue<'static, D> where D: 'static { Box::new(self.clone()) }
fn value_class(&self) -> ValueClass { ValueClass::Atomic(AtomClass::SignedInteger) }
@ -499,7 +499,7 @@ impl<D: Domain> Value<D> for SignedInteger {
}
}
impl<D: Domain> Value<D> for f32 {
impl<D: Domain> ValueImpl<D> for f32 {
fn write(&self, w: &mut dyn Writer, _enc: &mut dyn DomainEncode<D>) -> io::Result<()> { w.write_f32(*self) }
fn value_clone(&self) -> PlainValue<'static, D> where D: 'static { Box::new(*self) }
fn value_class(&self) -> ValueClass { ValueClass::Atomic(AtomClass::Float) }
@ -507,7 +507,7 @@ impl<D: Domain> Value<D> for f32 {
fn as_double(&self) -> Option<f64> { Some(*self as f64) }
}
impl<D: Domain> Value<D> for f64 {
impl<D: Domain> ValueImpl<D> for f64 {
fn write(&self, w: &mut dyn Writer, _enc: &mut dyn DomainEncode<D>) -> io::Result<()> { w.write_f64(*self) }
fn value_clone(&self) -> PlainValue<'static, D> where D: 'static { Box::new(*self) }
fn value_class(&self) -> ValueClass { ValueClass::Atomic(AtomClass::Float) }
@ -515,14 +515,14 @@ impl<D: Domain> Value<D> for f64 {
fn as_double(&self) -> Option<f64> { Some(*self) }
}
impl<D: Domain> Value<D> for str {
impl<D: Domain> ValueImpl<D> for str {
fn write(&self, w: &mut dyn Writer, _enc: &mut dyn DomainEncode<D>) -> io::Result<()> { w.write_string(self) }
fn value_clone(&self) -> PlainValue<'static, D> where D: 'static { Box::new(self.to_owned()) }
fn value_class(&self) -> ValueClass { ValueClass::Atomic(AtomClass::String) }
fn as_string(&self) -> Option<Cow<'_, str>> { Some(Cow::Borrowed(self)) }
}
impl<D: Domain> Value<D> for String {
impl<D: Domain> ValueImpl<D> for String {
fn write(&self, w: &mut dyn Writer, _enc: &mut dyn DomainEncode<D>) -> io::Result<()> { w.write_string(self) }
fn value_clone(&self) -> PlainValue<'static, D> where D: 'static { Box::new(self.clone()) }
fn value_class(&self) -> ValueClass { ValueClass::Atomic(AtomClass::String) }
@ -539,7 +539,7 @@ impl<T: AsRef<[u8]> + Debug> Bytes<T> {
}
}
impl<T: AsRef<[u8]> + Debug, D: Domain> Value<D> for Bytes<T> {
impl<T: AsRef<[u8]> + Debug, D: Domain> ValueImpl<D> for Bytes<T> {
fn write(&self, w: &mut dyn Writer, _enc: &mut dyn DomainEncode<D>) -> io::Result<()> { w.write_bytes(self.0.as_ref()) }
fn value_clone(&self) -> PlainValue<'static, D> where D: 'static { Box::new(Bytes(self.0.as_ref().to_owned())) }
fn value_class(&self) -> ValueClass { ValueClass::Atomic(AtomClass::ByteString) }
@ -556,7 +556,7 @@ impl<T: AsRef<str> + Debug> Symbol<T> {
}
}
impl<T: AsRef<str> + Debug, D: Domain> Value<D> for Symbol<T> {
impl<T: AsRef<str> + Debug, D: Domain> ValueImpl<D> for Symbol<T> {
fn write(&self, w: &mut dyn Writer, _enc: &mut dyn DomainEncode<D>) -> io::Result<()> { w.write_symbol(self.0.as_ref()) }
fn value_clone(&self) -> PlainValue<'static, D> where D: 'static { Box::new(Symbol(self.0.as_ref().to_owned())) }
fn value_class(&self) -> ValueClass { ValueClass::Atomic(AtomClass::Symbol) }
@ -583,7 +583,7 @@ impl<V> Record<V> {
}
}
impl<D: Domain, V: Value<D>> Value<D> for Record<V> {
impl<D: Domain, V: ValueImpl<D>> ValueImpl<D> for Record<V> {
fn write(&self, w: &mut dyn Writer, enc: &mut dyn DomainEncode<D>) -> io::Result<()> {
w.start_record()?;
let mut b = B::start(B::Item::RecordLabel);
@ -605,15 +605,15 @@ impl<D: Domain, V: Value<D>> Value<D> for Record<V> {
fn value_class(&self) -> ValueClass { ValueClass::Compound(CompoundClass::Record) }
fn is_record(&self) -> bool { true }
fn label(&self) -> &dyn Value<D> { &self.0[0] }
fn label(&self) -> &dyn ValueImpl<D> { &self.0[0] }
fn len(&self) -> usize { self.0.len() - 1 }
fn index(&self, i: usize) -> &dyn Value<D> { &self.0[i + 1] }
fn iter(&self) -> Box<dyn Iterator<Item = &dyn Value<D>> + '_> {
fn index(&self, i: usize) -> &dyn ValueImpl<D> { &self.0[i + 1] }
fn iter(&self) -> Box<dyn Iterator<Item = &dyn ValueImpl<D>> + '_> {
Box::new(self.0[1..].iter().map(value))
}
}
impl<D: Domain, V: Value<D>> Value<D> for Vec<V> {
impl<D: Domain, V: ValueImpl<D>> ValueImpl<D> for Vec<V> {
fn write(&self, w: &mut dyn Writer, enc: &mut dyn DomainEncode<D>) -> io::Result<()> {
(&self[..]).write(w, enc)
}
@ -625,13 +625,13 @@ impl<D: Domain, V: Value<D>> Value<D> for Vec<V> {
fn value_class(&self) -> ValueClass { ValueClass::Compound(CompoundClass::Sequence) }
fn is_sequence(&self) -> bool { true }
fn len(&self) -> usize { self.len() }
fn index(&self, i: usize) -> &dyn Value<D> { &self[i] }
fn iter(&self) -> Box<dyn Iterator<Item = &dyn Value<D>> + '_> {
fn index(&self, i: usize) -> &dyn ValueImpl<D> { &self[i] }
fn iter(&self) -> Box<dyn Iterator<Item = &dyn ValueImpl<D>> + '_> {
Box::new(self[..].iter().map(value))
}
}
impl<D: Domain, V: Value<D>> Value<D> for [V] {
impl<D: Domain, V: ValueImpl<D>> ValueImpl<D> for [V] {
fn write(&self, w: &mut dyn Writer, enc: &mut dyn DomainEncode<D>) -> io::Result<()> {
w.start_sequence()?;
let mut b = B::Type::default();
@ -652,13 +652,13 @@ impl<D: Domain, V: Value<D>> Value<D> for [V] {
fn value_class(&self) -> ValueClass { ValueClass::Compound(CompoundClass::Sequence) }
fn is_sequence(&self) -> bool { true }
fn len(&self) -> usize { self.len() }
fn index(&self, i: usize) -> &dyn Value<D> { &self[i] }
fn iter(&self) -> Box<dyn Iterator<Item = &dyn Value<D>> + '_> {
fn index(&self, i: usize) -> &dyn ValueImpl<D> { &self[i] }
fn iter(&self) -> Box<dyn Iterator<Item = &dyn ValueImpl<D>> + '_> {
Box::new(self[..].iter().map(value))
}
}
impl<'e, D: Domain, E: for<'a> Borrow<Key<'a, D>> + Ord + 'e> Value<D> for Set<E> {
impl<'e, D: Domain, E: for<'a> Borrow<Key<'a, D>> + Ord + 'e> ValueImpl<D> for Set<E> {
fn write(&self, w: &mut dyn Writer, enc: &mut dyn DomainEncode<D>) -> io::Result<()> {
w.start_set()?;
let mut b = B::Type::default();
@ -679,8 +679,8 @@ impl<'e, D: Domain, E: for<'a> Borrow<Key<'a, D>> + Ord + 'e> Value<D> for Set<E
fn value_class(&self) -> ValueClass { ValueClass::Compound(CompoundClass::Set) }
fn is_set(&self) -> bool { true }
fn len(&self) -> usize { self.len() }
fn has(&self, v: &dyn Value<D>) -> bool { self.contains(&Key::wrap_ref(v)) }
fn iter(&self) -> Box<dyn Iterator<Item = &dyn Value<D>> + '_> {
fn has(&self, v: &dyn ValueImpl<D>) -> bool { self.contains(&Key::wrap_ref(v)) }
fn iter(&self) -> Box<dyn Iterator<Item = &dyn ValueImpl<D>> + '_> {
Box::new(self.iter().map(|e| Key::peel_ref(&e.borrow())))
}
}
@ -691,8 +691,8 @@ impl<'e, D: Domain, E: for<'a> Borrow<Key<'a, D>> + Ord + 'e> Value<D> for Set<E
//
#[derive(PartialEq, Eq, PartialOrd, Ord)]
#[repr(transparent)]
pub struct Key<'a, D: Domain>(pub dyn Value<D> + 'a);
unsafe impl<'a, D: Domain> TransparentWrapper<dyn Value<D> + 'a> for Key<'a, D> {}
pub struct Key<'a, D: Domain>(pub dyn ValueImpl<D> + 'a);
unsafe impl<'a, D: Domain> TransparentWrapper<dyn ValueImpl<D> + 'a> for Key<'a, D> {}
impl<'a, 'b: 'a, D: Domain> Borrow<Key<'a, D>> for PlainValue<'b, D> {
fn borrow(&self) -> &Key<'a, D> {
@ -700,13 +700,13 @@ impl<'a, 'b: 'a, D: Domain> Borrow<Key<'a, D>> for PlainValue<'b, D> {
}
}
impl<'a, 'b: 'a, D: Domain> Borrow<Key<'a, D>> for &'b (dyn Value<D> + 'b) {
impl<'a, 'b: 'a, D: Domain> Borrow<Key<'a, D>> for &'b (dyn ValueImpl<D> + 'b) {
fn borrow(&self) -> &Key<'a, D> {
Key::wrap_ref(self)
}
}
impl<'k, D: Domain, V: Value<D>, K: for<'a> Borrow<Key<'a, D>> + Ord + 'k> Value<D>
impl<'k, D: Domain, V: ValueImpl<D>, K: for<'a> Borrow<Key<'a, D>> + Ord + 'k> ValueImpl<D>
for Map<K, V>
{
fn write(&self, w: &mut dyn Writer, enc: &mut dyn DomainEncode<D>) -> io::Result<()> {
@ -726,20 +726,20 @@ impl<'k, D: Domain, V: Value<D>, K: for<'a> Borrow<Key<'a, D>> + Ord + 'k> Value
}
fn value_clone(&self) -> PlainValue<'static, D> where D: 'static {
Box::new(Value::entries(self).map(|(k, v)| (k.value_clone(), v.value_clone())).collect::<Map<_, _>>())
Box::new(ValueImpl::entries(self).map(|(k, v)| (k.value_clone(), v.value_clone())).collect::<Map<_, _>>())
}
fn value_class(&self) -> ValueClass { ValueClass::Compound(CompoundClass::Dictionary) }
fn is_dictionary(&self) -> bool { true }
fn len(&self) -> usize { self.len() }
fn has(&self, v: &dyn Value<D>) -> bool { self.contains_key(&Key::wrap_ref(v)) }
fn get(&self, k: &dyn Value<D>) -> Option<&dyn Value<D>> {
fn has(&self, v: &dyn ValueImpl<D>) -> bool { self.contains_key(&Key::wrap_ref(v)) }
fn get(&self, k: &dyn ValueImpl<D>) -> Option<&dyn ValueImpl<D>> {
match Map::get(self, &Key::wrap_ref(k)) {
Some(v) => Some(v),
None => None,
}
}
fn entries(&self) -> Box<dyn Iterator<Item = (&dyn Value<D>, &dyn Value<D>)> + '_> {
fn entries(&self) -> Box<dyn Iterator<Item = (&dyn ValueImpl<D>, &dyn ValueImpl<D>)> + '_> {
Box::new(self.iter().map(|(k,v)| (Key::peel_ref(&k.borrow()), value(v))))
}
}
@ -762,7 +762,7 @@ impl<D: Domain> Embedded<D> {
}
}
impl<D: Domain> Value<D> for Embedded<D> {
impl<D: Domain> ValueImpl<D> for Embedded<D> {
fn write(&self, w: &mut dyn Writer, enc: &mut dyn DomainEncode<D>) -> io::Result<()> {
w.start_embedded()?;
enc.encode_embedded(w, &self.0)?;
@ -776,19 +776,19 @@ impl<D: Domain> Value<D> for Embedded<D> {
}
#[derive(Debug)]
pub struct Annotations<D: Domain, V: Value<D>>(V, Vec<IOValue>, PhantomData<D>);
pub struct Annotations<D: Domain, V: ValueImpl<D>>(V, Vec<IOValue>, PhantomData<D>);
impl<D: Domain, V: Value<D>> Annotations<D, V> {
impl<D: Domain, V: ValueImpl<D>> Annotations<D, V> {
pub fn new(value: V, anns: Vec<IOValue>) -> Self {
Annotations(value, anns, PhantomData)
}
pub fn value(&self) -> &dyn Value<D> {
pub fn value(&self) -> &dyn ValueImpl<D> {
&self.0
}
}
impl<D: Domain, V: Value<D>> Value<D> for Annotations<D, V> {
impl<D: Domain, V: ValueImpl<D>> ValueImpl<D> for Annotations<D, V> {
fn write(&self, w: &mut dyn Writer, enc: &mut dyn DomainEncode<D>) -> io::Result<()> {
if !self.1.is_empty() {
w.start_annotations()?;
@ -825,42 +825,42 @@ impl<D: Domain, V: Value<D>> Value<D> for Annotations<D, V> {
fn as_bytestring(&self) -> Option<Cow<'_, [u8]>> { self.value().as_bytestring() }
fn as_symbol(&self) -> Option<Cow<'_, str>> { self.value().as_symbol() }
fn is_record(&self) -> bool { self.value().is_record() }
fn label(&self) -> &dyn Value<D> { self.value().label() }
fn label(&self) -> &dyn ValueImpl<D> { self.value().label() }
fn is_sequence(&self) -> bool { self.value().is_sequence() }
fn len(&self) -> usize { self.value().len() }
fn index(&self, i: usize) -> &dyn Value<D> { self.value().index(i) }
fn iter(&self) -> Box<dyn Iterator<Item = &dyn Value<D>> + '_> { self.value().iter() }
fn index(&self, i: usize) -> &dyn ValueImpl<D> { self.value().index(i) }
fn iter(&self) -> Box<dyn Iterator<Item = &dyn ValueImpl<D>> + '_> { self.value().iter() }
fn is_set(&self) -> bool { self.value().is_set() }
fn has(&self, v: &dyn Value<D>) -> bool { self.value().has(v) }
fn has(&self, v: &dyn ValueImpl<D>) -> bool { self.value().has(v) }
fn is_dictionary(&self) -> bool { self.value().is_dictionary() }
fn get(&self, k: &dyn Value<D>) -> Option<&dyn Value<D>> { self.value().get(k) }
fn entries(&self) -> Box<dyn Iterator<Item = (&dyn Value<D>, &dyn Value<D>)> + '_> { self.value().entries() }
fn get(&self, k: &dyn ValueImpl<D>) -> Option<&dyn ValueImpl<D>> { self.value().get(k) }
fn entries(&self) -> Box<dyn Iterator<Item = (&dyn ValueImpl<D>, &dyn ValueImpl<D>)> + '_> { self.value().entries() }
fn is_embedded(&self) -> bool { self.value().is_embedded() }
fn embedded(&self) -> Cow<'_, D> { self.value().embedded() }
fn annotations(&self) -> Option<&[IOValue]> { Some(&self.1) }
}
impl<D: Domain, V: Value<D>> PartialEq for Annotations<D, V> {
impl<D: Domain, V: ValueImpl<D>> PartialEq for Annotations<D, V> {
fn eq(&self, other: &Self) -> bool {
self.value().eq(&other.value())
}
}
impl<D: Domain, V: Value<D>> Eq for Annotations<D, V> {}
impl<D: Domain, V: ValueImpl<D>> Eq for Annotations<D, V> {}
impl<D: Domain, V: Value<D>> Hash for Annotations<D, V> {
impl<D: Domain, V: ValueImpl<D>> Hash for Annotations<D, V> {
fn hash<H: Hasher>(&self, state: &mut H) {
self.value().hash(state);
}
}
impl<D: Domain, V: Value<D>> PartialOrd for Annotations<D, V> {
impl<D: Domain, V: ValueImpl<D>> PartialOrd for Annotations<D, V> {
fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
Some(self.cmp(other))
}
}
impl<D: Domain, V: Value<D>> Ord for Annotations<D, V> {
impl<D: Domain, V: ValueImpl<D>> Ord for Annotations<D, V> {
fn cmp(&self, other: &Self) -> Ordering {
self.value().cmp(&other.value())
}
@ -868,7 +868,7 @@ impl<D: Domain, V: Value<D>> Ord for Annotations<D, V> {
#[derive(Clone, Eq, Hash, PartialOrd, Ord)]
#[repr(transparent)]
pub struct ArcValue<D: Domain + 'static = IOValue>(Arc<dyn Value<D>>);
pub struct ArcValue<D: Domain + 'static = IOValue>(Arc<dyn ValueImpl<D>>);
#[derive(Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
#[repr(transparent)]
@ -938,7 +938,7 @@ impl<'a, D: Domain> Borrow<Key<'a, D>> for ArcValue<D> {
}
}
impl<D: Domain> Value<D> for ArcValue<D> {
impl<D: Domain> ValueImpl<D> for ArcValue<D> {
fn write(&self, w: &mut dyn Writer, enc: &mut dyn DomainEncode<D>) -> io::Result<()> { self.0.write(w, enc) }
fn value_clone(&self) -> PlainValue<'static, D> { Box::new(self.clone()) }
fn value_class(&self) -> ValueClass { self.0.value_class() }
@ -951,22 +951,22 @@ impl<D: Domain> Value<D> for ArcValue<D> {
fn as_bytestring(&self) -> Option<Cow<'_, [u8]>> { self.0.as_bytestring() }
fn as_symbol(&self) -> Option<Cow<'_, str>> { self.0.as_symbol() }
fn is_record(&self) -> bool { self.0.is_record() }
fn label(&self) -> &dyn Value<D> { self.0.label() }
fn label(&self) -> &dyn ValueImpl<D> { self.0.label() }
fn is_sequence(&self) -> bool { self.0.is_sequence() }
fn len(&self) -> usize { self.0.len() }
fn index(&self, i: usize) -> &dyn Value<D> { self.0.index(i) }
fn iter(&self) -> Box<dyn Iterator<Item = &dyn Value<D>> + '_> { self.0.iter() }
fn index(&self, i: usize) -> &dyn ValueImpl<D> { self.0.index(i) }
fn iter(&self) -> Box<dyn Iterator<Item = &dyn ValueImpl<D>> + '_> { self.0.iter() }
fn is_set(&self) -> bool { self.0.is_set() }
fn has(&self, v: &dyn Value<D>) -> bool { self.0.has(v) }
fn has(&self, v: &dyn ValueImpl<D>) -> bool { self.0.has(v) }
fn is_dictionary(&self) -> bool { self.0.is_dictionary() }
fn get<'value>(&'value self, k: &dyn Value<D>) -> Option<&'value dyn Value<D>> { self.0.get(k) }
fn entries(&self) -> Box<dyn Iterator<Item = (&dyn Value<D>, &dyn Value<D>)> + '_> { self.0.entries() }
fn get<'value>(&'value self, k: &dyn ValueImpl<D>) -> Option<&'value dyn ValueImpl<D>> { self.0.get(k) }
fn entries(&self) -> Box<dyn Iterator<Item = (&dyn ValueImpl<D>, &dyn ValueImpl<D>)> + '_> { self.0.entries() }
fn is_embedded(&self) -> bool { self.0.is_embedded() }
fn embedded(&self) -> Cow<'_, D> { self.0.embedded() }
fn annotations(&self) -> Option<&[IOValue]> { self.0.annotations() }
}
impl Value<IOValue> for IOValue {
impl ValueImpl<IOValue> for IOValue {
fn write(&self, w: &mut dyn Writer, enc: &mut dyn DomainEncode<IOValue>) -> io::Result<()> { self.0.write(w, enc) }
fn value_clone(&self) -> PlainValue<'static, IOValue> { Box::new(self.clone()) }
fn value_class(&self) -> ValueClass { self.0.value_class() }
@ -979,16 +979,16 @@ impl Value<IOValue> for IOValue {
fn as_bytestring(&self) -> Option<Cow<'_, [u8]>> { self.0.as_bytestring() }
fn as_symbol(&self) -> Option<Cow<'_, str>> { self.0.as_symbol() }
fn is_record(&self) -> bool { self.0.is_record() }
fn label(&self) -> &dyn Value<IOValue> { self.0.label() }
fn label(&self) -> &dyn ValueImpl<IOValue> { self.0.label() }
fn is_sequence(&self) -> bool { self.0.is_sequence() }
fn len(&self) -> usize { self.0.len() }
fn index(&self, i: usize) -> &dyn Value<IOValue> { self.0.index(i) }
fn iter(&self) -> Box<dyn Iterator<Item = &dyn Value<IOValue>> + '_> { self.0.iter() }
fn index(&self, i: usize) -> &dyn ValueImpl<IOValue> { self.0.index(i) }
fn iter(&self) -> Box<dyn Iterator<Item = &dyn ValueImpl<IOValue>> + '_> { self.0.iter() }
fn is_set(&self) -> bool { self.0.is_set() }
fn has(&self, v: &dyn Value<IOValue>) -> bool { self.0.has(v) }
fn has(&self, v: &dyn ValueImpl<IOValue>) -> bool { self.0.has(v) }
fn is_dictionary(&self) -> bool { self.0.is_dictionary() }
fn get<'value>(&'value self, k: &dyn Value<IOValue>) -> Option<&'value dyn Value<IOValue>> { self.0.get(k) }
fn entries(&self) -> Box<dyn Iterator<Item = (&dyn Value<IOValue>, &dyn Value<IOValue>)> + '_> { self.0.entries() }
fn get<'value>(&'value self, k: &dyn ValueImpl<IOValue>) -> Option<&'value dyn ValueImpl<IOValue>> { self.0.get(k) }
fn entries(&self) -> Box<dyn Iterator<Item = (&dyn ValueImpl<IOValue>, &dyn ValueImpl<IOValue>)> + '_> { self.0.entries() }
fn is_embedded(&self) -> bool { self.0.is_embedded() }
fn embedded(&self) -> Cow<'_, IOValue> { self.0.embedded() }
fn annotations(&self) -> Option<&[IOValue]> { self.0.annotations() }

6
implementations/rust/oo/src/text/writer.rs
View File

@ -2,7 +2,7 @@ use crate::Domain;
use crate::DomainEncode;
use crate::IOValue;
use crate::IOValueDomainCodec;
use crate::Value;
use crate::ValueImpl;
use crate::Writer;
use crate::hex::HexFormatter;
@ -39,7 +39,7 @@ impl TextWriter<&mut Vec<u8>> {
pub fn fmt_value<D: Domain, Enc: DomainEncode<D>>(
f: &mut std::fmt::Formatter<'_>,
enc: &mut Enc,
v: &dyn Value<D>,
v: &dyn ValueImpl<D>,
) -> io::Result<()> {
let mut buf: Vec<u8> = Vec::new();
let mut w = TextWriter::new(&mut buf);
@ -51,7 +51,7 @@ impl TextWriter<&mut Vec<u8>> {
pub fn encode<D: Domain, Enc: DomainEncode<D>>(
enc: &mut Enc,
v: &dyn Value<D>,
v: &dyn ValueImpl<D>,
) -> io::Result<String> {
let mut buf: Vec<u8> = Vec::new();
v.write(&mut TextWriter::new(&mut buf), enc)?;

4
implementations/rust/oo/src/writer.rs
View File

@ -10,7 +10,7 @@ use crate::SignedInteger;
use crate::ValueClass;
use crate::boundary as B;
use crate::signed_integer::SignedIntegerRepr;
use crate::Value;
use crate::ValueImpl;
pub trait Writer {
fn boundary(&mut self, b: &B::Type) -> io::Result<()>;
@ -68,7 +68,7 @@ pub trait Writer {
}
}
pub fn write_value<D: Domain, V: Value<D>>(
pub fn write_value<D: Domain, V: ValueImpl<D>>(
w: &mut dyn Writer,
v: V,
enc: &mut dyn DomainEncode<D>,