Avoidance of hardcoded use of IOValue in Embedded reading

implementations/rust/preserves/src/value/domain.rs

@@ -1,24 +1,38 @@
+use super::BinarySource;
 use super::Embeddable;
 use super::IOResult;
 use super::IOValue;
+use super::Reader;
+use super::packed::PackedReader;
 
 pub trait DomainDecode<D: Embeddable> {
-    fn decode_embedded_iovalue(&mut self, v: IOValue) -> IOResult<D>;
+    fn decode_embedded<'de, 'src, S: BinarySource<'de>>(
+        &mut self,
+        src: &'src mut S,
+        read_annotations: bool,
+    ) -> IOResult<D>;
 }
 
 pub struct IOValueDomainDecode;
 
 impl DomainDecode<IOValue> for IOValueDomainDecode {
-    fn decode_embedded_iovalue(&mut self, v: IOValue) -> IOResult<IOValue> {
+    fn decode_embedded<'de, 'src, S: BinarySource<'de>>(
-        Ok(v)
+        &mut self,
+        src: &'src mut S,
+        read_annotations: bool,
+    ) -> IOResult<IOValue> {
+        PackedReader::new(src, IOValueDomainDecode).demand_next(read_annotations)
     }
 }
 
 pub struct NoEmbeddedDomainDecode;
 
 impl<D: Embeddable> DomainDecode<D> for NoEmbeddedDomainDecode {
-    fn decode_embedded_iovalue(&mut self, _v: IOValue) -> IOResult<D> {
+    fn decode_embedded<'de, 'src, S: BinarySource<'de>>(
-        Err(std::io::Error::new(std::io::ErrorKind::Unsupported,
+        &mut self,
-                                "Embedded values not supported here"))
+        _src: &'src mut S,
+        _read_annotations: bool,
+    ) -> IOResult<D> {
+        Err(std::io::Error::new(std::io::ErrorKind::Unsupported, "Embedded values not supported here"))
     }
 }

implementations/rust/preserves/src/value/packed/reader.rs

@@ -13,7 +13,6 @@ use super::super::{
     DomainDecode,
     Embeddable,
     IOResult,
-    IOValueDomainDecode,
     Map,
     NestedValue,
     Record,
@@ -268,8 +267,7 @@ impl<'de, 'src, D: Embeddable, N: NestedValue<D>, Dec: DomainDecode<D>, S: Binar
                 }
             }
             Tag::Embedded => {
-                let v = PackedReader::new(self.source, IOValueDomainDecode).demand_next(read_annotations)?;
+                Value::Embedded(self.decode_embedded.decode_embedded(self.source, read_annotations)?).wrap()
-                Value::Embedded(self.decode_embedded.decode_embedded_iovalue(v)?).wrap()
             }
             Tag::SmallInteger(v) => {
                 // TODO: prebuild these in value.rs