Another failure
This commit is contained in:
parent
ce9d4f2f0c
commit
5a5ff987b7
|
@ -22,13 +22,11 @@ pub use packed::iovalue_from_bytes;
|
|||
pub use reader::IOValues;
|
||||
pub use reader::Reader;
|
||||
pub use repr::Annotations;
|
||||
pub use repr::ArcValue;
|
||||
pub use repr::Atom;
|
||||
pub use repr::Bytes;
|
||||
pub use repr::Embedded;
|
||||
pub use repr::IOValue;
|
||||
pub use repr::Map;
|
||||
pub use repr::PlainValue;
|
||||
pub use repr::NoValue;
|
||||
pub use repr::Record;
|
||||
pub use repr::Set;
|
||||
|
@ -36,9 +34,6 @@ 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;
|
||||
pub use repr::shell;
|
||||
pub use repr::value;
|
||||
pub use signed_integer::SignedInteger;
|
||||
pub use source::BinarySource;
|
||||
|
@ -65,24 +60,24 @@ mod demo {
|
|||
// }
|
||||
|
||||
#[test] fn a() {
|
||||
let l: PlainValue<NoValue> = "label".parse().unwrap();
|
||||
let r = Record::new(l.value_clone(), vec![owned(1), owned(2), owned(3)]);
|
||||
let r2 = Record::new(l, vec![owned(1), owned(2), owned(4)]);
|
||||
let l: Value<NoValue> = "label".parse().unwrap();
|
||||
let r = Record::new(l.value_clone(), vec![value(1), value(2), value(3)]);
|
||||
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(owned(123), "xyz".parse().unwrap());
|
||||
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());
|
||||
v.insert(value(123), "xyz".parse().unwrap());
|
||||
v.insert(vec![1, 2, 3].into(), "{a: 1, b: 2}".parse().unwrap());
|
||||
v.insert(value(r2), "bbb".parse().unwrap());
|
||||
v.insert(value(r), "<foo bar zot>".parse().unwrap());
|
||||
let w: &dyn ValueImpl<NoValue> = &v;
|
||||
println!("GETw abc {:?}", w.get(&"abc"));
|
||||
println!("GETw 123 {:?}", w.get(&123));
|
||||
println!("GETw qqq {:?}", w.get(&"qqq"));
|
||||
println!("GETv abc {:?}", v.get(&*value(&"abc")));
|
||||
println!("GETv 123 {:?}", v.get(&*value(&123)));
|
||||
println!("GETv qqq {:?}", v.get(&*value(&"qqq")));
|
||||
println!("GETw abc {:?}", w.get(&value("abc")));
|
||||
println!("GETw 123 {:?}", w.get(&value(123)));
|
||||
println!("GETw qqq {:?}", w.get(&value("qqq")));
|
||||
println!("GETv abc {:?}", v.get(&value("abc")));
|
||||
println!("GETv 123 {:?}", v.get(&value(123)));
|
||||
println!("GETv qqq {:?}", v.get(&value("qqq")));
|
||||
for (kk, vv) in w.entries() {
|
||||
println!("{:#?} ==> {:#?}", kk, vv);
|
||||
}
|
||||
|
@ -99,7 +94,7 @@ mod demo {
|
|||
}
|
||||
|
||||
#[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!("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 {
|
||||
Dom::One => owned(Bytes::new(vec![255, 255, 255, 255])),
|
||||
Dom::Two => owned(Symbol::new(format!("Dom::{:?}", v))),
|
||||
Dom::One => value(Bytes::new(vec![255, 255, 255, 255])),
|
||||
Dom::Two => value(Symbol::new(format!("Dom::{:?}", v))),
|
||||
})
|
||||
}
|
||||
|
||||
#[test] fn test_one() {
|
||||
let v = owned(vec![owned(1),
|
||||
owned(Embedded::new(Dom::One)),
|
||||
owned(2)]);
|
||||
assert_eq!(PackedWriter::encode_iovalue(&iovalue(copy_via(&v, &mut dom_as_preserves).unwrap())).unwrap(),
|
||||
let v = value(vec![value(1),
|
||||
value(Embedded::new(Dom::One)),
|
||||
value(2)]);
|
||||
assert_eq!(PackedWriter::encode_iovalue(©_via(&v, &mut dom_as_preserves).unwrap().into()).unwrap(),
|
||||
[0xb5, 0x91, 0xb2, 0x04, 255, 255, 255, 255, 0x92, 0x84]);
|
||||
}
|
||||
|
||||
#[test] fn test_two() {
|
||||
let v = owned(vec![owned(1),
|
||||
owned(Embedded::new(Dom::Two)),
|
||||
owned(2)]);
|
||||
assert_eq!(PackedWriter::encode_iovalue(&iovalue(copy_via(&v, &mut dom_as_preserves).unwrap())).unwrap(),
|
||||
let v = value(vec![value(1),
|
||||
value(Embedded::new(Dom::Two)),
|
||||
value(2)]);
|
||||
assert_eq!(PackedWriter::encode_iovalue(©_via(&v, &mut dom_as_preserves).unwrap().into()).unwrap(),
|
||||
[0xb5, 0x91, 0xb3, 0x08, 68, 111, 109, 58, 58, 84, 119, 111, 0x92, 0x84]);
|
||||
}
|
||||
}
|
||||
|
|
|
@ -13,13 +13,13 @@ use crate::BytesBinarySource;
|
|||
use crate::Domain;
|
||||
use crate::DomainDecode;
|
||||
use crate::IOValue;
|
||||
use crate::PlainValue;
|
||||
use crate::Reader;
|
||||
use crate::Value;
|
||||
|
||||
pub fn from_bytes<'de, D: Domain, Dec: DomainDecode<D>>(
|
||||
bs: &'de [u8],
|
||||
decode_embedded: &mut Dec,
|
||||
) -> io::Result<PlainValue<'de, D>> {
|
||||
) -> io::Result<Value<D>> {
|
||||
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>>(
|
||||
bs: &'de [u8],
|
||||
decode_embedded: &mut Dec,
|
||||
) -> io::Result<PlainValue<'de, D>> {
|
||||
) -> io::Result<Value<D>> {
|
||||
super::BytesBinarySource::new(bs).packed().next(true, decode_embedded)
|
||||
}
|
||||
|
||||
|
|
|
@ -300,11 +300,11 @@ impl<'de, S: BinarySource<'de>> Reader<'de> for PackedReader<'de, S> {
|
|||
self.readbytes_into(&mut bs)?;
|
||||
Ok(Atom::Double(f64::from_bits(u64::from_be_bytes(bs))))
|
||||
}
|
||||
Tag::SmallInteger(v) => Ok(Atom::SignedInteger(v.into())),
|
||||
Tag::MediumInteger(count) => Ok(Atom::SignedInteger(self.read_signed_integer(count.into())?)),
|
||||
Tag::SmallInteger(v) => Ok(Atom::SignedInteger(Cow::Owned(v.into()))),
|
||||
Tag::MediumInteger(count) => Ok(Atom::SignedInteger(Cow::Owned(self.read_signed_integer(count.into())?))),
|
||||
Tag::SignedInteger => {
|
||||
let count = self.varint()?;
|
||||
Ok(Atom::SignedInteger(self.read_signed_integer(count)?))
|
||||
Ok(Atom::SignedInteger(Cow::Owned(self.read_signed_integer(count)?)))
|
||||
}
|
||||
Tag::String => {
|
||||
let count = self.varint()?;
|
||||
|
|
|
@ -14,16 +14,12 @@ use crate::DomainDecode;
|
|||
use crate::IOValue;
|
||||
use crate::NoEmbeddedDomainCodec;
|
||||
use crate::PackedWriter;
|
||||
use crate::PlainValue;
|
||||
use crate::SignedInteger;
|
||||
use crate::Value;
|
||||
use crate::ValueClass;
|
||||
use crate::ValueImpl;
|
||||
use crate::error;
|
||||
use crate::error::io_eof;
|
||||
use crate::iovalue;
|
||||
use crate::owned;
|
||||
use crate::shell;
|
||||
use crate::reader::NextToken;
|
||||
|
||||
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> {
|
||||
owned(View {
|
||||
fn value_clone(&self) -> Value<D> {
|
||||
Value::new(View {
|
||||
repr: self.repr.trim(self.annotation_offset .. self.value_range.end),
|
||||
annotation_offset: 0,
|
||||
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() {
|
||||
Tag::SmallInteger(_) => true,
|
||||
Tag::MediumInteger(_) => true,
|
||||
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::SmallInteger(v) => Some(Cow::Owned(v.into())),
|
||||
Tag::MediumInteger(n) => Some(Cow::Owned(self.signed_integer(self.value_range.start + 1, n as usize))),
|
||||
Tag::SignedInteger => {
|
||||
let (n, i) = self.varint();
|
||||
Some(self.signed_integer(i, n as usize))
|
||||
Some(Cow::Owned(self.signed_integer(i, n as usize)))
|
||||
}
|
||||
_ => None,
|
||||
}
|
||||
|
@ -400,9 +387,9 @@ impl<'de, Packed: AsRef<[u8]> + 'de, D: Domain> ValueImpl<D> for View<'de, Packe
|
|||
self.tag() == Tag::Record
|
||||
}
|
||||
|
||||
fn label(&self) -> Value<'_, D> {
|
||||
fn label(&self) -> Value<D> {
|
||||
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 {
|
||||
|
@ -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()
|
||||
}
|
||||
|
||||
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));
|
||||
match self.tag() {
|
||||
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
|
||||
}
|
||||
|
||||
fn has(&self, v: &dyn ValueImpl<D>) -> bool {
|
||||
self.iter().find(|e| v == &**e).is_some()
|
||||
fn has(&self, v: &Value<D>) -> bool {
|
||||
self.iter().find(|e| v == e).is_some()
|
||||
}
|
||||
|
||||
fn is_dictionary(&self) -> bool {
|
||||
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() {
|
||||
if &*kk == k { return Some(vv); }
|
||||
if k == &kk { return Some(vv); }
|
||||
}
|
||||
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") }
|
||||
Box::new(DictionaryAdapter(ViewIterator::inner_new(&self.repr, self.value_range.start + 1)))
|
||||
}
|
||||
|
||||
fn is_embedded(&self) -> bool {
|
||||
self.tag() == Tag::Embedded
|
||||
}
|
||||
|
||||
fn embedded(&self) -> Cow<'_, D> {
|
||||
if !self.is_embedded() { panic!("Not an embedded value") }
|
||||
match self.repr.index.embedded.as_ref() {
|
||||
fn as_embedded(&self) -> Option<Cow<'_, D>> {
|
||||
if self.tag() != Tag::Embedded { return None }
|
||||
Some(match self.repr.index.embedded.as_ref() {
|
||||
Some(e) => {
|
||||
Cow::Borrowed(e.iter().find_map(|(r, d)| {
|
||||
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();
|
||||
Cow::Owned(d)
|
||||
}
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
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,
|
||||
});
|
||||
let anns: Vec<IOValue> = AnnotationAdapter(ViewIterator::inner_new(&repr, self.annotation_offset))
|
||||
.map(|ann| iovalue(ann.into_owned()))
|
||||
.map(|ann| ann.into())
|
||||
.collect();
|
||||
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> {
|
||||
type Item = io::Result<Value<'de, D>>;
|
||||
type Item = io::Result<Value<D>>;
|
||||
|
||||
fn next(&mut self) -> Option<Self::Item> {
|
||||
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) {
|
||||
Ok(v) => {
|
||||
self.offset = v.value_range.end;
|
||||
Some(Ok(shell(v)))
|
||||
Some(Ok(Value::new(v)))
|
||||
}
|
||||
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>> {
|
||||
type Item = Value<'de, D>;
|
||||
type Item = Value<D>;
|
||||
|
||||
fn next(&mut self) -> Option<Self::Item> {
|
||||
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 {
|
||||
let v = View::inner_new(&self.repr, self.offset).unwrap();
|
||||
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>);
|
||||
|
||||
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> {
|
||||
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>);
|
||||
|
||||
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> {
|
||||
if let Ok(Tag::Annotation) = tag_at(self.0.repr.packed.as_ref(), self.0.offset) {
|
||||
|
|
|
@ -5,8 +5,8 @@ use std::marker::PhantomData;
|
|||
|
||||
use crate::BinarySource;
|
||||
use crate::CompoundClass;
|
||||
use crate::PlainValue;
|
||||
use crate::SignedInteger;
|
||||
use crate::Value;
|
||||
use crate::ValueClass;
|
||||
use crate::boundary as B;
|
||||
use crate::domain::Domain;
|
||||
|
@ -23,7 +23,6 @@ use crate::repr::Map;
|
|||
use crate::repr::Record;
|
||||
use crate::repr::Set;
|
||||
use crate::repr::ValueImpl;
|
||||
use crate::repr::owned;
|
||||
|
||||
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,
|
||||
read_annotations: bool,
|
||||
dec: &mut Dec,
|
||||
) -> io::Result<PlainValue<'produced, D>>
|
||||
) -> io::Result<Value<D>>
|
||||
{
|
||||
let (anns, v) = match read_annotations {
|
||||
true => self.gather_annotations()?.ok_or_else(io_eof)?,
|
||||
|
@ -161,7 +160,7 @@ pub trait Reader<'de> {
|
|||
self.open_embedded()?;
|
||||
let v = dec.decode_embedded(self, read_annotations)?;
|
||||
self.close_embedded()?;
|
||||
Box::new(Embedded::new(v))
|
||||
Value::new(Embedded::new(v))
|
||||
}
|
||||
ValueClass::Compound(CompoundClass::Record) => {
|
||||
let mut vs = Vec::new();
|
||||
|
@ -172,7 +171,7 @@ pub trait Reader<'de> {
|
|||
while !self.close_compound(&mut b, &B::Item::RecordField)? {
|
||||
vs.push(self.next(read_annotations, dec)?);
|
||||
}
|
||||
Box::new(Record::_from_vec(vs))
|
||||
Value::new(Record::_from_vec(vs))
|
||||
}
|
||||
ValueClass::Compound(CompoundClass::Sequence) => {
|
||||
let mut vs = Vec::new();
|
||||
|
@ -181,7 +180,7 @@ pub trait Reader<'de> {
|
|||
while !self.close_compound(&mut b, &B::Item::SequenceValue)? {
|
||||
vs.push(self.next(read_annotations, dec)?);
|
||||
}
|
||||
Box::new(vs)
|
||||
Value::new(vs)
|
||||
}
|
||||
ValueClass::Compound(CompoundClass::Set) => {
|
||||
let mut s = Set::new();
|
||||
|
@ -190,7 +189,7 @@ pub trait Reader<'de> {
|
|||
while !self.close_compound(&mut b, &B::Item::SetValue)? {
|
||||
s.insert(self.next(read_annotations, dec)?);
|
||||
}
|
||||
Box::new(s)
|
||||
Value::new(s)
|
||||
}
|
||||
ValueClass::Compound(CompoundClass::Dictionary) => {
|
||||
let mut d = Map::new();
|
||||
|
@ -202,13 +201,13 @@ pub trait Reader<'de> {
|
|||
self.boundary(&b)?;
|
||||
d.insert(k, self.next(read_annotations, dec)?);
|
||||
}
|
||||
Box::new(d)
|
||||
Value::new(d)
|
||||
}
|
||||
};
|
||||
if anns.is_empty() {
|
||||
Ok(value)
|
||||
} 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> {
|
||||
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()?)?) }
|
||||
|
|
File diff suppressed because it is too large
Load Diff
|
@ -11,13 +11,13 @@ use crate::BytesBinarySource;
|
|||
use crate::Domain;
|
||||
use crate::DomainDecode;
|
||||
use crate::IOValue;
|
||||
use crate::PlainValue;
|
||||
use crate::Reader;
|
||||
use crate::Value;
|
||||
|
||||
pub fn from_str<'de, D: Domain, Dec: DomainDecode<D>>(
|
||||
s: &'de str,
|
||||
decode_embedded: &mut Dec,
|
||||
) -> io::Result<PlainValue<'de, D>> {
|
||||
) -> io::Result<Value<D>> {
|
||||
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>>(
|
||||
s: &'de str,
|
||||
decode_embedded: &mut Dec,
|
||||
) -> io::Result<PlainValue<'de, D>> {
|
||||
) -> io::Result<Value<D>> {
|
||||
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)]
|
||||
mod formatting_tests {
|
||||
use crate::IOValue;
|
||||
use crate::Value;
|
||||
use crate::test_domain::Dom;
|
||||
use crate::ArcValue;
|
||||
|
||||
#[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]");
|
||||
}
|
||||
|
||||
#[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!(
|
||||
"[\n",
|
||||
" 1,\n",
|
||||
|
@ -84,7 +84,7 @@ mod unusual_float_tests {
|
|||
|
||||
fn d32(u: u32, expected: &str) {
|
||||
let v = f32::from_bits(u);
|
||||
let w = iovalue(v);
|
||||
let w = value(v).into();
|
||||
assert_eq!(format!("{:?}", w), expected);
|
||||
let x = expected.parse::<IOValue>().unwrap();
|
||||
assert_eq!(x, w);
|
||||
|
@ -92,7 +92,7 @@ mod unusual_float_tests {
|
|||
|
||||
fn d64(u: u64, expected: &str) {
|
||||
let v = f64::from_bits(u);
|
||||
let w = iovalue(v);
|
||||
let w = value(v).into();
|
||||
assert_eq!(format!("{:?}", w), expected);
|
||||
let x = expected.parse::<IOValue>().unwrap();
|
||||
assert_eq!(x, w);
|
||||
|
|
|
@ -266,9 +266,10 @@ impl<'de, S: BinarySource<'de>> TextReader<'de, S>
|
|||
return match NUMBER_RE.captures(&s) {
|
||||
None => Ok(Atom::Symbol(s.into())),
|
||||
Some(m) => match m.get(2) {
|
||||
None => Ok(Atom::SignedInteger(s.parse::<BigInt>().map_err(
|
||||
None => Ok(Atom::SignedInteger(Cow::Owned(
|
||||
s.parse::<BigInt>().map_err(
|
||||
|_| self.syntax_error(&format!(
|
||||
"Invalid signed-integer number: {:?}", s)))?.into())),
|
||||
"Invalid signed-integer number: {:?}", s)))?.into()))),
|
||||
Some(_) => {
|
||||
if let Some(maybe_f) = m.get(7) {
|
||||
let s = m[1].to_owned() + &m[3];
|
||||
|
|
|
@ -70,9 +70,9 @@ pub trait Writer {
|
|||
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,
|
||||
v: V,
|
||||
v: &dyn ValueImpl<D>,
|
||||
enc: &mut dyn DomainEncode<D>,
|
||||
) -> io::Result<()> {
|
||||
let annotations = v.annotations();
|
||||
|
@ -163,7 +163,7 @@ pub fn write_value<D: Domain, V: ValueImpl<D>>(
|
|||
}
|
||||
ValueClass::Embedded => {
|
||||
w.start_embedded()?;
|
||||
enc.encode_embedded(w, &v.embedded())?;
|
||||
enc.encode_embedded(w, &v.as_embedded().unwrap())?;
|
||||
w.end_embedded()?
|
||||
}
|
||||
}
|
||||
|
|
Loading…
Reference in New Issue