Good progress
This commit is contained in:
parent
025c5bb962
commit
1f7895e14e
|
@ -3,12 +3,12 @@ use std::io;
|
||||||
use super::Reader;
|
use super::Reader;
|
||||||
use super::Writer;
|
use super::Writer;
|
||||||
|
|
||||||
pub trait Domain: std::fmt::Debug + Eq + std::hash::Hash + Ord + Clone {
|
pub trait Domain<'de>: std::fmt::Debug + Eq + std::hash::Hash + Ord + Clone {
|
||||||
type Decode: for<'de> DomainDecode<'de, Self> + Default;
|
type Decode: DomainDecode<'de, Self> + Default;
|
||||||
type Encode: DomainEncode<Self> + Default;
|
type Encode: DomainEncode<'de, Self> + Default;
|
||||||
}
|
}
|
||||||
|
|
||||||
pub trait DomainDecode<'de, D: Domain> {
|
pub trait DomainDecode<'de, D: Domain<'de>> {
|
||||||
fn decode_embedded<R: Reader<'de> + ?Sized>(
|
fn decode_embedded<R: Reader<'de> + ?Sized>(
|
||||||
&mut self,
|
&mut self,
|
||||||
r: &mut R,
|
r: &mut R,
|
||||||
|
@ -16,7 +16,7 @@ pub trait DomainDecode<'de, D: Domain> {
|
||||||
) -> io::Result<D>;
|
) -> io::Result<D>;
|
||||||
}
|
}
|
||||||
|
|
||||||
pub trait DomainEncode<D: Domain> {
|
pub trait DomainEncode<'de, D: Domain<'de>> {
|
||||||
fn encode_embedded(
|
fn encode_embedded(
|
||||||
&mut self,
|
&mut self,
|
||||||
w: &mut dyn Writer,
|
w: &mut dyn Writer,
|
||||||
|
@ -24,7 +24,7 @@ pub trait DomainEncode<D: Domain> {
|
||||||
) -> io::Result<()>;
|
) -> io::Result<()>;
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'a, 'de, D: Domain, T: DomainDecode<'de, D>> DomainDecode<'de, D> for &'a mut T {
|
impl<'a, 'de, D: Domain<'de>, T: DomainDecode<'de, D>> DomainDecode<'de, D> for &'a mut T {
|
||||||
fn decode_embedded<R: Reader<'de> + ?Sized>(
|
fn decode_embedded<R: Reader<'de> + ?Sized>(
|
||||||
&mut self,
|
&mut self,
|
||||||
r: &mut R,
|
r: &mut R,
|
||||||
|
@ -34,7 +34,7 @@ impl<'a, 'de, D: Domain, T: DomainDecode<'de, D>> DomainDecode<'de, D> for &'a m
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'a, D: Domain, T: DomainEncode<D>> DomainEncode<D> for &'a mut T {
|
impl<'a, 'de, D: Domain<'de>, T: DomainEncode<'de, D>> DomainEncode<'de, D> for &'a mut T {
|
||||||
fn encode_embedded(
|
fn encode_embedded(
|
||||||
&mut self,
|
&mut self,
|
||||||
w: &mut dyn Writer,
|
w: &mut dyn Writer,
|
||||||
|
@ -47,7 +47,7 @@ impl<'a, D: Domain, T: DomainEncode<D>> DomainEncode<D> for &'a mut T {
|
||||||
#[derive(Default)]
|
#[derive(Default)]
|
||||||
pub struct DefaultDomainCodec;
|
pub struct DefaultDomainCodec;
|
||||||
|
|
||||||
impl<'de, D: Domain> DomainDecode<'de, D> for DefaultDomainCodec {
|
impl<'de, D: Domain<'de>> DomainDecode<'de, D> for DefaultDomainCodec {
|
||||||
fn decode_embedded<R: Reader<'de> + ?Sized>(
|
fn decode_embedded<R: Reader<'de> + ?Sized>(
|
||||||
&mut self,
|
&mut self,
|
||||||
r: &mut R,
|
r: &mut R,
|
||||||
|
@ -57,7 +57,7 @@ impl<'de, D: Domain> DomainDecode<'de, D> for DefaultDomainCodec {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<D: Domain> DomainEncode<D> for DefaultDomainCodec {
|
impl<'de, D: Domain<'de>> DomainEncode<'de, D> for DefaultDomainCodec {
|
||||||
fn encode_embedded(
|
fn encode_embedded(
|
||||||
&mut self,
|
&mut self,
|
||||||
w: &mut dyn Writer,
|
w: &mut dyn Writer,
|
||||||
|
@ -70,7 +70,7 @@ impl<D: Domain> DomainEncode<D> for DefaultDomainCodec {
|
||||||
#[derive(Default)]
|
#[derive(Default)]
|
||||||
pub struct DebugDomainCodec;
|
pub struct DebugDomainCodec;
|
||||||
|
|
||||||
impl<'de, Err: Into<io::Error>, D: Domain + std::str::FromStr<Err = Err>> DomainDecode<'de, D> for DebugDomainCodec {
|
impl<'de, Err: Into<io::Error>, D: Domain<'de> + std::str::FromStr<Err = Err>> DomainDecode<'de, D> for DebugDomainCodec {
|
||||||
fn decode_embedded<R: Reader<'de> + ?Sized>(
|
fn decode_embedded<R: Reader<'de> + ?Sized>(
|
||||||
&mut self,
|
&mut self,
|
||||||
r: &mut R,
|
r: &mut R,
|
||||||
|
@ -80,7 +80,7 @@ impl<'de, Err: Into<io::Error>, D: Domain + std::str::FromStr<Err = Err>> Domain
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<D: Domain> DomainEncode<D> for DebugDomainCodec {
|
impl<'de, D: Domain<'de>> DomainEncode<'de, D> for DebugDomainCodec {
|
||||||
fn encode_embedded(
|
fn encode_embedded(
|
||||||
&mut self,
|
&mut self,
|
||||||
w: &mut dyn Writer,
|
w: &mut dyn Writer,
|
||||||
|
@ -93,7 +93,7 @@ impl<D: Domain> DomainEncode<D> for DebugDomainCodec {
|
||||||
#[derive(Default)]
|
#[derive(Default)]
|
||||||
pub struct NoEmbeddedDomainCodec;
|
pub struct NoEmbeddedDomainCodec;
|
||||||
|
|
||||||
impl<'de, D: Domain> DomainDecode<'de, D> for NoEmbeddedDomainCodec {
|
impl<'de, D: Domain<'de>> DomainDecode<'de, D> for NoEmbeddedDomainCodec {
|
||||||
fn decode_embedded<R: Reader<'de> + ?Sized>(
|
fn decode_embedded<R: Reader<'de> + ?Sized>(
|
||||||
&mut self,
|
&mut self,
|
||||||
_r: &mut R,
|
_r: &mut R,
|
||||||
|
@ -103,7 +103,7 @@ impl<'de, D: Domain> DomainDecode<'de, D> for NoEmbeddedDomainCodec {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<D: Domain> DomainEncode<D> for NoEmbeddedDomainCodec {
|
impl<'de, D: Domain<'de>> DomainEncode<'de, D> for NoEmbeddedDomainCodec {
|
||||||
fn encode_embedded(
|
fn encode_embedded(
|
||||||
&mut self,
|
&mut self,
|
||||||
_w: &mut dyn Writer,
|
_w: &mut dyn Writer,
|
||||||
|
|
|
@ -9,23 +9,23 @@ use crate::ValueImpl;
|
||||||
use crate::Writer;
|
use crate::Writer;
|
||||||
use crate::ValueReader;
|
use crate::ValueReader;
|
||||||
|
|
||||||
pub struct IOValueDomainDecode<V: ValueReader>(PhantomData<V>);
|
pub struct IOValueDomainDecode<'de, V: ValueReader<'de>>(PhantomData<&'de V>);
|
||||||
pub struct IOValueDomainEncode<V: ValueImpl>(PhantomData<V>);
|
pub struct IOValueDomainEncode<'de, V: ValueImpl<'de>>(PhantomData<&'de V>);
|
||||||
|
|
||||||
impl<V: ValueReader> Default for IOValueDomainDecode<V> { fn default() -> Self { Self(PhantomData) } }
|
impl<'de, V: ValueReader<'de>> Default for IOValueDomainDecode<'de, V> { fn default() -> Self { Self(PhantomData) } }
|
||||||
impl<V: ValueImpl> Default for IOValueDomainEncode<V> { fn default() -> Self { Self(PhantomData) } }
|
impl<'de, V: ValueImpl<'de>> Default for IOValueDomainEncode<'de, V> { fn default() -> Self { Self(PhantomData) } }
|
||||||
|
|
||||||
impl<'de, V: ValueReader> DomainDecode<'de, <V::Impl<'de> as ValueImpl>::IOEmbedded> for IOValueDomainDecode<V> {
|
impl<'de, V: ValueReader<'de>> DomainDecode<'de, <V::Impl as ValueImpl<'de>>::IOEmbedded> for IOValueDomainDecode<'de, V> {
|
||||||
fn decode_embedded<R: Reader<'de> + ?Sized>(
|
fn decode_embedded<R: Reader<'de> + ?Sized>(
|
||||||
&mut self,
|
&mut self,
|
||||||
r: &mut R,
|
r: &mut R,
|
||||||
read_annotations: bool,
|
read_annotations: bool,
|
||||||
) -> io::Result<<V::Impl<'de> as ValueImpl>::IOEmbedded> {
|
) -> io::Result<<V::Impl as ValueImpl<'de>>::IOEmbedded> {
|
||||||
Ok(V::read_iovalue(r, read_annotations)?)
|
Ok(V::read_iovalue(r, read_annotations)?)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<V: ValueImpl> DomainEncode<V::IOEmbedded> for IOValueDomainEncode<V> {
|
impl<'de, V: ValueImpl<'de>> DomainEncode<'de, V::IOEmbedded> for IOValueDomainEncode<'de, V> {
|
||||||
fn encode_embedded(
|
fn encode_embedded(
|
||||||
&mut self,
|
&mut self,
|
||||||
w: &mut dyn Writer,
|
w: &mut dyn Writer,
|
||||||
|
@ -35,13 +35,13 @@ impl<V: ValueImpl> DomainEncode<V::IOEmbedded> for IOValueDomainEncode<V> {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
pub struct IOValues<'de, V: ValueReader, R: Reader<'de>> {
|
pub struct IOValues<'de, V: ValueReader<'de>, R: Reader<'de>> {
|
||||||
pub reader: R,
|
pub reader: R,
|
||||||
pub read_annotations: bool,
|
pub read_annotations: bool,
|
||||||
phantom: PhantomData<&'de V>,
|
phantom: PhantomData<&'de V>,
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'de, V: ValueReader, R: Reader<'de>> IOValues<'de, V, R> {
|
impl<'de, V: ValueReader<'de>, R: Reader<'de>> IOValues<'de, V, R> {
|
||||||
pub fn new(reader: R) -> Self {
|
pub fn new(reader: R) -> Self {
|
||||||
IOValues {
|
IOValues {
|
||||||
reader,
|
reader,
|
||||||
|
@ -56,8 +56,8 @@ impl<'de, V: ValueReader, R: Reader<'de>> IOValues<'de, V, R> {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'de, V: ValueReader, R: Reader<'de>> Iterator for IOValues<'de, V, R> {
|
impl<'de, V: ValueReader<'de>, R: Reader<'de>> Iterator for IOValues<'de, V, R> {
|
||||||
type Item = io::Result<<V::Impl<'de> as ValueImpl>::IOEmbedded>;
|
type Item = io::Result<<V::Impl as ValueImpl<'de>>::IOEmbedded>;
|
||||||
|
|
||||||
fn next(&mut self) -> Option<Self::Item> {
|
fn next(&mut self) -> Option<Self::Item> {
|
||||||
match self.reader.peek_class() {
|
match self.reader.peek_class() {
|
||||||
|
|
|
@ -5,6 +5,7 @@ pub mod float;
|
||||||
pub mod hex;
|
pub mod hex;
|
||||||
pub mod iovalue;
|
pub mod iovalue;
|
||||||
pub mod merge;
|
pub mod merge;
|
||||||
|
pub mod novalue;
|
||||||
pub mod packed;
|
pub mod packed;
|
||||||
pub mod reader;
|
pub mod reader;
|
||||||
pub mod repr;
|
pub mod repr;
|
||||||
|
@ -23,6 +24,7 @@ pub use iovalue::IOValueDomainEncode;
|
||||||
pub use iovalue::IOValues;
|
pub use iovalue::IOValues;
|
||||||
pub use merge::merge;
|
pub use merge::merge;
|
||||||
pub use merge::merge2;
|
pub use merge::merge2;
|
||||||
|
pub use novalue::NoValue;
|
||||||
pub use packed::PackedReader;
|
pub use packed::PackedReader;
|
||||||
pub use packed::PackedWriter;
|
pub use packed::PackedWriter;
|
||||||
pub use packed::annotated_from_bytes;
|
pub use packed::annotated_from_bytes;
|
||||||
|
@ -36,11 +38,14 @@ pub use repr::value_hash;
|
||||||
pub use shell::Annotations;
|
pub use shell::Annotations;
|
||||||
pub use shell::Atom;
|
pub use shell::Atom;
|
||||||
pub use shell::IOValue;
|
pub use shell::IOValue;
|
||||||
|
pub use shell::IOValueImpl;
|
||||||
|
pub use shell::IOValueIso;
|
||||||
pub use shell::Map;
|
pub use shell::Map;
|
||||||
pub use shell::Record;
|
pub use shell::Record;
|
||||||
pub use shell::Set;
|
pub use shell::Set;
|
||||||
pub use shell::Shell;
|
pub use shell::Shell;
|
||||||
pub use shell::ShellHandle;
|
pub use shell::ShellHandle;
|
||||||
|
pub use shell::iso_parse;
|
||||||
pub use signed_integer::SignedInteger;
|
pub use signed_integer::SignedInteger;
|
||||||
pub use source::BinarySource;
|
pub use source::BinarySource;
|
||||||
pub use source::BytesBinarySource;
|
pub use source::BytesBinarySource;
|
||||||
|
@ -63,45 +68,47 @@ mod demo {
|
||||||
// d.get(&k)
|
// d.get(&k)
|
||||||
// }
|
// }
|
||||||
|
|
||||||
// #[test] fn a() {
|
#[test] fn a() -> std::io::Result<()> {
|
||||||
// let l: PlainValue<NoValue> = "label".parse().unwrap();
|
let l: IOValue = "label".parse()?;
|
||||||
// let r = Record::new(l.value_clone(), vec![owned(1), owned(2), owned(3)]);
|
let r = IOValue::record(l, vec![1.into(), 2.into(), 3.into()]).wrap();
|
||||||
// let r2 = Record::new(l, vec![owned(1), owned(2), owned(4)]);
|
let r2 = IOValue::record(l, vec![1.into(), 2.into(), 4.into()]).wrap();
|
||||||
|
|
||||||
// let mut v: Map<PlainValue<NoValue>, PlainValue<NoValue>> = Map::new();
|
let mut v: Map<IOValueIso, IOValueIso> = Map::new();
|
||||||
// v.insert("\"abc\"".parse().unwrap(), "def".parse().unwrap());
|
v.insert(iso_parse("\"abc\"")?, iso_parse("def")?);
|
||||||
// v.insert("abc".parse().unwrap(), "DEF".parse().unwrap());
|
v.insert(iso_parse("abc")?, iso_parse("DEF")?);
|
||||||
// v.insert(owned(123), "xyz".parse().unwrap());
|
v.insert(Shell::from(123).into(), iso_parse("xyz")?);
|
||||||
// v.insert(owned(vec![1, 2, 3]), "{a: 1, b: 2}".parse().unwrap());
|
v.insert(Shell::from(vec![1, 2, 3]).into(), iso_parse("{a: 1, b: 2}")?);
|
||||||
// v.insert(owned(r2), "bbb".parse().unwrap());
|
v.insert(r2.into(), iso_parse("bbb")?);
|
||||||
// v.insert(owned(r), "<foo bar zot>".parse().unwrap());
|
v.insert(r.into(), iso_parse("<foo bar zot>")?);
|
||||||
// let w: &dyn ValueImpl<NoValue> = &v;
|
let w: IOValue = IOValueImpl::Dictionary(v).into();
|
||||||
// println!("GETw abc {:?}", w.get(&"abc"));
|
println!("GETw abc {:?}", w.get::<IOValue>(&"abc".into()));
|
||||||
// println!("GETw 123 {:?}", w.get(&123));
|
println!("GETw 123 {:?}", w.get::<IOValue>(&123.into()));
|
||||||
// println!("GETw qqq {:?}", w.get(&"qqq"));
|
println!("GETw qqq {:?}", w.get::<IOValue>(&"qqq".into()));
|
||||||
// println!("GETv abc {:?}", v.get(&*value(&"abc")));
|
println!("GETv abc {:?}", v.get(&IOValue::from("abc").iso()));
|
||||||
// println!("GETv 123 {:?}", v.get(&*value(&123)));
|
println!("GETv 123 {:?}", v.get(&IOValue::from(123).iso()));
|
||||||
// println!("GETv qqq {:?}", v.get(&*value(&"qqq")));
|
println!("GETv qqq {:?}", v.get(&IOValue::from("qqq").iso()));
|
||||||
// for (kk, vv) in w.entries() {
|
for (kk, vv) in w.entries() {
|
||||||
// println!("{:#?} ==> {:#?}", kk, vv);
|
println!("{:#?} ==> {:#?}", kk, vv);
|
||||||
// }
|
}
|
||||||
|
|
||||||
// // {
|
// {
|
||||||
// // use std::io::BufRead;
|
// use std::io::BufRead;
|
||||||
// // for line in std::io::stdin().lock().lines() {
|
// for line in std::io::stdin().lock().lines() {
|
||||||
// // let line = line.unwrap();
|
// let line = line?;
|
||||||
// // let key = line.parse::<PlainValue<NoValue>>().unwrap();
|
// let key = line.parse::<PlainValue<NoValue>>()?;
|
||||||
// // let val = w.get(&key);
|
// let val = w.get(&key);
|
||||||
// // println!("{:?} == {:?} ==> {:?} == {:?}", line, &key, val, getit(&v, &line));
|
// println!("{:?} == {:?} ==> {:?} == {:?}", line, &key, val, getit(&v, &line));
|
||||||
// // }
|
// }
|
||||||
// // }
|
// }
|
||||||
// }
|
|
||||||
|
|
||||||
// #[test] fn value_size() {
|
Ok(())
|
||||||
// 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>>>());
|
#[test] fn value_size() {
|
||||||
// }
|
println!("IOValue size {}", std::mem::size_of::<IOValue>());
|
||||||
|
println!("ShellHandle size {}", std::mem::size_of::<ShellHandle<IOValue>>());
|
||||||
|
println!("Shell size {}", std::mem::size_of::<Shell<IOValue>>());
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
#[cfg(test)]
|
#[cfg(test)]
|
||||||
|
@ -115,7 +122,7 @@ mod test_domain {
|
||||||
Two,
|
Two,
|
||||||
}
|
}
|
||||||
|
|
||||||
impl Domain for Dom {
|
impl<'de> Domain<'de> for Dom {
|
||||||
type Decode = DebugDomainCodec;
|
type Decode = DebugDomainCodec;
|
||||||
type Encode = DebugDomainCodec;
|
type Encode = DebugDomainCodec;
|
||||||
}
|
}
|
||||||
|
@ -133,13 +140,13 @@ mod test_domain {
|
||||||
|
|
||||||
struct DomCodec;
|
struct DomCodec;
|
||||||
|
|
||||||
impl DomainDecode<Dom> for DomCodec {
|
impl<'de> DomainDecode<'de, Dom> for DomCodec {
|
||||||
fn decode_embedded<'de, R: Reader<'de> + ?Sized>(
|
fn decode_embedded<R: Reader<'de> + ?Sized>(
|
||||||
&mut self,
|
&mut self,
|
||||||
r: &mut R,
|
r: &mut R,
|
||||||
_read_annotations: bool,
|
_read_annotations: bool,
|
||||||
) -> io::Result<Dom> {
|
) -> io::Result<Dom> {
|
||||||
let v = read_iovalue(r, false)?;
|
let v = IOValue::read(r, false)?;
|
||||||
if v.value().as_bytestring().is_some() {
|
if v.value().as_bytestring().is_some() {
|
||||||
Ok(Dom::One)
|
Ok(Dom::One)
|
||||||
} else {
|
} else {
|
||||||
|
@ -148,7 +155,7 @@ mod test_domain {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl DomainEncode<Dom> for DomCodec {
|
impl<'de> DomainEncode<'de, Dom> for DomCodec {
|
||||||
fn encode_embedded(
|
fn encode_embedded(
|
||||||
&mut self,
|
&mut self,
|
||||||
w: &mut dyn Writer,
|
w: &mut dyn Writer,
|
||||||
|
@ -173,7 +180,7 @@ mod test_domain {
|
||||||
vec![SignedInteger::from(1).into(),
|
vec![SignedInteger::from(1).into(),
|
||||||
Shell::embedded(Dom::One),
|
Shell::embedded(Dom::One),
|
||||||
SignedInteger::from(2).into()]).wrap();
|
SignedInteger::from(2).into()]).wrap();
|
||||||
assert_eq!(PackedWriter::encode_iovalue(&IOValue::copy::<Shell::<Dom>, _, _>(&v, &mut dom_as_preserves).unwrap()).unwrap(),
|
assert_eq!(PackedWriter::encode(&IOValue::copy::<Shell::<Dom>, _, _>(&v, &mut dom_as_preserves).unwrap()).unwrap(),
|
||||||
[0xb5, 0x91, 0xb2, 0x04, 255, 255, 255, 255, 0x92, 0x84]);
|
[0xb5, 0x91, 0xb2, 0x04, 255, 255, 255, 255, 0x92, 0x84]);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -182,7 +189,7 @@ mod test_domain {
|
||||||
vec![SignedInteger::from(1).into(),
|
vec![SignedInteger::from(1).into(),
|
||||||
Shell::embedded(Dom::Two),
|
Shell::embedded(Dom::Two),
|
||||||
SignedInteger::from(2).into()]).wrap();
|
SignedInteger::from(2).into()]).wrap();
|
||||||
assert_eq!(PackedWriter::encode_iovalue(&IOValue::copy::<Shell::<Dom>, _, _>(&v, &mut dom_as_preserves).unwrap()).unwrap(),
|
assert_eq!(PackedWriter::encode(&IOValue::copy::<Shell::<Dom>, _, _>(&v, &mut dom_as_preserves).unwrap()).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]);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
|
@ -16,16 +16,16 @@ use crate::Shell;
|
||||||
use crate::ShellHandle;
|
use crate::ShellHandle;
|
||||||
use crate::ValueReader;
|
use crate::ValueReader;
|
||||||
|
|
||||||
pub fn from_bytes<'de, D: Domain, Dec: DomainDecode<'de, D>>(
|
pub fn from_bytes<'de, D: Domain<'de>, Dec: DomainDecode<'de, D>>(
|
||||||
bs: &'de [u8],
|
bs: &'de [u8],
|
||||||
decode_embedded: &mut Dec,
|
decode_embedded: &mut Dec,
|
||||||
) -> io::Result<ShellHandle<'de, D>> {
|
) -> io::Result<ShellHandle<'de, D>> {
|
||||||
Ok(Shell::read(&mut BytesBinarySource::new(bs).packed(), false, decode_embedded)?)
|
Ok(Shell::read_domain(&mut BytesBinarySource::new(bs).packed(), false, decode_embedded)?)
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn annotated_from_bytes<'de, D: Domain, Dec: DomainDecode<'de, D>>(
|
pub fn annotated_from_bytes<'de, D: Domain<'de>, Dec: DomainDecode<'de, D>>(
|
||||||
bs: &'de [u8],
|
bs: &'de [u8],
|
||||||
decode_embedded: &mut Dec,
|
decode_embedded: &mut Dec,
|
||||||
) -> io::Result<ShellHandle<'de, D>> {
|
) -> io::Result<ShellHandle<'de, D>> {
|
||||||
Ok(Shell::read(&mut BytesBinarySource::new(bs).packed(), true, decode_embedded)?)
|
Ok(Shell::read_domain(&mut BytesBinarySource::new(bs).packed(), true, decode_embedded)?)
|
||||||
}
|
}
|
||||||
|
|
|
@ -14,15 +14,18 @@ use crate::BinarySource;
|
||||||
use crate::BytesBinarySource;
|
use crate::BytesBinarySource;
|
||||||
use crate::Domain;
|
use crate::Domain;
|
||||||
use crate::DomainDecode;
|
use crate::DomainDecode;
|
||||||
|
use crate::DomainEncode;
|
||||||
use crate::NoEmbeddedDomainCodec;
|
use crate::NoEmbeddedDomainCodec;
|
||||||
use crate::PackedWriter;
|
use crate::PackedWriter;
|
||||||
use crate::SignedInteger;
|
use crate::SignedInteger;
|
||||||
use crate::ValueClass;
|
use crate::ValueClass;
|
||||||
use crate::ValueImpl;
|
use crate::ValueImpl;
|
||||||
|
use crate::Writer;
|
||||||
use crate::error;
|
use crate::error;
|
||||||
use crate::error::io_eof;
|
use crate::error::io_eof;
|
||||||
use crate::reader::NextToken;
|
use crate::reader::NextToken;
|
||||||
use crate::value_eq;
|
use crate::value_eq;
|
||||||
|
use crate::write_value;
|
||||||
|
|
||||||
use super::constants::Tag;
|
use super::constants::Tag;
|
||||||
|
|
||||||
|
@ -38,7 +41,7 @@ struct IndexedRepr<'de, D> {
|
||||||
phantom: PhantomData<&'de ()>,
|
phantom: PhantomData<&'de ()>,
|
||||||
}
|
}
|
||||||
|
|
||||||
pub struct View<'de, D: Domain> {
|
pub struct View<'de, D: Domain<'de>> {
|
||||||
repr: Arc<IndexedRepr<'de, D>>,
|
repr: Arc<IndexedRepr<'de, D>>,
|
||||||
annotation_offset: usize,
|
annotation_offset: usize,
|
||||||
value_range: Range<usize>,
|
value_range: Range<usize>,
|
||||||
|
@ -53,7 +56,7 @@ struct IndexInProgress<'dec, D, Dec> {
|
||||||
dec: &'dec mut Dec,
|
dec: &'dec mut Dec,
|
||||||
}
|
}
|
||||||
|
|
||||||
struct Indexer<'de, 'dec, D: Domain, Dec: DomainDecode<'de, D>> {
|
struct Indexer<'de, 'dec, D: Domain<'de>, Dec: DomainDecode<'de, D>> {
|
||||||
packed: &'de [u8],
|
packed: &'de [u8],
|
||||||
offset: usize,
|
offset: usize,
|
||||||
index: Option<IndexInProgress<'dec, D, Dec>>,
|
index: Option<IndexInProgress<'dec, D, Dec>>,
|
||||||
|
@ -86,7 +89,7 @@ fn varint(packed: &[u8], mut i: usize) -> io::Result<(u64, usize)> {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'de, 'dec, D: Domain, Dec: DomainDecode<'de, D>> Indexer<'de, 'dec, D, Dec> {
|
impl<'de, 'dec, D: Domain<'de>, Dec: DomainDecode<'de, D>> Indexer<'de, 'dec, D, Dec> {
|
||||||
fn skip_annotations(&mut self) -> io::Result<()> {
|
fn skip_annotations(&mut self) -> io::Result<()> {
|
||||||
loop {
|
loop {
|
||||||
if tag_at(&self.packed, self.offset)? == Tag::Annotation {
|
if tag_at(&self.packed, self.offset)? == Tag::Annotation {
|
||||||
|
@ -167,7 +170,7 @@ impl<'de, 'dec, D: Domain, Dec: DomainDecode<'de, D>> Indexer<'de, 'dec, D, Dec>
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'de, D: Domain> IndexedRepr<'de, D> {
|
impl<'de, D: Domain<'de>> IndexedRepr<'de, D> {
|
||||||
fn trim(&self, range: Range<usize>) -> Arc<IndexedRepr<'static, D>> {
|
fn trim(&self, range: Range<usize>) -> Arc<IndexedRepr<'static, D>> {
|
||||||
Arc::new(IndexedRepr {
|
Arc::new(IndexedRepr {
|
||||||
packed: self.packed.as_ref()[range.clone()].to_vec().into(),
|
packed: self.packed.as_ref()[range.clone()].to_vec().into(),
|
||||||
|
@ -190,19 +193,19 @@ impl<'de, D: Domain> IndexedRepr<'de, D> {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'de, D: Domain> View<'de, D> {
|
impl<'de, D: Domain<'de>> View<'de, D> {
|
||||||
pub fn new<Dec: DomainDecode<'de, D>>(packed: Cow<'de, [u8]>, dec: Option<&mut Dec>) -> io::Result<Self> {
|
pub fn new<Dec: DomainDecode<'de, D>>(packed: Cow<'de, [u8]>, dec: Option<&mut Dec>) -> io::Result<Self> {
|
||||||
Self::new_offset(packed, dec, 0)
|
Self::new_offset(packed, dec, 0)
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn trim(&self) -> View<'static, D> {
|
// pub fn trim(&self) -> View<'static, D> {
|
||||||
View {
|
// 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
|
||||||
.. self.value_range.end - self.annotation_offset),
|
// .. self.value_range.end - self.annotation_offset),
|
||||||
}
|
// }
|
||||||
}
|
// }
|
||||||
|
|
||||||
pub fn new_offset<Dec: DomainDecode<'de, D>>(packed: Cow<'de, [u8]>, dec: Option<&mut Dec>, offset: usize) -> io::Result<Self> {
|
pub fn new_offset<Dec: DomainDecode<'de, D>>(packed: Cow<'de, [u8]>, dec: Option<&mut Dec>, offset: usize) -> io::Result<Self> {
|
||||||
let mut indexer = Indexer {
|
let mut indexer = Indexer {
|
||||||
|
@ -299,12 +302,12 @@ impl<'de, D: Domain> View<'de, D> {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'de, D: Domain> Domain for View<'de, D> {
|
impl<'de, D: Domain<'de>> Domain<'de> for View<'de, D> {
|
||||||
type Decode = NoEmbeddedDomainCodec;
|
type Decode = NoEmbeddedDomainCodec;
|
||||||
type Encode = NoEmbeddedDomainCodec;
|
type Encode = NoEmbeddedDomainCodec;
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'de, D: Domain> Clone for View<'de, D> {
|
impl<'de, D: Domain<'de>> Clone for View<'de, D> {
|
||||||
fn clone(&self) -> Self {
|
fn clone(&self) -> Self {
|
||||||
View {
|
View {
|
||||||
repr: self.repr.clone(),
|
repr: self.repr.clone(),
|
||||||
|
@ -314,10 +317,10 @@ impl<'de, D: Domain> Clone for View<'de, D> {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'de, D: Domain> ValueImpl for View<'de, D> {
|
impl<'de, D: Domain<'de>> ValueImpl<'de> for View<'de, D> {
|
||||||
type Handle = Self;
|
type Handle = Self;
|
||||||
type Embedded = D;
|
type Embedded = D;
|
||||||
type Mapped<E: Domain> = View<'de, E>;
|
type Mapped<E: Domain<'de>> = View<'de, E>;
|
||||||
type Items<'a> = ViewIterator<IndexedRepr<'de, D>> where Self: 'a;
|
type Items<'a> = ViewIterator<IndexedRepr<'de, D>> where Self: 'a;
|
||||||
type Entries<'a> = DictionaryAdapter<IndexedRepr<'de, D>> where Self: 'a;
|
type Entries<'a> = DictionaryAdapter<IndexedRepr<'de, D>> where Self: 'a;
|
||||||
type IOEmbedded = IOView<'de>;
|
type IOEmbedded = IOView<'de>;
|
||||||
|
@ -326,7 +329,7 @@ impl<'de, D: Domain> ValueImpl for View<'de, D> {
|
||||||
self
|
self
|
||||||
}
|
}
|
||||||
|
|
||||||
fn write(&self, w: &mut dyn crate::Writer, enc: &mut dyn crate::DomainEncode<D>) -> io::Result<()> {
|
fn write(&self, w: &mut dyn Writer, enc: &mut dyn DomainEncode<D>) -> io::Result<()> {
|
||||||
match w.specialized() {
|
match w.specialized() {
|
||||||
Some(("packed", mut w)) => {
|
Some(("packed", mut w)) => {
|
||||||
if let Some(embedded) = &self.repr.index.embedded {
|
if let Some(embedded) = &self.repr.index.embedded {
|
||||||
|
@ -342,7 +345,7 @@ impl<'de, D: Domain> ValueImpl for View<'de, D> {
|
||||||
w.write_all(&self.repr.packed.as_ref()[self.annotation_offset .. self.value_range.end])
|
w.write_all(&self.repr.packed.as_ref()[self.annotation_offset .. self.value_range.end])
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
_ => crate::write_value(w, self, enc)
|
_ => write_value(w, self, enc)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -454,7 +457,7 @@ impl<'de, D: Domain> ValueImpl for View<'de, D> {
|
||||||
self.tag() == Tag::Set
|
self.tag() == Tag::Set
|
||||||
}
|
}
|
||||||
|
|
||||||
fn has<E: ValueImpl<Embedded = Self::Embedded>>(&self, v: &E::Handle) -> bool {
|
fn has<E: ValueImpl<'de, Embedded = Self::Embedded>>(&self, v: &E::Handle) -> bool {
|
||||||
self.iter().find(|e| value_eq(v.borrow(), e)).is_some()
|
self.iter().find(|e| value_eq(v.borrow(), e)).is_some()
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -462,7 +465,7 @@ impl<'de, D: Domain> ValueImpl for View<'de, D> {
|
||||||
self.tag() == Tag::Dictionary
|
self.tag() == Tag::Dictionary
|
||||||
}
|
}
|
||||||
|
|
||||||
fn get<K: ValueImpl<Embedded = Self::Embedded>>(&self, k: &K::Handle) -> Option<Self::Handle> {
|
fn get<K: ValueImpl<'de, Embedded = Self::Embedded>>(&self, k: &K::Handle) -> Option<Self::Handle> {
|
||||||
for (kk, vv) in self.entries() {
|
for (kk, vv) in self.entries() {
|
||||||
if value_eq(k.borrow(), &kk) { return Some(vv); }
|
if value_eq(k.borrow(), &kk) { return Some(vv); }
|
||||||
}
|
}
|
||||||
|
@ -492,7 +495,7 @@ impl<'de, D: Domain> ValueImpl for View<'de, D> {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
fn annotations(&self) -> Option<Cow<'_, [<Self::Mapped<Self::IOEmbedded> as ValueImpl>::Handle]>> {
|
fn annotations(&self) -> Option<Cow<'_, [<Self::Mapped<Self::IOEmbedded> as ValueImpl<'de>>::Handle]>> {
|
||||||
if self.value_range.start == self.annotation_offset {
|
if self.value_range.start == self.annotation_offset {
|
||||||
None
|
None
|
||||||
} else {
|
} else {
|
||||||
|
@ -515,20 +518,20 @@ impl<'de, D: Domain> ValueImpl for View<'de, D> {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
fn copy<E: ValueImpl, F, Err>(w: &E::Handle, f: &mut F) -> Result<Self::Handle, Err>
|
fn copy<E: ValueImpl<'de>, F, Err>(w: &E::Handle, f: &mut F) -> Result<Self::Handle, Err>
|
||||||
where
|
where
|
||||||
F: FnMut(&E::Embedded) -> Result<Self::Handle, Err> {
|
F: FnMut(&E::Embedded) -> Result<Self::Handle, Err> {
|
||||||
todo!()
|
todo!()
|
||||||
}
|
}
|
||||||
|
|
||||||
fn map_embedded<E: Domain, F, Err>(v: &Self::Handle, f: &mut F) -> Result<<Self::Mapped<E> as ValueImpl>::Handle, Err>
|
fn map_embedded<E: Domain<'de>, F, Err>(v: &Self::Handle, f: &mut F) -> Result<<Self::Mapped<E> as ValueImpl<'de>>::Handle, Err>
|
||||||
where
|
where
|
||||||
F: FnMut(&Self::Embedded) -> Result<E, Err> {
|
F: FnMut(&Self::Embedded) -> Result<E, Err> {
|
||||||
todo!()
|
todo!()
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
crate::impl_value_methods!({'de, D: Domain}, View<'de, D>);
|
crate::impl_value_methods!({'de, D: Domain<'de>}, View<'de, D>);
|
||||||
|
|
||||||
impl<'de> Clone for IOView<'de> {
|
impl<'de> Clone for IOView<'de> {
|
||||||
fn clone(&self) -> Self {
|
fn clone(&self) -> Self {
|
||||||
|
@ -568,7 +571,7 @@ impl<'de> PartialEq for IOView<'de> {
|
||||||
|
|
||||||
impl<'de> Eq for IOView<'de> {}
|
impl<'de> Eq for IOView<'de> {}
|
||||||
|
|
||||||
impl<'de> Domain for IOView<'de> {
|
impl<'de> Domain<'de> for IOView<'de> {
|
||||||
type Decode = NoEmbeddedDomainCodec;
|
type Decode = NoEmbeddedDomainCodec;
|
||||||
type Encode = NoEmbeddedDomainCodec;
|
type Encode = NoEmbeddedDomainCodec;
|
||||||
}
|
}
|
||||||
|
@ -591,14 +594,14 @@ impl<'de> AsRef<IOViewImpl<'de>> for IOView<'de> {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
pub struct ViewStream<'de, 'dec, D: Domain, Dec: DomainDecode<'de, D> = <D as Domain>::Decode> {
|
pub struct ViewStream<'de, 'dec, D: Domain<'de>, Dec: DomainDecode<'de, D> = <D as Domain<'de>>::Decode> {
|
||||||
buf: Cow<'de, [u8]>,
|
buf: Cow<'de, [u8]>,
|
||||||
dec: Option<&'dec mut Dec>,
|
dec: Option<&'dec mut Dec>,
|
||||||
offset: usize,
|
offset: usize,
|
||||||
phantom: PhantomData<&'de D>,
|
phantom: PhantomData<&'de D>,
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'de, 'dec, D: Domain, Dec: DomainDecode<'de, D>> ViewStream<'de, 'dec, D, Dec> {
|
impl<'de, 'dec, D: Domain<'de>, Dec: DomainDecode<'de, D>> ViewStream<'de, 'dec, D, Dec> {
|
||||||
pub fn new(buf: Cow<'de, [u8]>, dec: Option<&'dec mut Dec>) -> Self {
|
pub fn new(buf: Cow<'de, [u8]>, dec: Option<&'dec mut Dec>) -> Self {
|
||||||
ViewStream {
|
ViewStream {
|
||||||
buf,
|
buf,
|
||||||
|
@ -609,7 +612,7 @@ impl<'de, 'dec, D: Domain, Dec: DomainDecode<'de, D>> ViewStream<'de, 'dec, D, D
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'de, 'dec, D: Domain, Dec: DomainDecode<'de, D>> Iterator for ViewStream<'de, 'dec, D, Dec> {
|
impl<'de, 'dec, D: Domain<'de>, Dec: DomainDecode<'de, D>> Iterator for ViewStream<'de, 'dec, D, Dec> {
|
||||||
type Item = io::Result<View<'de, D>>;
|
type Item = io::Result<View<'de, D>>;
|
||||||
|
|
||||||
fn next(&mut self) -> Option<Self::Item> {
|
fn next(&mut self) -> Option<Self::Item> {
|
||||||
|
@ -632,13 +635,13 @@ pub struct ViewIterator<Repr> {
|
||||||
offset: usize,
|
offset: usize,
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'de, D: Domain> ViewIterator<IndexedRepr<'de, D>> {
|
impl<'de, D: Domain<'de>> ViewIterator<IndexedRepr<'de, D>> {
|
||||||
pub fn inner_new(repr: &Arc<IndexedRepr<'de, D>>, offset: usize) -> Self {
|
pub fn inner_new(repr: &Arc<IndexedRepr<'de, D>>, offset: usize) -> Self {
|
||||||
ViewIterator { repr: Arc::clone(repr), offset }
|
ViewIterator { repr: Arc::clone(repr), offset }
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'de, D: Domain> Iterator for ViewIterator<IndexedRepr<'de, D>> {
|
impl<'de, D: Domain<'de>> Iterator for ViewIterator<IndexedRepr<'de, D>> {
|
||||||
type Item = View<'de, D>;
|
type Item = View<'de, D>;
|
||||||
|
|
||||||
fn next(&mut self) -> Option<Self::Item> {
|
fn next(&mut self) -> Option<Self::Item> {
|
||||||
|
@ -654,7 +657,7 @@ impl<'de, D: Domain> Iterator for ViewIterator<IndexedRepr<'de, D>> {
|
||||||
|
|
||||||
pub struct DictionaryAdapter<Repr>(pub ViewIterator<Repr>);
|
pub struct DictionaryAdapter<Repr>(pub ViewIterator<Repr>);
|
||||||
|
|
||||||
impl<'de, D: Domain> Iterator for DictionaryAdapter<IndexedRepr<'de, D>> {
|
impl<'de, D: Domain<'de>> Iterator for DictionaryAdapter<IndexedRepr<'de, D>> {
|
||||||
type Item = (View<'de, D>, View<'de, D>);
|
type Item = (View<'de, D>, View<'de, D>);
|
||||||
|
|
||||||
fn next(&mut self) -> Option<Self::Item> {
|
fn next(&mut self) -> Option<Self::Item> {
|
||||||
|
|
|
@ -4,7 +4,7 @@ use std::convert::TryInto;
|
||||||
use std::io;
|
use std::io;
|
||||||
use std::io::Write;
|
use std::io::Write;
|
||||||
use super::constants::Tag;
|
use super::constants::Tag;
|
||||||
use crate::{boundary as B, ValueImpl, DomainEncode, Writer};
|
use crate::{boundary as B, ValueImpl, DomainEncode, Writer, DefaultDomainCodec};
|
||||||
|
|
||||||
struct Buffers<W: io::Write> {
|
struct Buffers<W: io::Write> {
|
||||||
base: W,
|
base: W,
|
||||||
|
@ -36,7 +36,7 @@ pub struct PackedWriter<W: io::Write>(Buffers<W>);
|
||||||
|
|
||||||
impl PackedWriter<&mut Vec<u8>> {
|
impl PackedWriter<&mut Vec<u8>> {
|
||||||
#[inline(always)]
|
#[inline(always)]
|
||||||
pub fn encode<V: ValueImpl, Enc: DomainEncode<V::Embedded>>(
|
pub fn encode_domain<'de, V: ValueImpl<'de>, Enc: DomainEncode<'de, V::Embedded>>(
|
||||||
enc: &mut Enc,
|
enc: &mut Enc,
|
||||||
v: &V,
|
v: &V,
|
||||||
) -> io::Result<Vec<u8>> {
|
) -> io::Result<Vec<u8>> {
|
||||||
|
@ -44,6 +44,11 @@ impl PackedWriter<&mut Vec<u8>> {
|
||||||
v.write(&mut PackedWriter::new(&mut buf), enc)?;
|
v.write(&mut PackedWriter::new(&mut buf), enc)?;
|
||||||
Ok(buf)
|
Ok(buf)
|
||||||
}
|
}
|
||||||
|
|
||||||
|
#[inline(always)]
|
||||||
|
pub fn encode<'de, V: ValueImpl<'de>>(v: &V) -> io::Result<Vec<u8>> {
|
||||||
|
Self::encode_domain(&mut DefaultDomainCodec, v)
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn varint<W: io::Write>(w: &mut W, mut v: u64) -> io::Result<usize> {
|
pub fn varint<W: io::Write>(w: &mut W, mut v: u64) -> io::Result<usize> {
|
||||||
|
|
|
@ -7,6 +7,7 @@ use std::hash::Hash;
|
||||||
use std::hash::Hasher;
|
use std::hash::Hasher;
|
||||||
use std::io;
|
use std::io;
|
||||||
|
|
||||||
|
use crate::DefaultDomainCodec;
|
||||||
use crate::DomainDecode;
|
use crate::DomainDecode;
|
||||||
use crate::Reader;
|
use crate::Reader;
|
||||||
use crate::error::ReadError;
|
use crate::error::ReadError;
|
||||||
|
@ -23,31 +24,38 @@ use crate::write_value;
|
||||||
|
|
||||||
use super::float::{eq_f32, eq_f64, cmp_f32, cmp_f64};
|
use super::float::{eq_f32, eq_f64, cmp_f32, cmp_f64};
|
||||||
|
|
||||||
pub trait ValueReader {
|
pub trait ValueReader<'de> {
|
||||||
type Impl<'de>: ValueImpl;
|
type Impl: ValueImpl<'de>;
|
||||||
|
|
||||||
fn read_impl<'de, R: Reader<'de> + ?Sized, Dec: DomainDecode<<Self::Impl<'de> as ValueImpl>::Embedded>>(
|
fn read_impl<R: Reader<'de> + ?Sized, Dec: DomainDecode<'de, <Self::Impl as ValueImpl<'de>>::Embedded>>(
|
||||||
r: &mut R,
|
r: &mut R,
|
||||||
read_annotations: bool,
|
read_annotations: bool,
|
||||||
dec: &mut Dec,
|
dec: &mut Dec,
|
||||||
) -> Result<Self::Impl<'de>, ReadError>;
|
) -> Result<Self::Impl, ReadError>;
|
||||||
|
|
||||||
fn read<'de, R: Reader<'de> + ?Sized, Dec: DomainDecode<<Self::Impl<'de> as ValueImpl>::Embedded>>(
|
fn read_domain<R: Reader<'de> + ?Sized, Dec: DomainDecode<'de, <Self::Impl as ValueImpl<'de>>::Embedded>>(
|
||||||
r: &mut R,
|
r: &mut R,
|
||||||
read_annotations: bool,
|
read_annotations: bool,
|
||||||
dec: &mut Dec,
|
dec: &mut Dec,
|
||||||
) -> Result<<Self::Impl<'de> as ValueImpl>::Handle, ReadError> {
|
) -> Result<<Self::Impl as ValueImpl<'de>>::Handle, ReadError> {
|
||||||
Ok(Self::read_impl(r, read_annotations, dec)?.wrap())
|
Ok(Self::read_impl(r, read_annotations, dec)?.wrap())
|
||||||
}
|
}
|
||||||
|
|
||||||
fn read_iovalue<'de, R: Reader<'de> + ?Sized>(
|
fn read<R: Reader<'de> + ?Sized>(
|
||||||
r: &mut R,
|
r: &mut R,
|
||||||
read_annotations: bool,
|
read_annotations: bool,
|
||||||
) -> Result<<Self::Impl<'de> as ValueImpl>::IOEmbedded, ReadError>;
|
) -> Result<<Self::Impl as ValueImpl<'de>>::Handle, ReadError> {
|
||||||
|
Self::read_domain(r, read_annotations, &mut DefaultDomainCodec)
|
||||||
|
}
|
||||||
|
|
||||||
fn gather_annotations<'de, R: Reader<'de> + ?Sized>(
|
fn read_iovalue<R: Reader<'de> + ?Sized>(
|
||||||
r: &mut R,
|
r: &mut R,
|
||||||
) -> io::Result<Option<(Vec<<<Self::Impl<'de> as ValueImpl>::Mapped<<Self::Impl<'de> as ValueImpl>::IOEmbedded> as ValueImpl>::Handle>, ValueClass)>> {
|
read_annotations: bool,
|
||||||
|
) -> Result<<Self::Impl as ValueImpl<'de>>::IOEmbedded, ReadError>;
|
||||||
|
|
||||||
|
fn gather_annotations<R: Reader<'de> + ?Sized>(
|
||||||
|
r: &mut R,
|
||||||
|
) -> io::Result<Option<(Vec<<<Self::Impl as ValueImpl<'de>>::Mapped<<Self::Impl as ValueImpl<'de>>::IOEmbedded> as ValueImpl<'de>>::Handle>, ValueClass)>> {
|
||||||
let mut anns = Vec::new();
|
let mut anns = Vec::new();
|
||||||
loop {
|
loop {
|
||||||
match r.peek_class()? {
|
match r.peek_class()? {
|
||||||
|
@ -64,17 +72,17 @@ pub trait ValueReader {
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Atomic values from the specification.
|
/// Atomic values from the specification.
|
||||||
pub trait ValueImpl: Sized {
|
pub trait ValueImpl<'de>: Sized {
|
||||||
type Handle: Borrow<Self> + Clone + From<Self> + Hash + Eq + Ord + PartialEq + PartialOrd;
|
type Handle: Borrow<Self> + Clone + From<Self> + Hash + Eq + Ord + PartialEq + PartialOrd;
|
||||||
type Embedded: Domain;
|
type Embedded: Domain<'de>;
|
||||||
type Mapped<E: Domain>: ValueImpl<Embedded = E>;
|
type Mapped<E: Domain<'de>>: ValueImpl<'de, Embedded = E>;
|
||||||
type Items<'a>: Iterator<Item = Self::Handle> + 'a where Self: 'a;
|
type Items<'a>: Iterator<Item = Self::Handle> + 'a where Self: 'a;
|
||||||
type Entries<'a>: Iterator<Item = (Self::Handle, Self::Handle)> + 'a where Self: 'a;
|
type Entries<'a>: Iterator<Item = (Self::Handle, Self::Handle)> + 'a where Self: 'a;
|
||||||
|
|
||||||
type IOEmbedded: From<<Self::Mapped<Self::IOEmbedded> as ValueImpl>::Handle> +
|
type IOEmbedded: From<<Self::Mapped<Self::IOEmbedded> as ValueImpl<'de>>::Handle> +
|
||||||
Into<<Self::Mapped<Self::IOEmbedded> as ValueImpl>::Handle> +
|
Into<<Self::Mapped<Self::IOEmbedded> as ValueImpl<'de>>::Handle> +
|
||||||
AsRef<<Self::Mapped<Self::IOEmbedded> as ValueImpl>::Handle> +
|
AsRef<<Self::Mapped<Self::IOEmbedded> as ValueImpl<'de>>::Handle> +
|
||||||
Domain;
|
Domain<'de>;
|
||||||
|
|
||||||
fn wrap(self) -> Self::Handle;
|
fn wrap(self) -> Self::Handle;
|
||||||
|
|
||||||
|
@ -114,29 +122,29 @@ pub trait ValueImpl: Sized {
|
||||||
fn iter(&self) -> Self::Items<'_>;
|
fn iter(&self) -> Self::Items<'_>;
|
||||||
|
|
||||||
fn is_set(&self) -> bool;
|
fn is_set(&self) -> bool;
|
||||||
fn has<E: ValueImpl<Embedded = Self::Embedded>>(&self, _v: &E::Handle) -> bool;
|
fn has<E: ValueImpl<'de, Embedded = Self::Embedded>>(&self, _v: &E::Handle) -> bool;
|
||||||
|
|
||||||
fn is_dictionary(&self) -> bool;
|
fn is_dictionary(&self) -> bool;
|
||||||
fn get<K: ValueImpl<Embedded = Self::Embedded>>(&self, _k: &K::Handle) -> Option<Self::Handle>;
|
fn get<K: ValueImpl<'de, Embedded = Self::Embedded>>(&self, _k: &K::Handle) -> Option<Self::Handle>;
|
||||||
fn entries(&self) -> Self::Entries<'_>;
|
fn entries(&self) -> Self::Entries<'_>;
|
||||||
|
|
||||||
fn as_embedded(&self) -> Option<Cow<'_, Self::Embedded>>;
|
fn as_embedded(&self) -> Option<Cow<'_, Self::Embedded>>;
|
||||||
|
|
||||||
// INVARIANT: return Some() *only* when the contained collection is nonempty
|
// INVARIANT: return Some() *only* when the contained collection is nonempty
|
||||||
fn annotations(&self) -> Option<Cow<'_, [<Self::Mapped<Self::IOEmbedded> as ValueImpl>::Handle]>>;
|
fn annotations(&self) -> Option<Cow<'_, [<Self::Mapped<Self::IOEmbedded> as ValueImpl<'de>>::Handle]>>;
|
||||||
|
|
||||||
fn peeled(v: &Self::Handle) -> Self::Handle;
|
fn peeled(v: &Self::Handle) -> Self::Handle;
|
||||||
|
|
||||||
fn copy<E: ValueImpl, F, Err>(w: &E::Handle, f: &mut F) -> Result<Self::Handle, Err>
|
fn copy<E: ValueImpl<'de>, F, Err>(w: &E::Handle, f: &mut F) -> Result<Self::Handle, Err>
|
||||||
where
|
where
|
||||||
F: FnMut(&E::Embedded) -> Result<Self::Handle, Err>;
|
F: FnMut(&E::Embedded) -> Result<Self::Handle, Err>;
|
||||||
|
|
||||||
fn map_embedded<E: Domain, F, Err>(v: &Self::Handle, f: &mut F) -> Result<<Self::Mapped<E> as ValueImpl>::Handle, Err>
|
fn map_embedded<E: Domain<'de>, F, Err>(v: &Self::Handle, f: &mut F) -> Result<<Self::Mapped<E> as ValueImpl<'de>>::Handle, Err>
|
||||||
where
|
where
|
||||||
F: FnMut(&Self::Embedded) -> Result<E, Err>;
|
F: FnMut(&Self::Embedded) -> Result<E, Err>;
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn value_hash<V: ValueImpl, H: Hasher>(v: &V, state: &mut H) {
|
pub fn value_hash<'de, V: ValueImpl<'de>, H: Hasher>(v: &V, state: &mut H) {
|
||||||
match v.value_class() {
|
match v.value_class() {
|
||||||
ValueClass::Atomic(a) => match a {
|
ValueClass::Atomic(a) => match a {
|
||||||
AtomClass::Boolean => v.as_boolean().unwrap().hash(state),
|
AtomClass::Boolean => v.as_boolean().unwrap().hash(state),
|
||||||
|
@ -171,7 +179,7 @@ pub fn value_hash<V: ValueImpl, H: Hasher>(v: &V, state: &mut H) {
|
||||||
}
|
}
|
||||||
|
|
||||||
// TODO: when unstable feature iter_order_by stabilises, use that instead
|
// TODO: when unstable feature iter_order_by stabilises, use that instead
|
||||||
fn iters_eq<V: ValueImpl, W: ValueImpl<Embedded = V::Embedded>>(i: &V::Items<'_>, j: &W::Items<'_>) -> bool {
|
fn iters_eq<'de, V: ValueImpl<'de>, W: ValueImpl<'de, Embedded = V::Embedded>>(i: &V::Items<'_>, j: &W::Items<'_>) -> bool {
|
||||||
loop {
|
loop {
|
||||||
match i.next() {
|
match i.next() {
|
||||||
None => return j.next().is_none(),
|
None => return j.next().is_none(),
|
||||||
|
@ -183,7 +191,7 @@ fn iters_eq<V: ValueImpl, W: ValueImpl<Embedded = V::Embedded>>(i: &V::Items<'_>
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn value_eq<V: ValueImpl, W: ValueImpl<Embedded = V::Embedded>>(v: &V, w: &W) -> bool {
|
pub fn value_eq<'de, V: ValueImpl<'de>, W: ValueImpl<'de, Embedded = V::Embedded>>(v: &V, w: &W) -> bool {
|
||||||
let cls = v.value_class();
|
let cls = v.value_class();
|
||||||
if cls != w.value_class() { return false; }
|
if cls != w.value_class() { return false; }
|
||||||
match cls {
|
match cls {
|
||||||
|
@ -227,7 +235,7 @@ pub fn value_eq<V: ValueImpl, W: ValueImpl<Embedded = V::Embedded>>(v: &V, w: &W
|
||||||
}
|
}
|
||||||
|
|
||||||
// TODO: when unstable feature iter_order_by stabilises, use that instead
|
// TODO: when unstable feature iter_order_by stabilises, use that instead
|
||||||
fn iters_cmp<V: ValueImpl, W: ValueImpl<Embedded = V::Embedded>>(i: &V::Items<'_>, j: &W::Items<'_>) -> Ordering {
|
fn iters_cmp<'de, V: ValueImpl<'de>, W: ValueImpl<'de, Embedded = V::Embedded>>(i: &V::Items<'_>, j: &W::Items<'_>) -> Ordering {
|
||||||
loop {
|
loop {
|
||||||
match i.next() {
|
match i.next() {
|
||||||
None => return if j.next().is_none() { Ordering::Equal } else { Ordering::Less },
|
None => return if j.next().is_none() { Ordering::Equal } else { Ordering::Less },
|
||||||
|
@ -242,7 +250,7 @@ fn iters_cmp<V: ValueImpl, W: ValueImpl<Embedded = V::Embedded>>(i: &V::Items<'_
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn value_cmp<V: ValueImpl, W: ValueImpl<Embedded = V::Embedded>>(v: &V, w: &W) -> Ordering {
|
pub fn value_cmp<'de, V: ValueImpl<'de>, W: ValueImpl<'de, Embedded = V::Embedded>>(v: &V, w: &W) -> Ordering {
|
||||||
let cls = v.value_class();
|
let cls = v.value_class();
|
||||||
cls.cmp(&w.value_class()).then_with(|| match cls {
|
cls.cmp(&w.value_class()).then_with(|| match cls {
|
||||||
ValueClass::Atomic(a) => match a {
|
ValueClass::Atomic(a) => match a {
|
||||||
|
|
|
@ -11,10 +11,14 @@ use std::sync::Arc;
|
||||||
use bytemuck::TransparentWrapper;
|
use bytemuck::TransparentWrapper;
|
||||||
|
|
||||||
use crate::AtomClass;
|
use crate::AtomClass;
|
||||||
|
use crate::BinarySource;
|
||||||
|
use crate::BytesBinarySource;
|
||||||
use crate::CompoundClass;
|
use crate::CompoundClass;
|
||||||
|
use crate::DefaultDomainCodec;
|
||||||
use crate::Domain;
|
use crate::Domain;
|
||||||
use crate::DomainDecode;
|
use crate::DomainDecode;
|
||||||
use crate::DomainEncode;
|
use crate::DomainEncode;
|
||||||
|
use crate::Error;
|
||||||
use crate::ExpectedKind;
|
use crate::ExpectedKind;
|
||||||
use crate::IOValueDomainDecode;
|
use crate::IOValueDomainDecode;
|
||||||
use crate::IOValueDomainEncode;
|
use crate::IOValueDomainEncode;
|
||||||
|
@ -22,12 +26,12 @@ use crate::Reader;
|
||||||
use crate::SignedInteger;
|
use crate::SignedInteger;
|
||||||
use crate::ValueClass;
|
use crate::ValueClass;
|
||||||
use crate::ValueImpl;
|
use crate::ValueImpl;
|
||||||
|
use crate::ValueReader;
|
||||||
use crate::Writer;
|
use crate::Writer;
|
||||||
use crate::boundary as B;
|
use crate::boundary as B;
|
||||||
use crate::error::ReadError;
|
use crate::error::ReadError;
|
||||||
use crate::error::io_eof;
|
use crate::error::io_eof;
|
||||||
use crate::impl_value_methods;
|
use crate::impl_value_methods;
|
||||||
use crate::repr::ValueReader;
|
|
||||||
|
|
||||||
pub use std::collections::BTreeSet as Set;
|
pub use std::collections::BTreeSet as Set;
|
||||||
pub use std::collections::BTreeMap as Map;
|
pub use std::collections::BTreeMap as Map;
|
||||||
|
@ -111,10 +115,23 @@ impl<'a> From<String> for Atom<'a> { fn from(v: String) -> Self { Atom::String(C
|
||||||
impl<'a> From<&'a [u8]> for Atom<'a> { fn from(v: &'a [u8]) -> Self { Atom::ByteString(Cow::Borrowed(v)) } }
|
impl<'a> From<&'a [u8]> for Atom<'a> { fn from(v: &'a [u8]) -> Self { Atom::ByteString(Cow::Borrowed(v)) } }
|
||||||
impl<'a> From<Vec<u8>> for Atom<'a> { fn from(v: Vec<u8>) -> Self { Atom::ByteString(Cow::Owned(v)) } }
|
impl<'a> From<Vec<u8>> for Atom<'a> { fn from(v: Vec<u8>) -> Self { Atom::ByteString(Cow::Owned(v)) } }
|
||||||
|
|
||||||
|
impl<'a> From<i8> for Atom<'a> { fn from(i: i8) -> Self { SignedInteger::from(i).into() } }
|
||||||
|
impl<'a> From<u8> for Atom<'a> { fn from(i: u8) -> Self { SignedInteger::from(i).into() } }
|
||||||
|
impl<'a> From<i16> for Atom<'a> { fn from(i: i16) -> Self { SignedInteger::from(i).into() } }
|
||||||
|
impl<'a> From<u16> for Atom<'a> { fn from(i: u16) -> Self { SignedInteger::from(i).into() } }
|
||||||
|
impl<'a> From<i32> for Atom<'a> { fn from(i: i32) -> Self { SignedInteger::from(i).into() } }
|
||||||
|
impl<'a> From<u32> for Atom<'a> { fn from(i: u32) -> Self { SignedInteger::from(i).into() } }
|
||||||
|
impl<'a> From<i64> for Atom<'a> { fn from(i: i64) -> Self { SignedInteger::from(i).into() } }
|
||||||
|
impl<'a> From<u64> for Atom<'a> { fn from(i: u64) -> Self { SignedInteger::from(i).into() } }
|
||||||
|
impl<'a> From<i128> for Atom<'a> { fn from(i: i128) -> Self { SignedInteger::from(i).into() } }
|
||||||
|
impl<'a> From<u128> for Atom<'a> { fn from(i: u128) -> Self { SignedInteger::from(i).into() } }
|
||||||
|
impl<'a> From<isize> for Atom<'a> { fn from(i: isize) -> Self { SignedInteger::from(i).into() } }
|
||||||
|
impl<'a> From<usize> for Atom<'a> { fn from(i: usize) -> Self { SignedInteger::from(i).into() } }
|
||||||
|
|
||||||
macro_rules! from_atom_ref_impl {
|
macro_rules! from_atom_ref_impl {
|
||||||
($t:ty, $p:pat, $e:expr, $err:expr) => {
|
($t:ty, $p:pat, $e:expr, $errty:ty, $err:expr) => {
|
||||||
impl<'r, 'a> TryFrom<&'r Atom<'a>> for $t {
|
impl<'r, 'a> TryFrom<&'r Atom<'a>> for $t {
|
||||||
type Error = ExpectedKind;
|
type Error = $errty;
|
||||||
fn try_from(value: &'r Atom<'a>) -> Result<Self, Self::Error> {
|
fn try_from(value: &'r Atom<'a>) -> Result<Self, Self::Error> {
|
||||||
match value {
|
match value {
|
||||||
$p => Ok($e),
|
$p => Ok($e),
|
||||||
|
@ -124,12 +141,25 @@ macro_rules! from_atom_ref_impl {
|
||||||
}
|
}
|
||||||
};
|
};
|
||||||
}
|
}
|
||||||
from_atom_ref_impl!(bool, Atom::Boolean(b), *b, ExpectedKind::Boolean);
|
from_atom_ref_impl!(bool, Atom::Boolean(b), *b, ExpectedKind, ExpectedKind::Boolean);
|
||||||
from_atom_ref_impl!(f32, Atom::Float(f), *f, ExpectedKind::Float);
|
from_atom_ref_impl!(f32, Atom::Float(f), *f, ExpectedKind, ExpectedKind::Float);
|
||||||
from_atom_ref_impl!(f64, Atom::Double(d), *d, ExpectedKind::Double);
|
from_atom_ref_impl!(f64, Atom::Double(d), *d, ExpectedKind, ExpectedKind::Double);
|
||||||
from_atom_ref_impl!(&'a SignedInteger, Atom::SignedInteger(i), i.as_ref(), ExpectedKind::SignedInteger);
|
from_atom_ref_impl!(&'a SignedInteger, Atom::SignedInteger(i), i.as_ref(), ExpectedKind, ExpectedKind::SignedInteger);
|
||||||
from_atom_ref_impl!(&'a str, Atom::String(s), s.as_ref(), ExpectedKind::String);
|
from_atom_ref_impl!(&'a str, Atom::String(s), s.as_ref(), ExpectedKind, ExpectedKind::String);
|
||||||
from_atom_ref_impl!(&'a [u8], Atom::ByteString(bs), bs.as_ref(), ExpectedKind::ByteString);
|
from_atom_ref_impl!(&'a [u8], Atom::ByteString(bs), bs.as_ref(), ExpectedKind, ExpectedKind::ByteString);
|
||||||
|
|
||||||
|
from_atom_ref_impl!(i8, Atom::SignedInteger(i), i.as_ref().try_into()?, Error, Error::Expected(ExpectedKind::SignedInteger));
|
||||||
|
from_atom_ref_impl!(u8, Atom::SignedInteger(i), i.as_ref().try_into()?, Error, Error::Expected(ExpectedKind::SignedInteger));
|
||||||
|
from_atom_ref_impl!(i16, Atom::SignedInteger(i), i.as_ref().try_into()?, Error, Error::Expected(ExpectedKind::SignedInteger));
|
||||||
|
from_atom_ref_impl!(u16, Atom::SignedInteger(i), i.as_ref().try_into()?, Error, Error::Expected(ExpectedKind::SignedInteger));
|
||||||
|
from_atom_ref_impl!(i32, Atom::SignedInteger(i), i.as_ref().try_into()?, Error, Error::Expected(ExpectedKind::SignedInteger));
|
||||||
|
from_atom_ref_impl!(u32, Atom::SignedInteger(i), i.as_ref().try_into()?, Error, Error::Expected(ExpectedKind::SignedInteger));
|
||||||
|
from_atom_ref_impl!(i64, Atom::SignedInteger(i), i.as_ref().try_into()?, Error, Error::Expected(ExpectedKind::SignedInteger));
|
||||||
|
from_atom_ref_impl!(u64, Atom::SignedInteger(i), i.as_ref().try_into()?, Error, Error::Expected(ExpectedKind::SignedInteger));
|
||||||
|
from_atom_ref_impl!(i128, Atom::SignedInteger(i), i.as_ref().try_into()?, Error, Error::Expected(ExpectedKind::SignedInteger));
|
||||||
|
from_atom_ref_impl!(u128, Atom::SignedInteger(i), i.as_ref().try_into()?, Error, Error::Expected(ExpectedKind::SignedInteger));
|
||||||
|
from_atom_ref_impl!(isize, Atom::SignedInteger(i), i.as_ref().try_into()?, Error, Error::Expected(ExpectedKind::SignedInteger));
|
||||||
|
from_atom_ref_impl!(usize, Atom::SignedInteger(i), i.as_ref().try_into()?, Error, Error::Expected(ExpectedKind::SignedInteger));
|
||||||
|
|
||||||
macro_rules! from_atom_val_impl {
|
macro_rules! from_atom_val_impl {
|
||||||
($t:ty, $p:pat, $e:expr, $err:expr) => {
|
($t:ty, $p:pat, $e:expr, $err:expr) => {
|
||||||
|
@ -152,22 +182,22 @@ from_atom_val_impl!(Cow<'a, str>, Atom::String(s), s, ExpectedKind::String);
|
||||||
from_atom_val_impl!(Cow<'a, [u8]>, Atom::ByteString(bs), bs, ExpectedKind::ByteString);
|
from_atom_val_impl!(Cow<'a, [u8]>, Atom::ByteString(bs), bs, ExpectedKind::ByteString);
|
||||||
|
|
||||||
pub type ShellHandle<'a, D> = Arc<Shell<'a, D>>;
|
pub type ShellHandle<'a, D> = Arc<Shell<'a, D>>;
|
||||||
pub enum Shell<'a, D: Domain> {
|
pub enum Shell<'de, D: Domain<'de>> {
|
||||||
Atom(Atom<'a>),
|
Atom(Atom<'de>),
|
||||||
Record(Record<ShellHandle<'a, D>>),
|
Record(Record<ShellHandle<'de, D>>),
|
||||||
Sequence(Vec<ShellHandle<'a, D>>),
|
Sequence(Vec<ShellHandle<'de, D>>),
|
||||||
Set(Set<ShellHandle<'a, D>>),
|
Set(Set<ShellHandle<'de, D>>),
|
||||||
Dictionary(Map<ShellHandle<'a, D>, ShellHandle<'a, D>>),
|
Dictionary(Map<ShellHandle<'de, D>, ShellHandle<'de, D>>),
|
||||||
Embedded(D),
|
Embedded(D),
|
||||||
Annotated(Annotations<Self>),
|
Annotated(Annotations<'de, Self>),
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'a, D: Domain> Shell<'a, D> {
|
impl<'de, D: Domain<'de>> Shell<'de, D> {
|
||||||
pub fn record(label: ShellHandle<'a, D>, fields: Vec<ShellHandle<'a, D>>) -> Self {
|
pub fn record(label: ShellHandle<'de, D>, fields: Vec<ShellHandle<'de, D>>) -> Self {
|
||||||
Shell::Record(Record::new(label, fields))
|
Shell::Record(Record::new(label, fields))
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn symbol<S: Into<Cow<'a, str>>>(s: S) -> Self {
|
pub fn symbol<S: Into<Cow<'de, str>>>(s: S) -> Self {
|
||||||
Shell::Atom(Atom::symbol(s))
|
Shell::Atom(Atom::symbol(s))
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -176,21 +206,21 @@ impl<'a, D: Domain> Shell<'a, D> {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<D: Domain> ValueReader for Shell<'_, D> {
|
impl<'de, D: Domain<'de>> ValueReader<'de> for Shell<'de, D> {
|
||||||
type Impl<'de> = Shell<'de, D>;
|
type Impl = Shell<'de, D>;
|
||||||
|
|
||||||
fn read_impl<'de, R: Reader<'de> + ?Sized, Dec: DomainDecode<'de, <Self::Impl<'de> as ValueImpl>::Embedded>>(
|
fn read_impl<R: Reader<'de> + ?Sized, Dec: DomainDecode<'de, <Self::Impl as ValueImpl<'de>>::Embedded>>(
|
||||||
r: &mut R,
|
r: &mut R,
|
||||||
read_annotations: bool,
|
read_annotations: bool,
|
||||||
dec: &mut Dec,
|
dec: &mut Dec,
|
||||||
) -> Result<Self::Impl<'de>, ReadError> {
|
) -> Result<Self::Impl, ReadError> {
|
||||||
Ok(read(r, read_annotations, dec)?)
|
Ok(read(r, read_annotations, dec)?)
|
||||||
}
|
}
|
||||||
|
|
||||||
fn read_iovalue<'de, R: Reader<'de> + ?Sized>(
|
fn read_iovalue<R: Reader<'de> + ?Sized>(
|
||||||
r: &mut R,
|
r: &mut R,
|
||||||
read_annotations: bool,
|
read_annotations: bool,
|
||||||
) -> Result<<Self::Impl<'de> as ValueImpl>::IOEmbedded, ReadError> {
|
) -> Result<<Self::Impl as ValueImpl<'de>>::IOEmbedded, ReadError> {
|
||||||
Ok(Shell::<'de, IOValue>::read_impl(
|
Ok(Shell::<'de, IOValue>::read_impl(
|
||||||
r,
|
r,
|
||||||
read_annotations,
|
read_annotations,
|
||||||
|
@ -198,13 +228,21 @@ impl<D: Domain> ValueReader for Shell<'_, D> {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'a, D: Domain> ValueImpl for Shell<'a, D> {
|
impl<'de, Err: Into<io::Error>, D: Domain<'de> + FromStr<Err = Err>> FromStr for Shell<'de, D> {
|
||||||
type Handle = ShellHandle<'a, D>;
|
type Err = io::Error;
|
||||||
|
|
||||||
|
fn from_str(s: &str) -> Result<Self, Self::Err> {
|
||||||
|
Ok(Shell::read_impl(&mut BytesBinarySource::new(s.as_bytes()).text(), true, &mut DefaultDomainCodec)?)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<'de, D: Domain<'de>> ValueImpl<'de> for Shell<'de, D> {
|
||||||
|
type Handle = ShellHandle<'de, D>;
|
||||||
type Embedded = D;
|
type Embedded = D;
|
||||||
type Mapped<E: Domain> = Shell<'a, E>;
|
type Mapped<E: Domain<'de>> = Shell<'de, E>;
|
||||||
type Items<'i> = std::slice::Iter<'i, Self::Handle> where Self: 'i;
|
type Items<'i> = std::slice::Iter<'i, Self::Handle> where Self: 'i;
|
||||||
type Entries<'i> = std::collections::btree_map::Iter<'i, Self::Handle, Self::Handle> where Self: 'i;
|
type Entries<'i> = std::collections::btree_map::Iter<'i, Self::Handle, Self::Handle> where Self: 'i;
|
||||||
type IOEmbedded = IOValue<'a>;
|
type IOEmbedded = IOValue<'de>;
|
||||||
|
|
||||||
fn wrap(self) -> Self::Handle {
|
fn wrap(self) -> Self::Handle {
|
||||||
Self::Handle::new(self)
|
Self::Handle::new(self)
|
||||||
|
@ -289,7 +327,7 @@ impl<'a, D: Domain> ValueImpl for Shell<'a, D> {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
fn copy<E: ValueImpl, F, Err>(w: &E::Handle, f: &mut F) -> Result<Self::Handle, Err>
|
fn copy<E: ValueImpl<'de>, F, Err>(w: &E::Handle, f: &mut F) -> Result<Self::Handle, Err>
|
||||||
where
|
where
|
||||||
F: FnMut(&E::Embedded) -> Result<Self::Handle, Err>
|
F: FnMut(&E::Embedded) -> Result<Self::Handle, Err>
|
||||||
{
|
{
|
||||||
|
@ -331,12 +369,12 @@ impl<'a, D: Domain> ValueImpl for Shell<'a, D> {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
fn map_embedded<E: Domain, F, Err>(v: &Self::Handle, f: &mut F) -> Result<<Self::Mapped<E> as ValueImpl>::Handle, Err>
|
fn map_embedded<E: Domain<'de>, F, Err>(v: &Self::Handle, f: &mut F) -> Result<<Self::Mapped<E> as ValueImpl<'de>>::Handle, Err>
|
||||||
where
|
where
|
||||||
F: FnMut(&D) -> Result<E, Err>
|
F: FnMut(&D) -> Result<E, Err>
|
||||||
{
|
{
|
||||||
Self::Mapped::<E>::copy::<Self, _, _>(v, &mut |d| Ok(
|
Self::Mapped::<E>::copy::<Self, _, _>(v, &mut |d| Ok(
|
||||||
ShellHandle::<'a, E>::new(Self::Mapped::<E>::Embedded(f(d)?))))
|
ShellHandle::<'de, E>::new(Self::Mapped::<E>::Embedded(f(d)?))))
|
||||||
}
|
}
|
||||||
|
|
||||||
fn as_boolean(&self) -> Option<bool> {
|
fn as_boolean(&self) -> Option<bool> {
|
||||||
|
@ -434,7 +472,7 @@ impl<'a, D: Domain> ValueImpl for Shell<'a, D> {
|
||||||
matches!(self, Shell::Set(_))
|
matches!(self, Shell::Set(_))
|
||||||
}
|
}
|
||||||
|
|
||||||
fn has<E: ValueImpl<Embedded = D>>(&self, v: &E::Handle) -> bool {
|
fn has<E: ValueImpl<'de, Embedded = D>>(&self, v: &E::Handle) -> bool {
|
||||||
match self {
|
match self {
|
||||||
Shell::Set(items) => todo!(), // items.contains(v),
|
Shell::Set(items) => todo!(), // items.contains(v),
|
||||||
_ => false,
|
_ => false,
|
||||||
|
@ -445,7 +483,7 @@ impl<'a, D: Domain> ValueImpl for Shell<'a, D> {
|
||||||
matches!(self, Shell::Dictionary(_))
|
matches!(self, Shell::Dictionary(_))
|
||||||
}
|
}
|
||||||
|
|
||||||
fn get<K: ValueImpl<Embedded = D>>(&self, k: &K::Handle) -> Option<Self::Handle> {
|
fn get<K: ValueImpl<'de, Embedded = D>>(&self, k: &K::Handle) -> Option<Self::Handle> {
|
||||||
match self {
|
match self {
|
||||||
Shell::Dictionary(entries) => todo!(), // entries.get(k),
|
Shell::Dictionary(entries) => todo!(), // entries.get(k),
|
||||||
_ => None,
|
_ => None,
|
||||||
|
@ -466,7 +504,7 @@ impl<'a, D: Domain> ValueImpl for Shell<'a, D> {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
fn annotations(&self) -> Option<Cow<'_, [<Self::Mapped<Self::IOEmbedded> as ValueImpl>::Handle]>> {
|
fn annotations(&self) -> Option<Cow<'_, [<Self::Mapped<Self::IOEmbedded> as ValueImpl<'de>>::Handle]>> {
|
||||||
match self {
|
match self {
|
||||||
Shell::Annotated(b) => Some(Cow::Borrowed(&b.0.as_ref().1)),
|
Shell::Annotated(b) => Some(Cow::Borrowed(&b.0.as_ref().1)),
|
||||||
_ => None,
|
_ => None,
|
||||||
|
@ -481,34 +519,34 @@ impl<'a, D: Domain> ValueImpl for Shell<'a, D> {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl_value_methods!({'a, D: Domain}, Shell<'a, D>);
|
impl_value_methods!({'de, D: Domain<'de>}, Shell<'de, D>);
|
||||||
|
|
||||||
impl<'a, W: Into<Atom<'a>>, D: Domain> From<W> for Shell<'a, D> {
|
impl<'de, W: Into<Atom<'de>>, D: Domain<'de>> From<W> for Shell<'de, D> {
|
||||||
fn from(w: W) -> Self {
|
fn from(w: W) -> Self {
|
||||||
Shell::Atom(w.into())
|
Shell::Atom(w.into())
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'a, D: Domain> From<Vec<ShellHandle<'a, D>>> for Shell<'a, D> {
|
impl<'de, D: Domain<'de>> From<Vec<ShellHandle<'de, D>>> for Shell<'de, D> {
|
||||||
fn from(vs: Vec<ShellHandle<'a, D>>) -> Self {
|
fn from(vs: Vec<ShellHandle<'de, D>>) -> Self {
|
||||||
Shell::Sequence(vs)
|
Shell::Sequence(vs)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'a, D: Domain> From<Vec<Shell<'a, D>>> for Shell<'a, D> {
|
impl<'de, D: Domain<'de>> From<Vec<Shell<'de, D>>> for Shell<'de, D> {
|
||||||
fn from(vs: Vec<Shell<'a, D>>) -> Self {
|
fn from(vs: Vec<Shell<'de, D>>) -> Self {
|
||||||
vs.iter().map(|v| v.wrap()).collect::<Vec<_>>().into()
|
vs.iter().map(|v| v.wrap()).collect::<Vec<_>>().into()
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'a, D: Domain> From<Set<ShellHandle<'a, D>>> for Shell<'a, D> {
|
impl<'de, D: Domain<'de>> From<Set<ShellHandle<'de, D>>> for Shell<'de, D> {
|
||||||
fn from(vs: Set<ShellHandle<'a, D>>) -> Self {
|
fn from(vs: Set<ShellHandle<'de, D>>) -> Self {
|
||||||
Shell::Set(vs)
|
Shell::Set(vs)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'a, D: Domain> From<Map<ShellHandle<'a, D>, ShellHandle<'a, D>>> for Shell<'a, D> {
|
impl<'de, D: Domain<'de>> From<Map<ShellHandle<'de, D>, ShellHandle<'de, D>>> for Shell<'de, D> {
|
||||||
fn from(vs: Map<ShellHandle<'a, D>, ShellHandle<'a, D>>) -> Self {
|
fn from(vs: Map<ShellHandle<'de, D>, ShellHandle<'de, D>>) -> Self {
|
||||||
Shell::Dictionary(vs)
|
Shell::Dictionary(vs)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -534,88 +572,103 @@ impl<V> Record<V> {
|
||||||
}
|
}
|
||||||
|
|
||||||
#[derive(Clone)]
|
#[derive(Clone)]
|
||||||
pub struct Annotations<V: ValueImpl>(Box<(V::Handle, Vec<<V::Mapped<V::IOEmbedded> as ValueImpl>::Handle>)>);
|
pub struct Annotations<'de, V: ValueImpl<'de>>(Box<(V::Handle, Vec<<V::Mapped<V::IOEmbedded> as ValueImpl<'de>>::Handle>)>);
|
||||||
|
|
||||||
impl<V: ValueImpl> Annotations<V> {
|
impl<'de, V: ValueImpl<'de>> Annotations<'de, V> {
|
||||||
pub fn new(v: V::Handle, anns: Vec<<V::Mapped<V::IOEmbedded> as ValueImpl>::Handle>) -> Self {
|
pub fn new(v: V::Handle, anns: Vec<<V::Mapped<V::IOEmbedded> as ValueImpl<'de>>::Handle>) -> Self {
|
||||||
Self(Box::new((v, anns)))
|
Self(Box::new((v, anns)))
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<V: ValueImpl> Hash for Annotations<V> {
|
impl<'de, V: ValueImpl<'de>> Hash for Annotations<'de, V> {
|
||||||
fn hash<H: Hasher>(&self, state: &mut H) {
|
fn hash<H: Hasher>(&self, state: &mut H) {
|
||||||
self.0.as_ref().0.hash(state)
|
self.0.as_ref().0.hash(state)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<V: ValueImpl> PartialEq for Annotations<V> {
|
impl<'de, V: ValueImpl<'de>> PartialEq for Annotations<'de, V> {
|
||||||
fn eq(&self, other: &Self) -> bool {
|
fn eq(&self, other: &Self) -> bool {
|
||||||
self.0.as_ref().0.eq(&other.0.as_ref().0)
|
self.0.as_ref().0.eq(&other.0.as_ref().0)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<V: ValueImpl> Ord for Annotations<V> {
|
impl<'de, V: ValueImpl<'de>> Ord for Annotations<'de, V> {
|
||||||
fn cmp(&self, other: &Self) -> Ordering {
|
fn cmp(&self, other: &Self) -> Ordering {
|
||||||
self.0.as_ref().0.cmp(&other.0.as_ref().0)
|
self.0.as_ref().0.cmp(&other.0.as_ref().0)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<V: ValueImpl> Eq for Annotations<V> {}
|
impl<'de, V: ValueImpl<'de>> Eq for Annotations<'de, V> {}
|
||||||
|
|
||||||
impl<V: ValueImpl> PartialOrd for Annotations<V> {
|
impl<'de, V: ValueImpl<'de>> PartialOrd for Annotations<'de, V> {
|
||||||
fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
|
fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
|
||||||
Some(self.cmp(other))
|
Some(self.cmp(other))
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn copy_iovalue<V: ValueImpl>(v: &<V::Mapped<V::IOEmbedded> as ValueImpl>::Handle) -> IOValue {
|
pub fn copy_iovalue<'de, V: ValueImpl<'de>>(v: &<V::Mapped<V::IOEmbedded> as ValueImpl<'de>>::Handle) -> IOValue<'de> {
|
||||||
Shell::copy::<V::Mapped<V::IOEmbedded>, _, _>(v, &mut |a| Result::<_, ()>::Ok(
|
Shell::copy::<V::Mapped<V::IOEmbedded>, _, _>(v, &mut |a| Result::<_, ()>::Ok(
|
||||||
copy_iovalue::<V>(a.as_ref()).into())).unwrap().into()
|
copy_iovalue::<V>(a.as_ref()).into())).unwrap().into()
|
||||||
}
|
}
|
||||||
|
|
||||||
pub type IOValueImpl<'a> = Shell<'a, IOValue<'a>>;
|
pub type IOValueImpl<'a> = Shell<'a, IOValue<'a>>;
|
||||||
|
pub type IOValueIso<'a> = ShellHandle<'a, IOValue<'a>>;
|
||||||
|
|
||||||
#[derive(Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
|
#[derive(Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
|
||||||
#[repr(transparent)]
|
#[repr(transparent)]
|
||||||
pub struct IOValue<'a>(ShellHandle<'a, IOValue<'a>>);
|
pub struct IOValue<'a>(IOValueIso<'a>);
|
||||||
unsafe impl<'a> TransparentWrapper<ShellHandle<'a, IOValue<'a>>> for IOValue<'a> {}
|
unsafe impl<'a> TransparentWrapper<IOValueIso<'a>> for IOValue<'a> {}
|
||||||
|
|
||||||
impl Domain for IOValue<'_> {
|
impl<'de> Domain<'de> for IOValue<'de> {
|
||||||
type Decode = IOValueDomainDecode<Self>;
|
type Decode = IOValueDomainDecode<'de, IOValueImpl<'de>>;
|
||||||
type Encode = IOValueDomainEncode<Self>;
|
type Encode = IOValueDomainEncode<'de, Self>;
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'a> Debug for IOValue<'a> {
|
impl<'de> Debug for IOValue<'de> {
|
||||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||||
IOValue::peel_ref(self).fmt(f)
|
IOValue::peel_ref(self).fmt(f)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'a> IOValue<'a> {
|
impl<'de> IOValue<'de> {
|
||||||
pub fn value(&self) -> &IOValueImpl<'a> {
|
pub fn record(label: IOValue<'de>, fields: Vec<IOValue<'de>>) -> Self {
|
||||||
|
IOValue(Shell::Record(Record::new(
|
||||||
|
label.into(),
|
||||||
|
fields.into_iter().map(|f| f.into()).collect())).wrap())
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn value(&self) -> &IOValueImpl<'de> {
|
||||||
self.0.as_ref()
|
self.0.as_ref()
|
||||||
}
|
}
|
||||||
|
|
||||||
|
pub fn iso(self) -> IOValueIso<'de> {
|
||||||
|
IOValue::peel(self)
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'a, T: Into<IOValueImpl<'a>>> From<T> for IOValue<'a> {
|
pub fn iso_parse<'a>(s: &'a str) -> io::Result<IOValueIso<'a>> {
|
||||||
|
Ok(IOValue::from_str(s)?.iso())
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<'de, T: Into<IOValueImpl<'de>>> From<T> for IOValue<'de> {
|
||||||
fn from(t: T) -> Self {
|
fn from(t: T) -> Self {
|
||||||
IOValue(t.into().wrap())
|
IOValue(t.into().wrap())
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'a> Borrow<IOValueImpl<'a>> for IOValue<'a> {
|
impl<'de> Borrow<IOValueImpl<'de>> for IOValue<'de> {
|
||||||
fn borrow(&self) -> &IOValueImpl<'a> {
|
fn borrow(&self) -> &IOValueImpl<'de> {
|
||||||
self.0.as_ref()
|
self.0.as_ref()
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'a> AsRef<Arc<Shell<'a, IOValue<'a>>>> for IOValue<'a> {
|
impl<'de> AsRef<Arc<Shell<'de, IOValue<'de>>>> for IOValue<'de> {
|
||||||
fn as_ref(&self) -> &Arc<Shell<'a, IOValue<'a>>> {
|
fn as_ref(&self) -> &Arc<Shell<'de, IOValue<'de>>> {
|
||||||
&self.0
|
&self.0
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'a> FromStr for IOValue<'a> {
|
impl<'de> FromStr for IOValue<'de> {
|
||||||
type Err = io::Error;
|
type Err = io::Error;
|
||||||
|
|
||||||
fn from_str(s: &str) -> Result<Self, Self::Err> {
|
fn from_str(s: &str) -> Result<Self, Self::Err> {
|
||||||
|
@ -623,53 +676,53 @@ impl<'a> FromStr for IOValue<'a> {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'a> From<<IOValueImpl<'a> as ValueImpl>::Handle> for IOValue<'a> {
|
impl<'de> From<<IOValueImpl<'de> as ValueImpl<'de>>::Handle> for IOValue<'de> {
|
||||||
fn from(h: <IOValueImpl<'a> as ValueImpl>::Handle) -> Self {
|
fn from(h: <IOValueImpl<'de> as ValueImpl<'de>>::Handle) -> Self {
|
||||||
TransparentWrapper::wrap(h)
|
TransparentWrapper::wrap(h)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'r, 'a> From<&'r <IOValueImpl<'a> as ValueImpl>::Handle> for &'r IOValue<'a> {
|
impl<'r, 'de> From<&'r <IOValueImpl<'de> as ValueImpl<'de>>::Handle> for &'r IOValue<'de> {
|
||||||
fn from(h: &'r <IOValueImpl<'a> as ValueImpl>::Handle) -> Self {
|
fn from(h: &'r <IOValueImpl<'de> as ValueImpl<'de>>::Handle) -> Self {
|
||||||
TransparentWrapper::wrap_ref(h)
|
TransparentWrapper::wrap_ref(h)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'a> From<IOValue<'a>> for <IOValueImpl<'a> as ValueImpl>::Handle {
|
impl<'de> From<IOValue<'de>> for <IOValueImpl<'de> as ValueImpl<'de>>::Handle {
|
||||||
fn from(i: IOValue<'a>) -> Self {
|
fn from(i: IOValue<'de>) -> Self {
|
||||||
IOValue::peel(i)
|
IOValue::peel(i)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'r, 'a> From<&'r IOValue<'a>> for &'r <IOValueImpl<'a> as ValueImpl>::Handle {
|
impl<'r, 'de> From<&'r IOValue<'de>> for &'r <IOValueImpl<'de> as ValueImpl<'de>>::Handle {
|
||||||
fn from(i: &'r IOValue<'a>) -> Self {
|
fn from(i: &'r IOValue<'de>) -> Self {
|
||||||
IOValue::peel_ref(i)
|
IOValue::peel_ref(i)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'a> ValueReader for IOValue<'a> {
|
impl<'de> ValueReader<'de> for IOValue<'de> {
|
||||||
type Impl<'i> = IOValue<'i>;
|
type Impl = Self;
|
||||||
|
|
||||||
fn read_impl<'de, R: Reader<'de> + ?Sized, Dec: DomainDecode<'de, <Self::Impl<'de> as ValueImpl>::Embedded>>(
|
fn read_impl<R: Reader<'de> + ?Sized, Dec: DomainDecode<'de, <Self::Impl as ValueImpl<'de>>::Embedded>>(
|
||||||
r: &mut R,
|
r: &mut R,
|
||||||
read_annotations: bool,
|
read_annotations: bool,
|
||||||
dec: &mut Dec,
|
dec: &mut Dec,
|
||||||
) -> Result<Self::Impl<'de>, ReadError> {
|
) -> Result<Self::Impl, ReadError> {
|
||||||
Ok(read(r, read_annotations, dec)?.into())
|
Ok(read(r, read_annotations, dec)?.into())
|
||||||
}
|
}
|
||||||
|
|
||||||
fn read_iovalue<'de, R: Reader<'de> + ?Sized>(
|
fn read_iovalue<R: Reader<'de> + ?Sized>(
|
||||||
r: &mut R,
|
r: &mut R,
|
||||||
read_annotations: bool,
|
read_annotations: bool,
|
||||||
) -> Result<<Self::Impl<'de> as ValueImpl>::IOEmbedded, ReadError> {
|
) -> Result<<Self::Impl as ValueImpl<'de>>::IOEmbedded, ReadError> {
|
||||||
Self::read(r, read_annotations, &mut IOValueDomainDecode::<Self>::default())
|
Self::read_domain(r, read_annotations, &mut IOValueDomainDecode::<Self>::default())
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'a> ValueImpl for IOValue<'a> {
|
impl<'de> ValueImpl<'de> for IOValue<'de> {
|
||||||
type Handle = Self;
|
type Handle = Self;
|
||||||
type Embedded = Self;
|
type Embedded = Self;
|
||||||
type Mapped<E: Domain> = Shell<'a, E>;
|
type Mapped<E: Domain<'de>> = Shell<'de, E>;
|
||||||
type Items<'i> = std::slice::Iter<'i, Self::Handle> where Self: 'i;
|
type Items<'i> = std::slice::Iter<'i, Self::Handle> where Self: 'i;
|
||||||
type Entries<'i> = std::collections::btree_map::Iter<'i, Self::Handle, Self::Handle> where Self: 'i;
|
type Entries<'i> = std::collections::btree_map::Iter<'i, Self::Handle, Self::Handle> where Self: 'i;
|
||||||
type IOEmbedded = Self;
|
type IOEmbedded = Self;
|
||||||
|
@ -738,7 +791,7 @@ impl<'a> ValueImpl for IOValue<'a> {
|
||||||
self.value().is_set()
|
self.value().is_set()
|
||||||
}
|
}
|
||||||
|
|
||||||
fn has<E: ValueImpl<Embedded = Self::Embedded>>(&self, v: &E::Handle) -> bool {
|
fn has<E: ValueImpl<'de, Embedded = Self::Embedded>>(&self, v: &E::Handle) -> bool {
|
||||||
self.value().has::<E>(v)
|
self.value().has::<E>(v)
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -746,7 +799,7 @@ impl<'a> ValueImpl for IOValue<'a> {
|
||||||
self.value().is_dictionary()
|
self.value().is_dictionary()
|
||||||
}
|
}
|
||||||
|
|
||||||
fn get<K: ValueImpl<Embedded = Self::Embedded>>(&self, k: &K::Handle) -> Option<Self::Handle> {
|
fn get<K: ValueImpl<'de, Embedded = Self::Embedded>>(&self, k: &K::Handle) -> Option<Self::Handle> {
|
||||||
self.value().get::<K>(k).map(|v| v.into())
|
self.value().get::<K>(k).map(|v| v.into())
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -758,7 +811,7 @@ impl<'a> ValueImpl for IOValue<'a> {
|
||||||
self.value().as_embedded()
|
self.value().as_embedded()
|
||||||
}
|
}
|
||||||
|
|
||||||
fn annotations(&self) -> Option<Cow<'_, [<Self::Mapped<Self::IOEmbedded> as ValueImpl>::Handle]>> {
|
fn annotations(&self) -> Option<Cow<'_, [<Self::Mapped<Self::IOEmbedded> as ValueImpl<'de>>::Handle]>> {
|
||||||
self.value().annotations()
|
self.value().annotations()
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -766,20 +819,20 @@ impl<'a> ValueImpl for IOValue<'a> {
|
||||||
TransparentWrapper::wrap(Shell::peeled(IOValue::peel_ref(v)))
|
TransparentWrapper::wrap(Shell::peeled(IOValue::peel_ref(v)))
|
||||||
}
|
}
|
||||||
|
|
||||||
fn copy<E: ValueImpl, F, Err>(w: &E::Handle, f: &mut F) -> Result<Self::Handle, Err>
|
fn copy<E: ValueImpl<'de>, F, Err>(w: &E::Handle, f: &mut F) -> Result<Self::Handle, Err>
|
||||||
where
|
where
|
||||||
F: FnMut(&E::Embedded) -> Result<Self::Handle, Err> {
|
F: FnMut(&E::Embedded) -> Result<Self::Handle, Err> {
|
||||||
IOValueImpl::copy::<E, _, _>(w, &mut |e| f(e).map(|v| v.into())).map(|v| v.into())
|
IOValueImpl::copy::<E, _, _>(w, &mut |e| f(e).map(|v| v.into())).map(|v| v.into())
|
||||||
}
|
}
|
||||||
|
|
||||||
fn map_embedded<E: Domain, F, Err>(v: &Self::Handle, f: &mut F) -> Result<<Self::Mapped<E> as ValueImpl>::Handle, Err>
|
fn map_embedded<E: Domain<'de>, F, Err>(v: &Self::Handle, f: &mut F) -> Result<<Self::Mapped<E> as ValueImpl<'de>>::Handle, Err>
|
||||||
where
|
where
|
||||||
F: FnMut(&Self::Embedded) -> Result<E, Err> {
|
F: FnMut(&Self::Embedded) -> Result<E, Err> {
|
||||||
IOValueImpl::map_embedded(v.into(), f)
|
IOValueImpl::map_embedded(v.into(), f)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn read<'de, R: Reader<'de> + ?Sized, D: Domain, Dec: DomainDecode<'de, D>>(
|
pub fn read<'de, R: Reader<'de> + ?Sized, D: Domain<'de>, Dec: DomainDecode<'de, D>>(
|
||||||
r: &mut R,
|
r: &mut R,
|
||||||
read_annotations: bool,
|
read_annotations: bool,
|
||||||
dec: &mut Dec,
|
dec: &mut Dec,
|
||||||
|
|
|
@ -14,33 +14,32 @@ use crate::Shell;
|
||||||
use crate::ShellHandle;
|
use crate::ShellHandle;
|
||||||
use crate::ValueReader;
|
use crate::ValueReader;
|
||||||
|
|
||||||
pub fn from_str<'de, D: Domain, Dec: DomainDecode<'de, D>>(
|
pub fn from_str<'de, D: Domain<'de>, Dec: DomainDecode<'de, D>>(
|
||||||
s: &'de str,
|
s: &'de str,
|
||||||
decode_embedded: &mut Dec,
|
decode_embedded: &mut Dec,
|
||||||
) -> io::Result<ShellHandle<'de, D>> {
|
) -> io::Result<ShellHandle<'de, D>> {
|
||||||
Ok(Shell::read(&mut BytesBinarySource::new(s.as_bytes()).text(), false, decode_embedded)?)
|
Ok(Shell::read_domain(&mut BytesBinarySource::new(s.as_bytes()).text(), false, decode_embedded)?)
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn annotated_from_str<'de, D: Domain, Dec: DomainDecode<'de, D>>(
|
pub fn annotated_from_str<'de, D: Domain<'de>, Dec: DomainDecode<'de, D>>(
|
||||||
s: &'de str,
|
s: &'de str,
|
||||||
decode_embedded: &mut Dec,
|
decode_embedded: &mut Dec,
|
||||||
) -> io::Result<ShellHandle<'de, D>> {
|
) -> io::Result<ShellHandle<'de, D>> {
|
||||||
Ok(Shell::read(&mut BytesBinarySource::new(s.as_bytes()).text(), true, decode_embedded)?)
|
Ok(Shell::read_domain(&mut BytesBinarySource::new(s.as_bytes()).text(), true, decode_embedded)?)
|
||||||
}
|
}
|
||||||
|
|
||||||
#[cfg(test)]
|
#[cfg(test)]
|
||||||
mod formatting_tests {
|
mod formatting_tests {
|
||||||
use crate::IOValue;
|
use crate::{IOValue, Shell, ValueImpl};
|
||||||
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::<Shell<Dom>>().unwrap().wrap();
|
||||||
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::<Shell<Dom>>().unwrap().wrap();
|
||||||
assert_eq!(format!("{:#?}", &v), concat!(
|
assert_eq!(format!("{:#?}", &v), concat!(
|
||||||
"[\n",
|
"[\n",
|
||||||
" 1,\n",
|
" 1,\n",
|
||||||
|
@ -76,7 +75,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: IOValue = 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);
|
||||||
|
@ -84,7 +83,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: IOValue = 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);
|
||||||
|
|
|
@ -33,7 +33,7 @@ impl std::default::Default for CommaStyle {
|
||||||
}
|
}
|
||||||
|
|
||||||
impl TextWriter<&mut Vec<u8>> {
|
impl TextWriter<&mut Vec<u8>> {
|
||||||
pub fn fmt_value<V: ValueImpl, Enc: DomainEncode<V::Embedded>>(
|
pub fn fmt_value<'de, V: ValueImpl<'de>, Enc: DomainEncode<'de, V::Embedded>>(
|
||||||
f: &mut std::fmt::Formatter<'_>,
|
f: &mut std::fmt::Formatter<'_>,
|
||||||
enc: &mut Enc,
|
enc: &mut Enc,
|
||||||
v: &V,
|
v: &V,
|
||||||
|
@ -46,7 +46,7 @@ impl TextWriter<&mut Vec<u8>> {
|
||||||
|_| io::Error::new(io::ErrorKind::Other, "could not append to Formatter"))
|
|_| io::Error::new(io::ErrorKind::Other, "could not append to Formatter"))
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn encode<V: ValueImpl, Enc: DomainEncode<V::Embedded>>(
|
pub fn encode<'de, V: ValueImpl<'de>, Enc: DomainEncode<'de, V::Embedded>>(
|
||||||
enc: &mut Enc,
|
enc: &mut Enc,
|
||||||
v: &V,
|
v: &V,
|
||||||
) -> io::Result<String> {
|
) -> io::Result<String> {
|
||||||
|
|
|
@ -70,10 +70,10 @@ 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<V: ValueImpl>(
|
pub fn write_value<'de, V: ValueImpl<'de>>(
|
||||||
w: &mut dyn Writer,
|
w: &mut dyn Writer,
|
||||||
v: &V,
|
v: &V,
|
||||||
enc: &mut dyn DomainEncode<V::Embedded>,
|
enc: &mut dyn DomainEncode<'de, V::Embedded>,
|
||||||
) -> io::Result<()> {
|
) -> io::Result<()> {
|
||||||
let annotations = v.annotations();
|
let annotations = v.annotations();
|
||||||
let mut annotation_b = B::Type::default();
|
let mut annotation_b = B::Type::default();
|
||||||
|
|
Loading…
Reference in New Issue