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

Another failure

This commit is contained in:
Tony Garnock-Jones 2022-11-17 09:43:04 +01:00
parent ce9d4f2f0c
commit 5a5ff987b7
9 changed files with 345 additions and 509 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

57
implementations/rust/preserves/src/lib.rs
View File

@ -22,13 +22,11 @@ pub use packed::iovalue_from_bytes;
pub use reader::IOValues; pub use reader::IOValues;
pub use reader::Reader; pub use reader::Reader;
pub use repr::Annotations; pub use repr::Annotations;
pub use repr::ArcValue;
pub use repr::Atom; pub use repr::Atom;
pub use repr::Bytes; pub use repr::Bytes;
pub use repr::Embedded; pub use repr::Embedded;
pub use repr::IOValue; pub use repr::IOValue;
pub use repr::Map; pub use repr::Map;
pub use repr::PlainValue;
pub use repr::NoValue; pub use repr::NoValue;
pub use repr::Record; pub use repr::Record;
pub use repr::Set; pub use repr::Set;
@ -36,9 +34,6 @@ pub use repr::Symbol;
pub use repr::Value; pub use repr::Value;
pub use repr::ValueImpl; pub use repr::ValueImpl;
pub use repr::copy_via; pub use repr::copy_via;
pub use repr::iovalue;
pub use repr::owned;
pub use repr::shell;
pub use repr::value; pub use repr::value;
pub use signed_integer::SignedInteger; pub use signed_integer::SignedInteger;
pub use source::BinarySource; pub use source::BinarySource;
@ -65,24 +60,24 @@ mod demo {
// } // }
#[test] fn a() { #[test] fn a() {
let l: PlainValue<NoValue> = "label".parse().unwrap(); let l: Value<NoValue> = "label".parse().unwrap();
let r = Record::new(l.value_clone(), vec![owned(1), owned(2), owned(3)]); let r = Record::new(l.value_clone(), vec![value(1), value(2), value(3)]);
let r2 = Record::new(l, vec![owned(1), owned(2), owned(4)]); let r2 = Record::new(l, vec![value(1), value(2), value(4)]);
let mut v: Map<PlainValue<NoValue>, PlainValue<NoValue>> = Map::new(); let mut v: Map<Value<NoValue>, Value<NoValue>> = Map::new();
v.insert("\"abc\"".parse().unwrap(), "def".parse().unwrap()); v.insert("\"abc\"".parse().unwrap(), "def".parse().unwrap());
v.insert("abc".parse().unwrap(), "DEF".parse().unwrap()); v.insert("abc".parse().unwrap(), "DEF".parse().unwrap());
v.insert(owned(123), "xyz".parse().unwrap()); v.insert(value(123), "xyz".parse().unwrap());
v.insert(owned(vec![1, 2, 3]), "{a: 1, b: 2}".parse().unwrap()); v.insert(vec![1, 2, 3].into(), "{a: 1, b: 2}".parse().unwrap());
v.insert(owned(r2), "bbb".parse().unwrap()); v.insert(value(r2), "bbb".parse().unwrap());
v.insert(owned(r), "<foo bar zot>".parse().unwrap()); v.insert(value(r), "<foo bar zot>".parse().unwrap());
let w: &dyn ValueImpl<NoValue> = &v; let w: &dyn ValueImpl<NoValue> = &v;
println!("GETw abc {:?}", w.get(&"abc")); println!("GETw abc {:?}", w.get(&value("abc")));
println!("GETw 123 {:?}", w.get(&123)); println!("GETw 123 {:?}", w.get(&value(123)));
println!("GETw qqq {:?}", w.get(&"qqq")); println!("GETw qqq {:?}", w.get(&value("qqq")));
println!("GETv abc {:?}", v.get(&*value(&"abc"))); println!("GETv abc {:?}", v.get(&value("abc")));
println!("GETv 123 {:?}", v.get(&*value(&123))); println!("GETv 123 {:?}", v.get(&value(123)));
println!("GETv qqq {:?}", v.get(&*value(&"qqq"))); println!("GETv qqq {:?}", v.get(&value("qqq")));
for (kk, vv) in w.entries() { for (kk, vv) in w.entries() {
println!("{:#?} ==> {:#?}", kk, vv); println!("{:#?} ==> {:#?}", kk, vv);
} }
@ -99,7 +94,7 @@ mod demo {
} }
#[test] fn value_size() { #[test] fn value_size() {
println!("Value size {}", std::mem::size_of::<Value<'_, NoValue>>()); println!("Value size {}", std::mem::size_of::<Value<NoValue>>());
println!("&dyn ValueImpl size {}", std::mem::size_of::<&dyn ValueImpl<NoValue>>()); println!("&dyn ValueImpl size {}", std::mem::size_of::<&dyn ValueImpl<NoValue>>());
println!("Box dyn ValueImpl size {}", std::mem::size_of::<Box<dyn ValueImpl<NoValue>>>()); println!("Box dyn ValueImpl size {}", std::mem::size_of::<Box<dyn ValueImpl<NoValue>>>());
} }
@ -162,26 +157,26 @@ mod test_domain {
} }
} }
fn dom_as_preserves(v: &Dom) -> io::Result<PlainValue<'static, IOValue>> { fn dom_as_preserves(v: &Dom) -> io::Result<Value<IOValue>> {
Ok(match v { Ok(match v {
Dom::One => owned(Bytes::new(vec![255, 255, 255, 255])), Dom::One => value(Bytes::new(vec![255, 255, 255, 255])),
Dom::Two => owned(Symbol::new(format!("Dom::{:?}", v))), Dom::Two => value(Symbol::new(format!("Dom::{:?}", v))),
}) })
} }
#[test] fn test_one() { #[test] fn test_one() {
let v = owned(vec![owned(1), let v = value(vec![value(1),
owned(Embedded::new(Dom::One)), value(Embedded::new(Dom::One)),
owned(2)]); value(2)]);
assert_eq!(PackedWriter::encode_iovalue(&iovalue(copy_via(&v, &mut dom_as_preserves).unwrap())).unwrap(), assert_eq!(PackedWriter::encode_iovalue(&copy_via(&v, &mut dom_as_preserves).unwrap().into()).unwrap(),
[0xb5, 0x91, 0xb2, 0x04, 255, 255, 255, 255, 0x92, 0x84]); [0xb5, 0x91, 0xb2, 0x04, 255, 255, 255, 255, 0x92, 0x84]);
} }
#[test] fn test_two() { #[test] fn test_two() {
let v = owned(vec![owned(1), let v = value(vec![value(1),
owned(Embedded::new(Dom::Two)), value(Embedded::new(Dom::Two)),
owned(2)]); value(2)]);
assert_eq!(PackedWriter::encode_iovalue(&iovalue(copy_via(&v, &mut dom_as_preserves).unwrap())).unwrap(), assert_eq!(PackedWriter::encode_iovalue(&copy_via(&v, &mut dom_as_preserves).unwrap().into()).unwrap(),
[0xb5, 0x91, 0xb3, 0x08, 68, 111, 109, 58, 58, 84, 119, 111, 0x92, 0x84]); [0xb5, 0x91, 0xb3, 0x08, 68, 111, 109, 58, 58, 84, 119, 111, 0x92, 0x84]);
} }
} }

6
implementations/rust/preserves/src/packed/mod.rs
View File

@ -13,13 +13,13 @@ use crate::BytesBinarySource;
use crate::Domain; use crate::Domain;
use crate::DomainDecode; use crate::DomainDecode;
use crate::IOValue; use crate::IOValue;
use crate::PlainValue;
use crate::Reader; use crate::Reader;
use crate::Value;
pub fn from_bytes<'de, D: Domain, Dec: DomainDecode<D>>( pub fn from_bytes<'de, D: Domain, Dec: DomainDecode<D>>(
bs: &'de [u8], bs: &'de [u8],
decode_embedded: &mut Dec, decode_embedded: &mut Dec,
) -> io::Result<PlainValue<'de, D>> { ) -> io::Result<Value<D>> {
BytesBinarySource::new(bs).packed().next(false, decode_embedded) BytesBinarySource::new(bs).packed().next(false, decode_embedded)
} }
@ -30,7 +30,7 @@ pub fn iovalue_from_bytes(bs: &[u8]) -> io::Result<IOValue> {
pub fn annotated_from_bytes<'de, D: Domain, Dec: DomainDecode<D>>( pub fn annotated_from_bytes<'de, D: Domain, Dec: DomainDecode<D>>(
bs: &'de [u8], bs: &'de [u8],
decode_embedded: &mut Dec, decode_embedded: &mut Dec,
) -> io::Result<PlainValue<'de, D>> { ) -> io::Result<Value<D>> {
super::BytesBinarySource::new(bs).packed().next(true, decode_embedded) super::BytesBinarySource::new(bs).packed().next(true, decode_embedded)
} }

6
implementations/rust/preserves/src/packed/reader.rs
View File

@ -300,11 +300,11 @@ impl<'de, S: BinarySource<'de>> Reader<'de> for PackedReader<'de, S> {
self.readbytes_into(&mut bs)?; self.readbytes_into(&mut bs)?;
Ok(Atom::Double(f64::from_bits(u64::from_be_bytes(bs)))) Ok(Atom::Double(f64::from_bits(u64::from_be_bytes(bs))))
} }
Tag::SmallInteger(v) => Ok(Atom::SignedInteger(v.into())), Tag::SmallInteger(v) => Ok(Atom::SignedInteger(Cow::Owned(v.into()))),
Tag::MediumInteger(count) => Ok(Atom::SignedInteger(self.read_signed_integer(count.into())?)), Tag::MediumInteger(count) => Ok(Atom::SignedInteger(Cow::Owned(self.read_signed_integer(count.into())?))),
Tag::SignedInteger => { Tag::SignedInteger => {
let count = self.varint()?; let count = self.varint()?;
Ok(Atom::SignedInteger(self.read_signed_integer(count)?)) Ok(Atom::SignedInteger(Cow::Owned(self.read_signed_integer(count)?)))
} }
Tag::String => { Tag::String => {
let count = self.varint()?; let count = self.varint()?;

69
implementations/rust/preserves/src/packed/view.rs
View File

@ -14,16 +14,12 @@ use crate::DomainDecode;
use crate::IOValue; use crate::IOValue;
use crate::NoEmbeddedDomainCodec; use crate::NoEmbeddedDomainCodec;
use crate::PackedWriter; use crate::PackedWriter;
use crate::PlainValue;
use crate::SignedInteger; use crate::SignedInteger;
use crate::Value; use crate::Value;
use crate::ValueClass; use crate::ValueClass;
use crate::ValueImpl; use crate::ValueImpl;
use crate::error; use crate::error;
use crate::error::io_eof; use crate::error::io_eof;
use crate::iovalue;
use crate::owned;
use crate::shell;
use crate::reader::NextToken; use crate::reader::NextToken;
use super::constants::Tag; use super::constants::Tag;
@ -310,8 +306,8 @@ impl<'de, Packed: AsRef<[u8]> + 'de, D: Domain> ValueImpl<D> for View<'de, Packe
} }
} }
fn value_clone(&self) -> PlainValue<'static, D> { fn value_clone(&self) -> Value<D> {
owned(View { Value::new(View {
repr: self.repr.trim(self.annotation_offset .. self.value_range.end), repr: self.repr.trim(self.annotation_offset .. self.value_range.end),
annotation_offset: 0, annotation_offset: 0,
value_range: (self.value_range.start - self.annotation_offset value_range: (self.value_range.start - self.annotation_offset
@ -348,22 +344,13 @@ impl<'de, Packed: AsRef<[u8]> + 'de, D: Domain> ValueImpl<D> for View<'de, Packe
} }
} }
fn is_signed_integer(&self) -> bool { fn as_signed_integer(&self) -> Option<Cow<'_, SignedInteger>> {
match self.tag() { match self.tag() {
Tag::SmallInteger(_) => true, Tag::SmallInteger(v) => Some(Cow::Owned(v.into())),
Tag::MediumInteger(_) => true, Tag::MediumInteger(n) => Some(Cow::Owned(self.signed_integer(self.value_range.start + 1, n as usize))),
Tag::SignedInteger => true,
_ => false,
}
}
fn as_signed_integer(&self) -> Option<SignedInteger> {
match self.tag() {
Tag::SmallInteger(v) => Some(v.into()),
Tag::MediumInteger(n) => Some(self.signed_integer(self.value_range.start + 1, n as usize)),
Tag::SignedInteger => { Tag::SignedInteger => {
let (n, i) = self.varint(); let (n, i) = self.varint();
Some(self.signed_integer(i, n as usize)) Some(Cow::Owned(self.signed_integer(i, n as usize)))
} }
_ => None, _ => None,
} }
@ -400,9 +387,9 @@ impl<'de, Packed: AsRef<[u8]> + 'de, D: Domain> ValueImpl<D> for View<'de, Packe
self.tag() == Tag::Record self.tag() == Tag::Record
} }
fn label(&self) -> Value<'_, D> { fn label(&self) -> Value<D> {
if !self.is_record() { panic!("Not a record") } if !self.is_record() { panic!("Not a record") }
shell(View::inner_new(&self.repr, self.value_range.start + 1).unwrap()) Value::new(View::inner_new(&self.repr, self.value_range.start + 1).unwrap())
} }
fn is_sequence(&self) -> bool { fn is_sequence(&self) -> bool {
@ -417,11 +404,11 @@ impl<'de, Packed: AsRef<[u8]> + 'de, D: Domain> ValueImpl<D> for View<'de, Packe
} }
} }
fn index(&self, i: usize) -> Value<'_, D> { fn index(&self, i: usize) -> Value<D> {
self.iter().nth(i).unwrap() self.iter().nth(i).unwrap()
} }
fn iter(&self) -> Box<dyn Iterator<Item = Value<'_, D>> + '_> { fn iter(&self) -> Box<dyn Iterator<Item = Value<D>> + '_> {
let mut i = Box::new(ViewIterator::inner_new(&self.repr, self.value_range.start + 1)); let mut i = Box::new(ViewIterator::inner_new(&self.repr, self.value_range.start + 1));
match self.tag() { match self.tag() {
Tag::Record => { i.next(); () } Tag::Record => { i.next(); () }
@ -436,33 +423,29 @@ impl<'de, Packed: AsRef<[u8]> + 'de, D: Domain> ValueImpl<D> for View<'de, Packe
self.tag() == Tag::Set self.tag() == Tag::Set
} }
fn has(&self, v: &dyn ValueImpl<D>) -> bool { fn has(&self, v: &Value<D>) -> bool {
self.iter().find(|e| v == &**e).is_some() self.iter().find(|e| v == e).is_some()
} }
fn is_dictionary(&self) -> bool { fn is_dictionary(&self) -> bool {
self.tag() == Tag::Dictionary self.tag() == Tag::Dictionary
} }
fn get(&self, k: &dyn ValueImpl<D>) -> Option<Value<'_, D>> { fn get(&self, k: &Value<D>) -> Option<Value<D>> {
for (kk, vv) in self.entries() { for (kk, vv) in self.entries() {
if &*kk == k { return Some(vv); } if k == &kk { return Some(vv); }
} }
None None
} }
fn entries(&self) -> Box<dyn Iterator<Item = (Value<'_, D>, Value<'_, D>)> + '_> { fn entries(&self) -> Box<dyn Iterator<Item = (Value<D>, Value<D>)> + '_> {
if !self.is_dictionary() { panic!("Not a dictionary") } if !self.is_dictionary() { panic!("Not a dictionary") }
Box::new(DictionaryAdapter(ViewIterator::inner_new(&self.repr, self.value_range.start + 1))) Box::new(DictionaryAdapter(ViewIterator::inner_new(&self.repr, self.value_range.start + 1)))
} }
fn is_embedded(&self) -> bool { fn as_embedded(&self) -> Option<Cow<'_, D>> {
self.tag() == Tag::Embedded if self.tag() != Tag::Embedded { return None }
} Some(match self.repr.index.embedded.as_ref() {
fn embedded(&self) -> Cow<'_, D> {
if !self.is_embedded() { panic!("Not an embedded value") }
match self.repr.index.embedded.as_ref() {
Some(e) => { Some(e) => {
Cow::Borrowed(e.iter().find_map(|(r, d)| { Cow::Borrowed(e.iter().find_map(|(r, d)| {
if r.start == self.value_range.start { Some(d) } else { None } if r.start == self.value_range.start { Some(d) } else { None }
@ -475,7 +458,7 @@ impl<'de, Packed: AsRef<[u8]> + 'de, D: Domain> ValueImpl<D> for View<'de, Packe
let d = D::Decode::default().decode_embedded(&mut r, true).unwrap(); let d = D::Decode::default().decode_embedded(&mut r, true).unwrap();
Cow::Owned(d) Cow::Owned(d)
} }
} })
} }
fn annotations(&self) -> Option<Cow<'_, [IOValue]>> { fn annotations(&self) -> Option<Cow<'_, [IOValue]>> {
@ -488,7 +471,7 @@ impl<'de, Packed: AsRef<[u8]> + 'de, D: Domain> ValueImpl<D> for View<'de, Packe
phantom: PhantomData, phantom: PhantomData,
}); });
let anns: Vec<IOValue> = AnnotationAdapter(ViewIterator::inner_new(&repr, self.annotation_offset)) let anns: Vec<IOValue> = AnnotationAdapter(ViewIterator::inner_new(&repr, self.annotation_offset))
.map(|ann| iovalue(ann.into_owned())) .map(|ann| ann.into())
.collect(); .collect();
Some(Cow::Owned(anns)) Some(Cow::Owned(anns))
} }
@ -514,7 +497,7 @@ impl<'de, 'dec, D: Domain, Dec: DomainDecode<D>> ViewStream<'de, 'dec, D, Dec> {
} }
impl<'de, 'dec, D: Domain, Dec: DomainDecode<D>> Iterator for ViewStream<'de, 'dec, D, Dec> { impl<'de, 'dec, D: Domain, Dec: DomainDecode<D>> Iterator for ViewStream<'de, 'dec, D, Dec> {
type Item = io::Result<Value<'de, D>>; type Item = io::Result<Value<D>>;
fn next(&mut self) -> Option<Self::Item> { fn next(&mut self) -> Option<Self::Item> {
if self.offset >= self.buf.len() { if self.offset >= self.buf.len() {
@ -523,7 +506,7 @@ impl<'de, 'dec, D: Domain, Dec: DomainDecode<D>> Iterator for ViewStream<'de, 'd
match View::new_offset(self.buf, self.dec.as_mut().map(|dec| &mut *dec), self.offset) { match View::new_offset(self.buf, self.dec.as_mut().map(|dec| &mut *dec), self.offset) {
Ok(v) => { Ok(v) => {
self.offset = v.value_range.end; self.offset = v.value_range.end;
Some(Ok(shell(v))) Some(Ok(Value::new(v)))
} }
Err(e) => Some(Err(e)), Err(e) => Some(Err(e)),
} }
@ -543,7 +526,7 @@ impl<'de, Packed: AsRef<[u8]> + 'de, D: Domain> ViewIterator<IndexedRepr<'de, Pa
} }
impl<'de, Packed: AsRef<[u8]> + 'de, D: Domain> Iterator for ViewIterator<IndexedRepr<'de, Packed, D>> { impl<'de, Packed: AsRef<[u8]> + 'de, D: Domain> Iterator for ViewIterator<IndexedRepr<'de, Packed, D>> {
type Item = Value<'de, D>; type Item = Value<D>;
fn next(&mut self) -> Option<Self::Item> { fn next(&mut self) -> Option<Self::Item> {
if let Ok(Tag::End) = tag_at(self.repr.packed.as_ref(), self.offset) { if let Ok(Tag::End) = tag_at(self.repr.packed.as_ref(), self.offset) {
@ -551,7 +534,7 @@ impl<'de, Packed: AsRef<[u8]> + 'de, D: Domain> Iterator for ViewIterator<Indexe
} else { } else {
let v = View::inner_new(&self.repr, self.offset).unwrap(); let v = View::inner_new(&self.repr, self.offset).unwrap();
self.offset = v.value_range.end; self.offset = v.value_range.end;
Some(shell(v)) Some(Value::new(v))
} }
} }
} }
@ -559,7 +542,7 @@ impl<'de, Packed: AsRef<[u8]> + 'de, D: Domain> Iterator for ViewIterator<Indexe
pub struct DictionaryAdapter<Repr>(pub ViewIterator<Repr>); pub struct DictionaryAdapter<Repr>(pub ViewIterator<Repr>);
impl<'de, Packed: AsRef<[u8]> + 'de, D: Domain> Iterator for DictionaryAdapter<IndexedRepr<'de, Packed, D>> { impl<'de, Packed: AsRef<[u8]> + 'de, D: Domain> Iterator for DictionaryAdapter<IndexedRepr<'de, Packed, D>> {
type Item = (Value<'de, D>, Value<'de, D>); type Item = (Value<D>, Value<D>);
fn next(&mut self) -> Option<Self::Item> { fn next(&mut self) -> Option<Self::Item> {
let k = self.0.next()?; let k = self.0.next()?;
@ -571,7 +554,7 @@ impl<'de, Packed: AsRef<[u8]> + 'de, D: Domain> Iterator for DictionaryAdapter<I
pub struct AnnotationAdapter<Repr>(pub ViewIterator<Repr>); pub struct AnnotationAdapter<Repr>(pub ViewIterator<Repr>);
impl<'de, Packed: AsRef<[u8]> + 'de, D: Domain> Iterator for AnnotationAdapter<IndexedRepr<'de, Packed, D>> { impl<'de, Packed: AsRef<[u8]> + 'de, D: Domain> Iterator for AnnotationAdapter<IndexedRepr<'de, Packed, D>> {
type Item = Value<'de, D>; type Item = Value<D>;
fn next(&mut self) -> Option<Self::Item> { fn next(&mut self) -> Option<Self::Item> {
if let Ok(Tag::Annotation) = tag_at(self.0.repr.packed.as_ref(), self.0.offset) { if let Ok(Tag::Annotation) = tag_at(self.0.repr.packed.as_ref(), self.0.offset) {

21
implementations/rust/preserves/src/reader.rs
View File

@ -5,8 +5,8 @@ use std::marker::PhantomData;
use crate::BinarySource; use crate::BinarySource;
use crate::CompoundClass; use crate::CompoundClass;
use crate::PlainValue;
use crate::SignedInteger; use crate::SignedInteger;
use crate::Value;
use crate::ValueClass; use crate::ValueClass;
use crate::boundary as B; use crate::boundary as B;
use crate::domain::Domain; use crate::domain::Domain;
@ -23,7 +23,6 @@ use crate::repr::Map;
use crate::repr::Record; use crate::repr::Record;
use crate::repr::Set; use crate::repr::Set;
use crate::repr::ValueImpl; use crate::repr::ValueImpl;
use crate::repr::owned;
pub type ReaderResult<T> = std::result::Result<T, Error>; pub type ReaderResult<T> = std::result::Result<T, Error>;
@ -144,11 +143,11 @@ pub trait Reader<'de> {
} }
} }
fn next<'produced: 'de, D: Domain, Dec: DomainDecode<D>>( fn next<D: Domain, Dec: DomainDecode<D>>(
&mut self, &mut self,
read_annotations: bool, read_annotations: bool,
dec: &mut Dec, dec: &mut Dec,
) -> io::Result<PlainValue<'produced, D>> ) -> io::Result<Value<D>>
{ {
let (anns, v) = match read_annotations { let (anns, v) = match read_annotations {
true => self.gather_annotations()?.ok_or_else(io_eof)?, true => self.gather_annotations()?.ok_or_else(io_eof)?,
@ -161,7 +160,7 @@ pub trait Reader<'de> {
self.open_embedded()?; self.open_embedded()?;
let v = dec.decode_embedded(self, read_annotations)?; let v = dec.decode_embedded(self, read_annotations)?;
self.close_embedded()?; self.close_embedded()?;
Box::new(Embedded::new(v)) Value::new(Embedded::new(v))
} }
ValueClass::Compound(CompoundClass::Record) => { ValueClass::Compound(CompoundClass::Record) => {
let mut vs = Vec::new(); let mut vs = Vec::new();
@ -172,7 +171,7 @@ pub trait Reader<'de> {
while !self.close_compound(&mut b, &B::Item::RecordField)? { while !self.close_compound(&mut b, &B::Item::RecordField)? {
vs.push(self.next(read_annotations, dec)?); vs.push(self.next(read_annotations, dec)?);
} }
Box::new(Record::_from_vec(vs)) Value::new(Record::_from_vec(vs))
} }
ValueClass::Compound(CompoundClass::Sequence) => { ValueClass::Compound(CompoundClass::Sequence) => {
let mut vs = Vec::new(); let mut vs = Vec::new();
@ -181,7 +180,7 @@ pub trait Reader<'de> {
while !self.close_compound(&mut b, &B::Item::SequenceValue)? { while !self.close_compound(&mut b, &B::Item::SequenceValue)? {
vs.push(self.next(read_annotations, dec)?); vs.push(self.next(read_annotations, dec)?);
} }
Box::new(vs) Value::new(vs)
} }
ValueClass::Compound(CompoundClass::Set) => { ValueClass::Compound(CompoundClass::Set) => {
let mut s = Set::new(); let mut s = Set::new();
@ -190,7 +189,7 @@ pub trait Reader<'de> {
while !self.close_compound(&mut b, &B::Item::SetValue)? { while !self.close_compound(&mut b, &B::Item::SetValue)? {
s.insert(self.next(read_annotations, dec)?); s.insert(self.next(read_annotations, dec)?);
} }
Box::new(s) Value::new(s)
} }
ValueClass::Compound(CompoundClass::Dictionary) => { ValueClass::Compound(CompoundClass::Dictionary) => {
let mut d = Map::new(); let mut d = Map::new();
@ -202,13 +201,13 @@ pub trait Reader<'de> {
self.boundary(&b)?; self.boundary(&b)?;
d.insert(k, self.next(read_annotations, dec)?); d.insert(k, self.next(read_annotations, dec)?);
} }
Box::new(d) Value::new(d)
} }
}; };
if anns.is_empty() { if anns.is_empty() {
Ok(value) Ok(value)
} else { } else {
Ok(owned(Annotations::new(value, anns))) Ok(Annotations::new(value, anns))
} }
} }
@ -230,7 +229,7 @@ pub trait Reader<'de> {
} }
fn next_signedinteger(&mut self) -> ReaderResult<SignedInteger> { fn next_signedinteger(&mut self) -> ReaderResult<SignedInteger> {
self.next_iovalue(false)?.as_signed_integer().ok_or(Error::Expected(ExpectedKind::SignedInteger)) Ok(self.next_iovalue(false)?.as_signed_integer().ok_or(Error::Expected(ExpectedKind::SignedInteger))?.into_owned().into())
} }
fn next_i8(&mut self) -> ReaderResult<i8> { Ok(i8::try_from(&self.next_signedinteger()?)?) } fn next_i8(&mut self) -> ReaderResult<i8> { Ok(i8::try_from(&self.next_signedinteger()?)?) }

666
implementations/rust/preserves/src/repr.rs
View File

File diff suppressed because it is too large Load Diff

16
implementations/rust/preserves/src/text/mod.rs
View File

@ -11,13 +11,13 @@ use crate::BytesBinarySource;
use crate::Domain; use crate::Domain;
use crate::DomainDecode; use crate::DomainDecode;
use crate::IOValue; use crate::IOValue;
use crate::PlainValue;
use crate::Reader; use crate::Reader;
use crate::Value;
pub fn from_str<'de, D: Domain, Dec: DomainDecode<D>>( pub fn from_str<'de, D: Domain, Dec: DomainDecode<D>>(
s: &'de str, s: &'de str,
decode_embedded: &mut Dec, decode_embedded: &mut Dec,
) -> io::Result<PlainValue<'de, D>> { ) -> io::Result<Value<D>> {
BytesBinarySource::new(s.as_bytes()).text().next(false, decode_embedded) BytesBinarySource::new(s.as_bytes()).text().next(false, decode_embedded)
} }
@ -28,7 +28,7 @@ pub fn iovalue_from_str(s: &str) -> io::Result<IOValue> {
pub fn annotated_from_str<'de, D: Domain, Dec: DomainDecode<D>>( pub fn annotated_from_str<'de, D: Domain, Dec: DomainDecode<D>>(
s: &'de str, s: &'de str,
decode_embedded: &mut Dec, decode_embedded: &mut Dec,
) -> io::Result<PlainValue<'de, D>> { ) -> io::Result<Value<D>> {
BytesBinarySource::new(s.as_bytes()).text().next(true, decode_embedded) BytesBinarySource::new(s.as_bytes()).text().next(true, decode_embedded)
} }
@ -39,16 +39,16 @@ pub fn annotated_iovalue_from_str(s: &str) -> io::Result<IOValue> {
#[cfg(test)] #[cfg(test)]
mod formatting_tests { mod formatting_tests {
use crate::IOValue; use crate::IOValue;
use crate::Value;
use crate::test_domain::Dom; use crate::test_domain::Dom;
use crate::ArcValue;
#[test] fn format_debug_and_parse() { #[test] fn format_debug_and_parse() {
let v = "[1, {z: 2, a: #!\"One\"}, 3]".parse::<ArcValue<Dom>>().unwrap(); let v = "[1, {z: 2, a: #!\"One\"}, 3]".parse::<Value<Dom>>().unwrap();
assert_eq!(format!("{:?}", &v), "[1, {a: #!\"One\", z: 2}, 3]"); assert_eq!(format!("{:?}", &v), "[1, {a: #!\"One\", z: 2}, 3]");
} }
#[test] fn format_pretty_debug_and_parse() { #[test] fn format_pretty_debug_and_parse() {
let v = "[1, {z: 2, a: #!\"One\"}, 3]".parse::<ArcValue<Dom>>().unwrap(); let v = "[1, {z: 2, a: #!\"One\"}, 3]".parse::<Value<Dom>>().unwrap();
assert_eq!(format!("{:#?}", &v), concat!( assert_eq!(format!("{:#?}", &v), concat!(
"[\n", "[\n",
" 1,\n", " 1,\n",
@ -84,7 +84,7 @@ mod unusual_float_tests {
fn d32(u: u32, expected: &str) { fn d32(u: u32, expected: &str) {
let v = f32::from_bits(u); let v = f32::from_bits(u);
let w = iovalue(v); let w = value(v).into();
assert_eq!(format!("{:?}", w), expected); assert_eq!(format!("{:?}", w), expected);
let x = expected.parse::<IOValue>().unwrap(); let x = expected.parse::<IOValue>().unwrap();
assert_eq!(x, w); assert_eq!(x, w);
@ -92,7 +92,7 @@ mod unusual_float_tests {
fn d64(u: u64, expected: &str) { fn d64(u: u64, expected: &str) {
let v = f64::from_bits(u); let v = f64::from_bits(u);
let w = iovalue(v); let w = value(v).into();
assert_eq!(format!("{:?}", w), expected); assert_eq!(format!("{:?}", w), expected);
let x = expected.parse::<IOValue>().unwrap(); let x = expected.parse::<IOValue>().unwrap();
assert_eq!(x, w); assert_eq!(x, w);

7
implementations/rust/preserves/src/text/reader.rs
View File

@ -266,9 +266,10 @@ impl<'de, S: BinarySource<'de>> TextReader<'de, S>
return match NUMBER_RE.captures(&s) { return match NUMBER_RE.captures(&s) {
None => Ok(Atom::Symbol(s.into())), None => Ok(Atom::Symbol(s.into())),
Some(m) => match m.get(2) { Some(m) => match m.get(2) {
None => Ok(Atom::SignedInteger(s.parse::<BigInt>().map_err( None => Ok(Atom::SignedInteger(Cow::Owned(
|_| self.syntax_error(&format!( s.parse::<BigInt>().map_err(
"Invalid signed-integer number: {:?}", s)))?.into())), |_| self.syntax_error(&format!(
"Invalid signed-integer number: {:?}", s)))?.into()))),
Some(_) => { Some(_) => {
if let Some(maybe_f) = m.get(7) { if let Some(maybe_f) = m.get(7) {
let s = m[1].to_owned() + &m[3]; let s = m[1].to_owned() + &m[3];

6
implementations/rust/preserves/src/writer.rs
View File

@ -70,9 +70,9 @@ pub trait Writer {
fn specialized(&mut self) -> Option<(&str, &mut dyn io::Write)> { None } fn specialized(&mut self) -> Option<(&str, &mut dyn io::Write)> { None }
} }
pub fn write_value<D: Domain, V: ValueImpl<D>>( pub fn write_value<D: Domain>(
w: &mut dyn Writer, w: &mut dyn Writer,
v: V, v: &dyn ValueImpl<D>,
enc: &mut dyn DomainEncode<D>, enc: &mut dyn DomainEncode<D>,
) -> io::Result<()> { ) -> io::Result<()> {
let annotations = v.annotations(); let annotations = v.annotations();
@ -163,7 +163,7 @@ pub fn write_value<D: Domain, V: ValueImpl<D>>(
} }
ValueClass::Embedded => { ValueClass::Embedded => {
w.start_embedded()?; w.start_embedded()?;
enc.encode_embedded(w, &v.embedded())?; enc.encode_embedded(w, &v.as_embedded().unwrap())?;
w.end_embedded()? w.end_embedded()?
} }
} }