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

Remove unnecessary Cow

This commit is contained in:
Tony Garnock-Jones 2020-06-17 09:35:09 +02:00
parent 046a2ad999
commit b1c7fe8c04
3 changed files with 49 additions and 44 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
implementations/rust/src/de.rs
View File

@ -175,7 +175,7 @@ impl<'r, 'de, 'a, R: Reader<'de>> serde::de::Deserializer<'de> for &'a mut Deser
-> Result<V::Value> where V: Visitor<'de>
{
match super::value::magic::transmit_input_value(
name, || Ok(self.read.demand_next(false)?.into_owned()))?
name, || Ok(self.read.demand_next(false)?))?
{
Some(v) => visitor.visit_u64(v),
None => {

5
implementations/rust/src/value/decoder.rs
View File

@ -1,4 +1,3 @@
use std::borrow::Cow;
use std::marker::PhantomData;
use super::reader::{self, Reader, BinaryReader};
use super::value::IOValue;
@ -32,7 +31,7 @@ impl<'de, R: Reader<'de>> Decoder<'de, R> {
self.read_annotations = read_annotations
}
pub fn demand_next(&mut self) -> Result<Cow<'de, IOValue>> {
pub fn demand_next(&mut self) -> Result<IOValue> {
self.read.demand_next(self.read_annotations)
}
}
@ -43,7 +42,7 @@ impl<'de, R: Reader<'de>> std::iter::Iterator for Decoder<'de, R> {
match self.read.next(self.read_annotations) {
Err(e) => Some(Err(e)),
Ok(None) => None,
Ok(Some(v)) => Some(Ok(v.into_owned())),
Ok(Some(v)) => Some(Ok(v)),
}
}
}

86
implementations/rust/src/value/reader.rs
View File

@ -65,7 +65,7 @@ impl CompoundBody {
{
match self.more_expected(read)? {
false => Ok(None),
true => Ok(Some(read.demand_next(read_annotations)?.into_owned())),
true => Ok(Some(read.demand_next(read_annotations)?)),
}
}
@ -106,7 +106,7 @@ impl CompoundBody {
}
pub trait Reader<'de> {
fn next(&mut self, read_annotations: bool) -> IOResult<Option<Cow<'de, IOValue>>>;
fn next(&mut self, read_annotations: bool) -> IOResult<Option<IOValue>>;
fn open_record(&mut self, arity: Option<usize>) -> ReaderResult<CompoundBody>;
fn open_sequence_or_set(&mut self) -> ReaderResult<CompoundBody>;
fn open_sequence(&mut self) -> ReaderResult<CompoundBody>;
@ -123,7 +123,7 @@ pub trait Reader<'de> {
Ok(())
}
fn demand_next(&mut self, read_annotations: bool) -> IOResult<Cow<'de, IOValue>> {
fn demand_next(&mut self, read_annotations: bool) -> IOResult<IOValue> {
match self.next(read_annotations)? {
None => Err(io_eof()),
Some(v) => Ok(v)
@ -189,7 +189,7 @@ pub trait Reader<'de> {
}
impl<'r, 'de, R: Reader<'de>> Reader<'de> for &'r mut R {
fn next(&mut self, read_annotations: bool) -> IOResult<Option<Cow<'de, IOValue>>> {
fn next(&mut self, read_annotations: bool) -> IOResult<Option<IOValue>> {
(*self).next(read_annotations)
}
@ -374,7 +374,7 @@ impl<'de, S: BinarySource<'de>> BinaryReader<'de, S> {
fn expected(&mut self, k: ExpectedKind) -> error::Error {
match self.demand_next(true) {
Ok(v) => error::Error::Expected(k, Received::ReceivedOtherValue(v.into_owned())),
Ok(v) => error::Error::Expected(k, Received::ReceivedOtherValue(v)),
Err(e) => e.into()
}
}
@ -568,7 +568,7 @@ impl<'de, S: BinarySource<'de>> BinaryReader<'de, S> {
}
impl<'de, S: BinarySource<'de>> Reader<'de> for BinaryReader<'de, S> {
fn next(&mut self, read_annotations: bool) -> IOResult<Option<Cow<'de, IOValue>>> {
fn next(&mut self, read_annotations: bool) -> IOResult<Option<IOValue>> {
match self.peek() {
Err(e) if is_eof_io_error(&e) => return Ok(None),
Err(e) => return Err(e),
@ -576,26 +576,28 @@ impl<'de, S: BinarySource<'de>> Reader<'de> for BinaryReader<'de, S> {
}
loop {
return Ok(Some(match decodeop(self.read()?)? {
(Op::Misc(0), 0) => Cow::Borrowed(&FALSE),
(Op::Misc(0), 1) => Cow::Borrowed(&TRUE),
(Op::Misc(0), 0) => FALSE.clone(),
(Op::Misc(0), 1) => TRUE.clone(),
(Op::Misc(0), 2) => {
let bs: &[u8] = &self.readbytes(4)?;
Cow::Owned(Value::from(f32::from_bits(u32::from_be_bytes(bs.try_into().unwrap()))).wrap())
let mut bs = [0; 4];
self.readbytes_into(&mut bs)?;
Value::from(f32::from_bits(u32::from_be_bytes(bs))).wrap()
}
(Op::Misc(0), 3) => {
let bs: &[u8] = &self.readbytes(8)?;
Cow::Owned(Value::from(f64::from_bits(u64::from_be_bytes(bs.try_into().unwrap()))).wrap())
let mut bs = [0; 8];
self.readbytes_into(&mut bs)?;
Value::from(f64::from_bits(u64::from_be_bytes(bs))).wrap()
}
(Op::Misc(0), 5) => {
if read_annotations {
let mut annotations = vec![self.demand_next(read_annotations)?.into_owned()];
let mut annotations = vec![self.demand_next(read_annotations)?];
while decodeop(self.peek()?)? == (Op::Misc(0), 5) {
self.skip()?;
annotations.push(self.demand_next(read_annotations)?.into_owned());
annotations.push(self.demand_next(read_annotations)?);
}
let (existing_annotations, v) = self.demand_next(read_annotations)?.into_owned().pieces();
let (existing_annotations, v) = self.demand_next(read_annotations)?.pieces();
annotations.extend_from_slice(existing_annotations.slice());
Cow::Owned(IOValue::wrap(Annotations::new(Some(annotations)), v))
IOValue::wrap(Annotations::new(Some(annotations)), v)
} else {
self.skip_value()?;
continue;
@ -605,41 +607,41 @@ impl<'de, S: BinarySource<'de>> Reader<'de> for BinaryReader<'de, S> {
(Op::Misc(1), _) => Err(io_syntax_error("Invalid format A encoding"))?,
(Op::Misc(2), arg) => match Op::try_from(arg)? {
Op::Atom(minor) =>
Cow::Owned(decodebinary(minor, Cow::Owned(self.gather_chunks()?))?),
Op::Compound(minor) => Cow::Owned(decodecompound(minor, DelimitedStream {
decodebinary(minor, Cow::Owned(self.gather_chunks()?))?,
Op::Compound(minor) => decodecompound(minor, DelimitedStream {
reader: ConfiguredBinaryReader {
reader: self,
read_annotations,
phantom: PhantomData,
},
})?),
})?,
_ => Err(io_syntax_error("Invalid format C start byte"))?,
}
(Op::Misc(3), arg) => {
let n = if arg > 12 { i32::from(arg) - 16 } else { i32::from(arg) };
// TODO: prebuild these in value.rs
Cow::Owned(Value::from(n).wrap())
Value::from(n).wrap()
}
(Op::Misc(_), _) => unreachable!(),
(Op::Atom(AtomMinor::SignedInteger), arg) => {
let count = self.wirelength(arg)?;
let n = self.read_number_format_b(count)?;
Cow::Owned(Value::SignedInteger(n).wrap())
Value::SignedInteger(n).wrap()
}
(Op::Atom(minor), arg) => {
let count = self.wirelength(arg)?;
Cow::Owned(decodebinary(minor, self.readbytes(count)?)?)
decodebinary(minor, self.readbytes(count)?)?
}
(Op::Compound(minor), arg) => {
let count = self.wirelength(arg)?;
Cow::Owned(decodecompound(minor, CountedStream {
decodecompound(minor, CountedStream {
reader: ConfiguredBinaryReader {
reader: self,
read_annotations,
phantom: PhantomData,
},
count,
})?)
})?
}
(Op::Reserved(3), 15) => continue,
(Op::Reserved(_), _) => return Err(InvalidOp.into()),
@ -727,13 +729,15 @@ impl<'de, S: BinarySource<'de>> Reader<'de> for BinaryReader<'de, S> {
match self.peek_next_nonannotation_op()? {
(Op::Misc(0), 2) => {
self.skip()?;
let bs: &[u8] = &self.readbytes(4)?;
Ok(f32::from_bits(u32::from_be_bytes(bs.try_into().unwrap())))
let mut bs = [0; 4];
self.readbytes_into(&mut bs)?;
Ok(f32::from_bits(u32::from_be_bytes(bs)))
},
(Op::Misc(0), 3) => {
self.skip()?;
let bs: &[u8] = &self.readbytes(8)?;
Ok(f64::from_bits(u64::from_be_bytes(bs.try_into().unwrap())) as f32)
let mut bs = [0; 8];
self.readbytes_into(&mut bs)?;
Ok(f64::from_bits(u64::from_be_bytes(bs)) as f32)
},
_ => Err(self.expected(ExpectedKind::Float)),
}
@ -743,13 +747,15 @@ impl<'de, S: BinarySource<'de>> Reader<'de> for BinaryReader<'de, S> {
match self.peek_next_nonannotation_op()? {
(Op::Misc(0), 2) => {
self.skip()?;
let bs: &[u8] = &self.readbytes(4)?;
Ok(f32::from_bits(u32::from_be_bytes(bs.try_into().unwrap())) as f64)
let mut bs = [0; 4];
self.readbytes_into(&mut bs)?;
Ok(f32::from_bits(u32::from_be_bytes(bs)) as f64)
},
(Op::Misc(0), 3) => {
self.skip()?;
let bs: &[u8] = &self.readbytes(8)?;
Ok(f64::from_bits(u64::from_be_bytes(bs.try_into().unwrap())))
let mut bs = [0; 8];
self.readbytes_into(&mut bs)?;
Ok(f64::from_bits(u64::from_be_bytes(bs)))
},
_ => Err(self.expected(ExpectedKind::Double)),
}
@ -781,7 +787,7 @@ struct CountedStream<'de, 'a, S: BinarySource<'de>> {
impl<'de, 'a, S: BinarySource<'de>> Iterator for CountedStream<'de, 'a, S>
{
type Item = IOResult<Cow<'de, IOValue>>;
type Item = IOResult<IOValue>;
fn next(&mut self) -> Option<Self::Item> {
if self.count == 0 { return None }
self.count -= 1;
@ -795,7 +801,7 @@ struct DelimitedStream<'de, 'a, S: BinarySource<'de>> {
impl<'de, 'a, S: BinarySource<'de>> Iterator for DelimitedStream<'de, 'a, S>
{
type Item = IOResult<Cow<'de, IOValue>>;
type Item = IOResult<IOValue>;
fn next(&mut self) -> Option<Self::Item> {
match self.reader.reader.peekend() {
Err(e) => Some(Err(e)),
@ -827,7 +833,7 @@ pub fn decodebinary<'de>(minor: AtomMinor, bs: Cow<'de, [u8]>) -> IOResult<IOVal
})
}
pub fn decodecompound<'de, I: Iterator<Item = IOResult<Cow<'de, IOValue>>>>(
pub fn decodecompound<'de, I: Iterator<Item = IOResult<IOValue>>>(
minor: CompoundMinor,
mut iter: I
) ->
@ -835,7 +841,7 @@ pub fn decodecompound<'de, I: Iterator<Item = IOResult<Cow<'de, IOValue>>>>(
{
match minor {
CompoundMinor::Record => {
let vs = iter.map(|r| r.map(|c| c.into_owned())).collect::<IOResult<Vec<IOValue>>>()?;
let vs = iter.collect::<IOResult<Vec<IOValue>>>()?;
if vs.len() < 1 {
Err(io_syntax_error("Too few elements in encoded record"))
} else {
@ -843,21 +849,21 @@ pub fn decodecompound<'de, I: Iterator<Item = IOResult<Cow<'de, IOValue>>>>(
}
}
CompoundMinor::Sequence => {
let vs = iter.map(|r| r.map(|c| c.into_owned())).collect::<IOResult<Vec<IOValue>>>()?;
let vs = iter.collect::<IOResult<Vec<IOValue>>>()?;
Ok(Value::Sequence(vs).wrap())
}
CompoundMinor::Set => {
let mut s = Set::new();
for res in iter { s.insert(res?.into_owned()); }
for res in iter { s.insert(res?); }
Ok(Value::Set(s).wrap())
}
CompoundMinor::Dictionary => {
let mut d = Map::new();
while let Some(kres) = iter.next() {
let k = kres?.into_owned();
let k = kres?;
match iter.next() {
Some(vres) => {
let v = vres?.into_owned();
let v = vres?;
d.insert(k, v);
}
None => return Err(io_syntax_error("Missing dictionary value")),