Basic error_chain compatibility

packed_struct/src/packing.rs

@@ -42,6 +42,25 @@ pub enum PackingError {
     BufferSizeMismatch { expected: usize, actual: usize }
 }
 
+impl Display for PackingError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{:?}", self)
+    }    
+}
+
+#[cfg(feature="std")]
+impl ::std::error::Error for PackingError {
+    fn description(&self) -> &str {
+        match *self {
+            PackingError::InvalidValue => "Invalid value",
+            PackingError::BitsError => "Bits error",
+            PackingError::BufferTooSmall => "Buffer too small",            
+            PackingError::BufferSizeMismatch { .. } => "Buffer size mismatched",
+            PackingError::NotImplemented => "Not implemented"
+        }
+    }
+}
+
 
 macro_rules! packing_slice {
     ($T: path; $num_bytes: expr) => (

packed_struct_codegen/src/common.rs

@@ -10,6 +10,15 @@ pub fn collections_prefix() -> syn::Ty {
     syn::parse_type("::collections").unwrap()
 }
 
+#[cfg(feature="std")]
+pub fn result_type() -> syn::Ty {
+    syn::parse_type("::std::result::Result").expect("result type parse error")
+}
+
+#[cfg(not(feature="std"))]
+pub fn result_type() -> syn::Ty {
+    syn::parse_type("::core::result::Result").expect("result type parse error")
+}
 
 
 

packed_struct_codegen/src/pack_codegen.rs

@@ -89,6 +89,8 @@ pub fn derive_pack(parsed: &PackStruct) -> quote::Tokens {
 
     }
 
+    let result_ty = result_type();
+
     quote! {
         #type_documentation
         impl #impl_generics ::packed_struct::PackedStruct<[u8; #num_bytes]> for #name #ty_generics #where_clause {
@@ -106,7 +108,7 @@ pub fn derive_pack(parsed: &PackStruct) -> quote::Tokens {
 
             #[inline]
             #[allow(unused_imports, unused_parens)]
-            fn unpack(src: &[u8; #num_bytes]) -> Result<#name, ::packed_struct::PackingError> {
+            fn unpack(src: &[u8; #num_bytes]) -> #result_ty <#name, ::packed_struct::PackingError> {
                 use ::packed_struct::*;
 
                 #(#unpack_fields)*
@@ -127,7 +129,7 @@ pub fn derive_pack(parsed: &PackStruct) -> quote::Tokens {
         impl #impl_generics ::packed_struct::PackedStructSlice for #name #ty_generics #where_clause {
             #[inline]
             #[allow(unused_imports)]
-            fn pack_to_slice(&self, output: &mut [u8]) -> Result<(), ::packed_struct::PackingError> {
+            fn pack_to_slice(&self, output: &mut [u8]) -> #result_ty <(), ::packed_struct::PackingError> {
                 use ::packed_struct::*;
 
                 if output.len() != #num_bytes {
@@ -140,7 +142,7 @@ pub fn derive_pack(parsed: &PackStruct) -> quote::Tokens {
 
             #[inline]
             #[allow(unused_imports)]
-            fn unpack_from_slice(src: &[u8]) -> Result<Self, ::packed_struct::PackingError> {
+            fn unpack_from_slice(src: &[u8]) -> #result_ty <Self, ::packed_struct::PackingError> {
                 use ::packed_struct::*;
 
                 if src.len() != #num_bytes {
@@ -325,6 +327,7 @@ fn pack_field(name: &syn::Ident, field: &FieldRegular) -> quote::Tokens {
 fn unpack_field(field: &FieldRegular) -> quote::Tokens {
     let wrappers: Vec<_> = field.serialization_wrappers.iter().rev().cloned().collect();
 
+    let result_ty = result_type();
     let mut unpack = quote! { bytes };
 
     let mut i = 0;
@@ -336,7 +339,7 @@ fn unpack_field(field: &FieldRegular) -> quote::Tokens {
                     use ::packed_struct::types::*;
                     use ::packed_struct::types::bits::*;
 
-                    let res: Result<#endian <_, _, #integer >, PackingError> = <#endian <_, _, _>>::unpack(& #unpack );
+                    let res: #result_ty <#endian <_, _, #integer >, PackingError> = <#endian <_, _, _>>::unpack(& #unpack );
                     let unpacked = try!(res);
                     **unpacked
                 };
@@ -361,7 +364,7 @@ fn unpack_field(field: &FieldRegular) -> quote::Tokens {
                     use ::packed_struct::types::*;
                     use ::packed_struct::types::bits::*;
 
-                    let res: Result<#endian <_, _, #integer_ty >, PackingError> = <#endian <_, _, #integer_ty >>::unpack(& #unpack );
+                    let res: #result_ty <#endian <_, _, #integer_ty >, PackingError> = <#endian <_, _, #integer_ty >>::unpack(& #unpack );
                     let unpacked = try!(res);
                     *unpacked
                 };
@@ -383,4 +386,4 @@ fn unpack_field(field: &FieldRegular) -> quote::Tokens {
     }
 
     unpack
-}
+}

packed_struct_codegen/src/pack_codegen_docs.rs

@@ -58,6 +58,7 @@ pub fn struct_runtime_formatter(parsed: &PackStruct) -> quote::Tokens {
     }
 
     let num_fields = debug_fields.len();
+    let result_ty = result_type();
 
     quote! {
         #[doc(hidden)]
@@ -67,7 +68,7 @@ pub fn struct_runtime_formatter(parsed: &PackStruct) -> quote::Tokens {
 
         #[allow(unused_imports)]
         impl #impl_generics ::packed_struct::debug_fmt::PackedStructDebug for #name #ty_generics #where_clause {
-            fn fmt_fields(&self, fmt: &mut #stdlib_prefix::fmt::Formatter) -> Result<(), #stdlib_prefix::fmt::Error> {
+            fn fmt_fields(&self, fmt: &mut #stdlib_prefix::fmt::Formatter) -> #result_ty <(), #stdlib_prefix::fmt::Error> {
                 use ::packed_struct::PackedStruct;
 
                 let fields = #debug_fields_fn(self);

packed_struct_tests/Cargo.toml

@@ -7,3 +7,4 @@ publish = false
 [dependencies]
 packed_struct = "^0.2.0"
 packed_struct_codegen = "^0.2.0"
+error-chain = "0.11.0"

packed_struct_tests/tests/packing_issue_10.rs

@@ -0,0 +1,69 @@
+extern crate packed_struct;
+#[macro_use]
+extern crate packed_struct_codegen;
+
+#[macro_use]
+extern crate error_chain;
+
+mod errors {
+    error_chain! {
+        foreign_links {
+            PackedStruct(::packed_struct::PackingError);
+        }
+    }
+}
+
+use errors::*;
+
+use packed_struct::prelude::*;
+
+#[derive(Debug, PackedStruct)]
+#[packed_struct(bit_numbering = "msb0")]
+pub struct LedDriverConfig {
+    #[packed_field(bits = "46:47")]
+    lodvth: Integer<u8, ::packed_bits::Bits2>,
+    #[packed_field(bits = "44:45")]
+    sel_td0: Integer<u8, ::packed_bits::Bits2>,
+    #[packed_field(bits = "43")]
+    sel_gdly: Integer<u8, ::packed_bits::Bits1>,
+    #[packed_field(bits = "42")]
+    xrefresh: Integer<u8, ::packed_bits::Bits1>,
+    #[packed_field(bits = "41")]
+    sel_gck_edge: Integer<u8, ::packed_bits::Bits1>,
+    #[packed_field(bits = "40")]
+    sel_pchg: Integer<u8, ::packed_bits::Bits1>,
+    #[packed_field(bits = "39")]
+    espwm: Integer<u8, ::packed_bits::Bits1>,
+    #[packed_field(bits = "38")]
+    lgse3: Integer<u8, ::packed_bits::Bits1>,
+    #[packed_field(bits = "37")]
+    sel_sck_edge: Integer<u8, ::packed_bits::Bits1>,
+    #[packed_field(bits = "34:36")]
+    lgse1: Integer<u8, ::packed_bits::Bits3>,
+    #[packed_field(bits = "25:33", endian = "msb")]
+    ccb: Integer<u16, ::packed_bits::Bits9>,
+    #[packed_field(bits = "16:24", endian = "msb")]
+    ccg: Integer<u16, ::packed_bits::Bits9>,
+    #[packed_field(bits = "7:15", endian = "msb")]
+    ccr: Integer<u16, ::packed_bits::Bits9>,
+    #[packed_field(bits = "4:6")]
+    bc: Integer<u8, ::packed_bits::Bits3>,
+    #[packed_field(bits = "3")]
+    poker_trans_mode: Integer<u8, ::packed_bits::Bits1>,
+    #[packed_field(bits = "0:2")]
+    lgse2: Integer<u8, ::packed_bits::Bits3>,
+}
+
+#[test]
+#[cfg(test)]
+fn test_packed_struct_issue_10() {
+    run().unwrap();
+}
+
+fn run() -> Result<()> {
+    let data = [0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF];
+    let unpacked = LedDriverConfig::unpack(&data)
+        .chain_err(|| "unable to unpack LED driver config")?;
+
+    Ok(())
+}