release 1.2.0 (#48)

* core: boxed raw value

* core: more helper

* feat: add Custom kind to error

* release 1.2.0

* more tests

Author: quininer

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "cbor4ii"
-version = "1.1.1"
+version = "1.2.0"
 authors = ["quininer <quininer@live.com>"]
 description = "CBOR: Concise Binary Object Representation"
 repository = "https://github.com/quininer/cbor4ii"

src/core.rs

@@ -13,6 +13,9 @@ use crate::alloc::{ vec::Vec, boxed::Box, string::String };
 
 pub use raw_value::RawValue;
 
+#[cfg(feature = "use_alloc")]
+pub use raw_value::boxed::BoxedRawValue;
+
 
 /// Major type
 pub mod major {

src/core/dec.rs

@@ -6,7 +6,7 @@ use crate::util::ScopeGuard;
 pub use crate::core::error::DecodeError as Error;
 
 #[cfg(feature = "use_alloc")]
-use crate::alloc::{ vec::Vec, string::String };
+use crate::alloc::{ boxed::Box, vec::Vec, string::String };
 
 
 /// Read trait
@@ -748,6 +748,18 @@ impl<'de, T: Decode<'de>> Decode<'de> for Option<T> {
     }
 }
 
+impl<'de, T: Decode<'de>> Decode<'de> for types::Maybe<Option<T>> {
+    #[inline]
+    fn decode<R: Read<'de>>(reader: &mut R) -> Result<Self, Error<R::Error>> {
+        let len = <types::Array<()>>::len(reader)?;
+        match len {
+            Some(0) => Ok(types::Maybe(None)),
+            Some(1) => T::decode(reader).map(Some).map(types::Maybe),
+            _ => Err(Error::require_length(&"maybe", len))
+        }
+    }
+}
+
 impl<'de> Decode<'de> for types::F16 {
     #[inline]
     fn decode<R: Read<'de>>(reader: &mut R) -> Result<Self, Error<R::Error>> {
@@ -808,6 +820,21 @@ impl<'de> Decode<'de> for f64 {
     }
 }
 
+impl<'de> Decode<'de> for types::Nothing {
+    #[inline]
+    fn decode<R: Read<'de>>(_reader: &mut R) -> Result<Self, Error<R::Error>> {
+        Ok(types::Nothing)
+    }
+}
+
+#[cfg(feature = "use_alloc")]
+impl<'de, T: Decode<'de>> Decode<'de> for Box<T> {
+    #[inline]
+    fn decode<R: Read<'de>>(reader: &mut R) -> Result<Self, Error<R::Error>> {
+        T::decode(reader).map(Box::new)
+    }
+}
+
 /// Ignore an arbitrary object
 pub struct IgnoredAny;
 

src/core/enc.rs

@@ -4,6 +4,8 @@ use core::convert::TryFrom;
 use crate::core::{ types, major, marker };
 pub use crate::core::error::EncodeError as Error;
 
+#[cfg(feature = "use_alloc")]
+use crate::alloc::{ boxed::Box, vec::Vec, string::String };
 
 /// Write trait
 ///
@@ -208,6 +210,14 @@ impl Encode for types::Bytes<&'_ [u8]> {
     }
 }
 
+#[cfg(feature = "use_alloc")]
+impl Encode for String {
+    #[inline]
+    fn encode<W: Write>(&self, writer: &mut W) -> Result<(), Error<W::Error>> {
+        self.as_str().encode(writer)
+    }
+}
+
 impl Encode for &'_ str {
     #[inline]
     fn encode<W: Write>(&self, writer: &mut W) -> Result<(), Error<W::Error>> {
@@ -328,6 +338,13 @@ impl Encode for types::Undefined {
     }
 }
 
+impl<T: Encode> Encode for types::Maybe<&'_ Option<T>> {
+    #[inline]
+    fn encode<W: Write>(&self, writer: &mut W) -> Result<(), Error<W::Error>> {
+        self.0.as_slice().encode(writer)
+    }
+}
+
 #[cfg(feature = "half-f16")]
 impl Encode for half::f16 {
     #[inline]
@@ -365,6 +382,29 @@ impl Encode for f64 {
     }
 }
 
+impl Encode for types::Nothing {
+    #[inline]
+    fn encode<W: Write>(&self, _writer: &mut W) -> Result<(), Error<W::Error>> {
+        Ok(())
+    }
+}
+
+#[cfg(feature = "use_alloc")]
+impl<T: Encode> Encode for Box<T> {
+    #[inline]
+    fn encode<W: Write>(&self, writer: &mut W) -> Result<(), Error<W::Error>> {
+        <T as Encode>::encode(&**self, writer)
+    }
+}
+
+#[cfg(feature = "use_alloc")]
+impl<T: Encode> Encode for Vec<T> {
+    #[inline]
+    fn encode<W: Write>(&self, writer: &mut W) -> Result<(), Error<W::Error>> {
+        self.as_slice().encode(writer)
+    }
+}
+
 // from https://www.rfc-editor.org/rfc/rfc8949.html#name-examples-of-encoded-cbor-da
 #[test]
 #[cfg(feature = "use_std")]

src/core/error.rs

@@ -68,6 +68,10 @@ pub enum DecodeError<E> {
     DepthOverflow {
         name: StaticStr
     },
+    Custom {
+        name: StaticStr,
+        num: u32
+    }
 }
 
 impl Len {
@@ -195,5 +199,5 @@ fn test_error_type_size() {
     assert_eq!(core::mem::size_of::<DecodeError<()>>(), 16);
 
     // a word type
-    assert_eq!(core::mem::size_of::<DecodeError<&'static ()>>(), 16);
+    assert_eq!(core::mem::size_of::<DecodeError<&'static u8>>(), 16);
 }

src/core/raw_value.rs

@@ -1,7 +1,7 @@
 use core::marker::PhantomData;
 use crate::core::{ enc, dec };
 
-
+#[derive(PartialEq, Eq, Debug, Clone)]
 pub struct RawValue<'de>(&'de [u8]);
 
 struct RawValueReader<'r, 'de, R>
@@ -91,13 +91,63 @@ impl enc::Encode for RawValue<'_> {
     }
 }
 
+impl<'de> RawValue<'de> {
+    pub fn as_bytes(&self) -> &'de [u8] {
+        self.0
+    }
+}
+
+#[cfg(feature = "use_alloc")]
+pub mod boxed {
+    use crate::core::Value;
+    use crate::core::utils::BufWriter;
+    use crate::alloc::boxed::Box;
+    use super::*;
+    
+    #[derive(PartialEq, Eq, Debug, Clone)]
+    pub struct BoxedRawValue(Box<[u8]>);
+
+    impl<'de> dec::Decode<'de> for BoxedRawValue {
+        #[inline]
+        fn decode<R: dec::Read<'de>>(reader: &mut R) -> Result<Self, dec::Error<R::Error>> {
+            let value = RawValue::decode(reader)?;
+            Ok(BoxedRawValue(Box::from(value.0)))
+        }
+    }
+
+    impl enc::Encode for BoxedRawValue {
+        #[inline]
+        fn encode<W: enc::Write>(&self, writer: &mut W) -> Result<(), enc::Error<W::Error>> {
+            writer.push(&self.0).map_err(enc::Error::Write)
+        }
+    }
+
+    impl BoxedRawValue {
+        pub fn as_bytes(&self) -> &[u8] {
+            &self.0
+        }
+
+        pub fn from_value(value: &Value)
+            -> Result<BoxedRawValue, enc::Error<crate::alloc::collections::TryReserveError>>
+        {
+            use crate::alloc::vec::Vec;
+            use crate::core::enc::Encode;
+            
+            let mut writer = BufWriter::new(Vec::new());
+            value.encode(&mut writer)?;
+            Ok(BoxedRawValue(writer.into_inner().into_boxed_slice()))
+        }
+    }
+}
+
 #[test]
 #[cfg(feature = "use_std")]
 fn test_raw_value() {
     use crate::core::enc::Encode;
     use crate::core::dec::Decode;
     use crate::core::utils::{ BufWriter, SliceReader };
     use crate::core::types;
+    use boxed::BoxedRawValue;
 
     let buf = {
         let mut buf = BufWriter::new(Vec::new());
@@ -111,37 +161,91 @@ fn test_raw_value() {
         buf
     };
 
-    let mut reader = SliceReader::new(buf.buffer());
-    let map = <types::Map<Vec<(&str, RawValue<'_>)>>>::decode(&mut reader).unwrap();
+    // raw value
+    {
+        let mut reader = SliceReader::new(buf.buffer());
+        let map = <types::Map<Vec<(&str, RawValue<'_>)>>>::decode(&mut reader).unwrap();
 
-    assert_eq!(map.0.len(), 1);
-    assert_eq!(map.0[0].0, "bar");
+        assert_eq!(map.0.len(), 1);
+        assert_eq!(map.0[0].0, "bar");
 
-    let bar_raw_value = &map.0[0].1;
+        let bar_raw_value = &map.0[0].1;
+        assert!(!bar_raw_value.as_bytes().is_empty());
 
-    let buf2 = {
-        let mut buf = BufWriter::new(Vec::new());
+        let buf2 = {
+            let mut buf = BufWriter::new(Vec::new());
 
-        types::Map(&[
-            ("bar", bar_raw_value)
-        ][..]).encode(&mut buf).unwrap();
+            types::Map(&[
+                ("bar", bar_raw_value)
+            ][..]).encode(&mut buf).unwrap();
 
-        buf
-    };
+            buf
+        };
+
+        assert_eq!(buf.buffer(), buf2.buffer());
+
+        type Bar<'a> = types::Map<Vec<(&'a str, u32)>>;
+
+        let mut reader = SliceReader::new(buf2.buffer());
+        let map2 = <types::Map<Vec<(&str, Bar)>>>::decode(&mut reader).unwrap();
+
+        assert_eq!(map2.0.len(), 1);
+        assert_eq!(map2.0[0].0, "bar");
+
+        let bar = &map2.0[0].1;
 
-    assert_eq!(buf.buffer(), buf2.buffer());
+        assert_eq!(bar.0.len(), 1);
+        assert_eq!(bar.0[0].0, "value");
+        assert_eq!(bar.0[0].1, 0x99);
+    }
+
+    // boxed raw value
+    {
+        let mut reader = SliceReader::new(buf.buffer());
+        let map = <types::Map<Vec<(&str, BoxedRawValue)>>>::decode(&mut reader).unwrap();
+
+        assert_eq!(map.0.len(), 1);
+        assert_eq!(map.0[0].0, "bar");
+
+        let bar_raw_value = &map.0[0].1;
+        assert!(!bar_raw_value.as_bytes().is_empty());
+
+        // check from value
+        {
+            use crate::core::Value;
+            
+            let mut reader = SliceReader::new(buf.buffer());
+            let map = <types::Map<Vec<(&str, Value)>>>::decode(&mut reader).unwrap();
+            
+            let bar_value = &map.0[0].1;
+            let bar_raw_value2 = BoxedRawValue::from_value(&bar_value).unwrap();
+            assert_eq!(bar_raw_value, &bar_raw_value2);
+        }
 
-    type Bar<'a> = types::Map<Vec<(&'a str, u32)>>;
+        let buf2 = {
+            let mut buf = BufWriter::new(Vec::new());
 
-    let mut reader = SliceReader::new(buf2.buffer());
-    let map2 = <types::Map<Vec<(&str, Bar)>>>::decode(&mut reader).unwrap();
+            types::Map(&[
+                ("bar", bar_raw_value)
+            ][..]).encode(&mut buf).unwrap();
+
+            buf
+        };
 
-    assert_eq!(map2.0.len(), 1);
-    assert_eq!(map2.0[0].0, "bar");
+        assert_eq!(buf.buffer(), buf2.buffer());
 
-    let bar = &map2.0[0].1;
+        type Bar<'a> = types::Map<Vec<(&'a str, u32)>>;
 
-    assert_eq!(bar.0.len(), 1);
-    assert_eq!(bar.0[0].0, "value");
-    assert_eq!(bar.0[0].1, 0x99);
+        let mut reader = SliceReader::new(buf2.buffer());
+        let map2 = <types::Map<Vec<(&str, Bar)>>>::decode(&mut reader).unwrap();
+
+        assert_eq!(map2.0.len(), 1);
+        assert_eq!(map2.0[0].0, "bar");
+
+        let bar = &map2.0[0].1;
+
+        assert_eq!(bar.0.len(), 1);
+        assert_eq!(bar.0[0].0, "value");
+        assert_eq!(bar.0[0].1, 0x99);        
+    }
 }

src/core/types.rs

@@ -19,3 +19,7 @@ pub struct Null;
 pub struct Undefined;
 
 pub struct F16(pub u16);
+
+pub struct Maybe<T>(pub T);
+
+pub struct Nothing;