1 files changed, 40 insertions, 42 deletions

diff --git a/src/structs/settings.rs b/src/structs/settings.rs
index 63c4d3a..fce6d9e 100644
--- a/src/structs/settings.rs
+++ b/src/structs/settings.rs
@@ -1,5 +1,6 @@
-use crate::structs::{ArchiveSerializer, StructError, StructResult};
-use serde::Serialize;
+use crate::structs::{ArchiveDeserializer, ArchiveSerializer, StructResult};
+use serde::{Deserialize, Serialize};
+use std::mem::size_of;
 
 pub enum ByteOrder {
     Le,
@@ -12,61 +13,53 @@ pub enum VariantIndexType {
     U16,
     U32,
     U64,
-    I8,
-    I16,
-    I32,
-    I64,
 }
 
 macro_rules! impl_byte_order {
-    ($($n:ident),+) => {
+    ($($to:ident $fr:ident $n:ident),+) => {
         impl ByteOrder {$(
-            pub fn $n(&self, num: $n) -> Vec<u8> {
+            pub fn $fr(&self, num: $n) -> Vec<u8> {
                 match self {
                     ByteOrder::Le => num.to_le_bytes().to_vec(),
                     ByteOrder::Be => num.to_be_bytes().to_vec(),
                     ByteOrder::Ne => num.to_ne_bytes().to_vec(),
                 }
             }
+
+            pub fn $to(&self, bytes: [u8; size_of::<$n>()]) -> $n {
+                match self {
+                    ByteOrder::Le => $n::from_le_bytes(bytes),
+                    ByteOrder::Be => $n::from_be_bytes(bytes),
+                    ByteOrder::Ne => $n::from_ne_bytes(bytes),
+                }
+            }
         )+}
     };
 }
-impl_byte_order!(u8, u16, u32, u64, i8, i16, i32, i64, f32, f64);
+
+impl_byte_order!(
+    to_u8 from_u8 u8,
+    to_u16 form_u16 u16,
+    to_u32 form_u32 u32,
+    to_u64 form_u64 u64,
+
+    to_i8 form_i8 i8,
+    to_i16 form_i16 i16,
+    to_i32 form_i32 i32,
+    to_i64 form_i64 i64,
+
+    to_f32 form_f32 f32,
+    to_f64 form_f64 f64
+);
 
 impl VariantIndexType {
-    pub fn cast(&self, num: u32, byte_order: &ByteOrder) -> StructResult<Vec<u8>> {
-        Ok(match self {
-            VariantIndexType::U8 => byte_order.u8(num
-                .try_into()
-                .map_err(|_| StructError::IncorrectEnumVariant)?),
-            VariantIndexType::U16 => byte_order.u16(
-                num.try_into()
-                    .map_err(|_| StructError::IncorrectEnumVariant)?,
-            ),
-            VariantIndexType::U32 => byte_order.u32(
-                num.try_into()
-                    .map_err(|_| StructError::IncorrectEnumVariant)?,
-            ),
-            VariantIndexType::U64 => byte_order.u64(
-                num.try_into()
-                    .map_err(|_| StructError::IncorrectEnumVariant)?,
-            ),
-            VariantIndexType::I8 => byte_order.i8(num
-                .try_into()
-                .map_err(|_| StructError::IncorrectEnumVariant)?),
-            VariantIndexType::I16 => byte_order.i16(
-                num.try_into()
-                    .map_err(|_| StructError::IncorrectEnumVariant)?,
-            ),
-            VariantIndexType::I32 => byte_order.i32(
-                num.try_into()
-                    .map_err(|_| StructError::IncorrectEnumVariant)?,
-            ),
-            VariantIndexType::I64 => byte_order.i64(
-                num.try_into()
-                    .map_err(|_| StructError::IncorrectEnumVariant)?,
-            ),
-        })
+    pub fn cast(&self, num: u32, byte_order: &ByteOrder) -> Vec<u8> {
+        match self {
+            VariantIndexType::U8 => byte_order.from_u8(num as u8),
+            VariantIndexType::U16 => byte_order.form_u16(num as u16),
+            VariantIndexType::U32 => byte_order.form_u32(num as u32),
+            VariantIndexType::U64 => byte_order.form_u64(num as u64),
+        }
     }
 }
 
@@ -98,6 +91,11 @@ impl Settings {
         object.serialize(&mut serializer)?;
         Ok(serializer.to_bytes())
     }
+
+    pub fn deserialize<'de, T: Deserialize<'de>>(self, object: &'de [u8]) -> StructResult<T> {
+        let mut deserializer = ArchiveDeserializer::new(object, self);
+        Ok(T::deserialize(&mut deserializer)?)
+    }
 }
 
 impl Default for Settings {