11 files changed, 567 insertions, 149 deletions

diff --git a/Cargo.toml b/Cargo.toml
index d511387..71fef29 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -12,6 +12,5 @@ categories = ["compression", "filesystem"]
 exclude = [".vscode/"]
 
 [dependencies]
-bincode = "1.3.3"
 chrono = "0.4.29"
 serde = { version = "1.0.203", features = ["derive"] }
diff --git a/src/error.rs b/src/error.rs
index 9252762..7172d04 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -27,15 +27,7 @@ impl<E: Error> Display for ArchiveError<E> {
     }
 }
 
-impl<E: Error> Error for ArchiveError<E> {
-    fn source(&self) -> Option<&(dyn Error + 'static)> {
-        match self {
-            Self::IO { error } => Some(error),
-            Self::Serde { .. } => None,
-            Self::Archivator { module, error } => None,
-        }
-    }
-}
+impl<E: Error> Error for ArchiveError<E> {}
 
 impl<E: Error> serde::ser::Error for ArchiveError<E> {
     fn custom<T: Display>(msg: T) -> Self {
diff --git a/src/structs/de.rs b/src/structs/de.rs
index e69de29..9158d90 100644
--- a/src/structs/de.rs
+++ b/src/structs/de.rs
@@ -0,0 +1,365 @@
+use crate::structs::{Settings, StructError, StructResult};
+use crate::ArchiveError;
+use serde::de;
+
+pub struct ArchiveDeserializer<'de> {
+    bytes: &'de [u8],
+    pointer: usize,
+    settings: Settings,
+}
+
+struct SeqDeserializer<'a, 'de: 'a> {
+    de: &'a mut ArchiveDeserializer<'de>,
+    len: usize,
+}
+
+struct EnumDeserializer<'a, 'de: 'a> {
+    de: &'a mut ArchiveDeserializer<'de>,
+}
+
+impl<'de> ArchiveDeserializer<'de> {
+    pub fn new(bytes: &'de [u8], settings: Settings) -> Self {
+        Self {
+            bytes,
+            pointer: 0,
+            settings,
+        }
+    }
+
+    fn take<const S: usize>(&mut self) -> StructResult<[u8; S]> {
+        let bytes = self
+            .bytes
+            .get(self.pointer..self.pointer + S)
+            .ok_or(StructError::UnexpectedEOF)?
+            .try_into()
+            .unwrap();
+        self.pointer += S;
+        Ok(bytes)
+    }
+
+    fn take_byte(&mut self) -> StructResult<u8> {
+        let byte = self
+            .bytes
+            .get(self.pointer)
+            .ok_or(StructError::UnexpectedEOF)?;
+        self.pointer += 1;
+        Ok(*byte)
+    }
+}
+
+impl<'a, 'de> SeqDeserializer<'a, 'de> {
+    pub fn new(de: &'a mut ArchiveDeserializer<'de>, len: usize) -> Self {
+        Self { de, len }
+    }
+}
+
+impl<'a, 'de> EnumDeserializer<'a, 'de> {
+    pub fn new(de: &'a mut ArchiveDeserializer<'de>) -> Self {
+        Self { de }
+    }
+}
+
+impl<'de> de::Deserializer<'de> for &mut ArchiveDeserializer<'de> {
+    type Error = ArchiveError<StructError>;
+
+    fn deserialize_any<V>(self, _visitor: V) -> StructResult<V::Value>
+    where
+        V: de::Visitor<'de>,
+    {
+        Err(StructError::DeserializationNotSupported { type_name: "any" }.into())
+    }
+
+    fn deserialize_bool<V>(self, visitor: V) -> StructResult<V::Value>
+    where
+        V: de::Visitor<'de>,
+    {
+        visitor.visit_bool(self.take_byte()? != 0)
+    }
+
+    fn deserialize_i8<V>(self, visitor: V) -> StructResult<V::Value>
+    where
+        V: de::Visitor<'de>,
+    {
+        visitor.visit_i8(self.take_byte()? as i8)
+    }
+
+    fn deserialize_i16<V>(self, visitor: V) -> StructResult<V::Value>
+    where
+        V: de::Visitor<'de>,
+    {
+        let bytes = self.take()?;
+        visitor.visit_i16(self.settings.byte_order.to_i16(bytes))
+    }
+
+    fn deserialize_i32<V>(self, visitor: V) -> StructResult<V::Value>
+    where
+        V: de::Visitor<'de>,
+    {
+        let bytes = self.take()?;
+        visitor.visit_i32(self.settings.byte_order.to_i32(bytes))
+    }
+
+    fn deserialize_i64<V>(self, visitor: V) -> StructResult<V::Value>
+    where
+        V: de::Visitor<'de>,
+    {
+        let bytes = self.take()?;
+        visitor.visit_i64(self.settings.byte_order.to_i64(bytes))
+    }
+
+    fn deserialize_u8<V>(self, visitor: V) -> StructResult<V::Value>
+    where
+        V: de::Visitor<'de>,
+    {
+        visitor.visit_u8(self.take_byte()?)
+    }
+
+    fn deserialize_u16<V>(self, visitor: V) -> StructResult<V::Value>
+    where
+        V: de::Visitor<'de>,
+    {
+        let bytes = self.take()?;
+        visitor.visit_u16(self.settings.byte_order.to_u16(bytes))
+    }
+
+    fn deserialize_u32<V>(self, visitor: V) -> StructResult<V::Value>
+    where
+        V: de::Visitor<'de>,
+    {
+        let bytes = self.take()?;
+        visitor.visit_u32(self.settings.byte_order.to_u32(bytes))
+    }
+
+    fn deserialize_u64<V>(self, visitor: V) -> StructResult<V::Value>
+    where
+        V: de::Visitor<'de>,
+    {
+        let bytes = self.take()?;
+        visitor.visit_u64(self.settings.byte_order.to_u64(bytes))
+    }
+
+    fn deserialize_f32<V>(self, visitor: V) -> StructResult<V::Value>
+    where
+        V: de::Visitor<'de>,
+    {
+        let bytes = self.take()?;
+        visitor.visit_f32(self.settings.byte_order.to_f32(bytes))
+    }
+
+    fn deserialize_f64<V>(self, visitor: V) -> StructResult<V::Value>
+    where
+        V: de::Visitor<'de>,
+    {
+        let bytes = self.take()?;
+        visitor.visit_f64(self.settings.byte_order.to_f64(bytes))
+    }
+
+    fn deserialize_char<V>(self, _visitor: V) -> StructResult<V::Value>
+    where
+        V: de::Visitor<'de>,
+    {
+        Err(StructError::DeserializationNotSupported { type_name: "char" }.into())
+    }
+
+    fn deserialize_str<V>(self, _visitor: V) -> StructResult<V::Value>
+    where
+        V: de::Visitor<'de>,
+    {
+        Err(StructError::DeserializationNotSupported { type_name: "str" }.into())
+    }
+
+    fn deserialize_string<V>(self, _visitor: V) -> StructResult<V::Value>
+    where
+        V: de::Visitor<'de>,
+    {
+        Err(StructError::DeserializationNotSupported {
+            type_name: "string",
+        }
+        .into())
+    }
+
+    fn deserialize_bytes<V>(self, _visitor: V) -> StructResult<V::Value>
+    where
+        V: de::Visitor<'de>,
+    {
+        Err(StructError::DeserializationNotSupported { type_name: "bytes" }.into())
+    }
+
+    fn deserialize_byte_buf<V>(self, _visitor: V) -> StructResult<V::Value>
+    where
+        V: de::Visitor<'de>,
+    {
+        Err(StructError::DeserializationNotSupported { type_name: "bytes" }.into())
+    }
+
+    fn deserialize_option<V>(self, _visitor: V) -> StructResult<V::Value>
+    where
+        V: de::Visitor<'de>,
+    {
+        Err(StructError::DeserializationNotSupported {
+            type_name: "optional",
+        }
+        .into())
+    }
+
+    fn deserialize_unit<V>(self, visitor: V) -> StructResult<V::Value>
+    where
+        V: de::Visitor<'de>,
+    {
+        visitor.visit_unit()
+    }
+
+    fn deserialize_unit_struct<V>(self, _name: &'static str, visitor: V) -> StructResult<V::Value>
+    where
+        V: de::Visitor<'de>,
+    {
+        self.deserialize_unit(visitor)
+    }
+
+    fn deserialize_newtype_struct<V>(
+        self,
+        _name: &'static str,
+        visitor: V,
+    ) -> StructResult<V::Value>
+    where
+        V: de::Visitor<'de>,
+    {
+        visitor.visit_newtype_struct(self)
+    }
+
+    fn deserialize_seq<V>(self, _visitor: V) -> StructResult<V::Value>
+    where
+        V: de::Visitor<'de>,
+    {
+        Err(StructError::DeserializationNotSupported { type_name: "seq" }.into())
+    }
+
+    fn deserialize_tuple<V>(self, len: usize, visitor: V) -> StructResult<V::Value>
+    where
+        V: de::Visitor<'de>,
+    {
+        visitor.visit_seq(SeqDeserializer::new(self, len))
+    }
+
+    fn deserialize_tuple_struct<V>(
+        self,
+        _name: &'static str,
+        len: usize,
+        visitor: V,
+    ) -> StructResult<V::Value>
+    where
+        V: de::Visitor<'de>,
+    {
+        self.deserialize_tuple(len, visitor)
+    }
+
+    fn deserialize_map<V>(self, _visitor: V) -> StructResult<V::Value>
+    where
+        V: de::Visitor<'de>,
+    {
+        Err(StructError::DeserializationNotSupported { type_name: "map" }.into())
+    }
+
+    fn deserialize_struct<V>(
+        self,
+        _name: &'static str,
+        fields: &'static [&'static str],
+        visitor: V,
+    ) -> StructResult<V::Value>
+    where
+        V: de::Visitor<'de>,
+    {
+        self.deserialize_tuple(fields.len(), visitor)
+    }
+
+    fn deserialize_enum<V>(
+        self,
+        _name: &'static str,
+        _variants: &'static [&'static str],
+        visitor: V,
+    ) -> StructResult<V::Value>
+    where
+        V: de::Visitor<'de>,
+    {
+        visitor.visit_enum(EnumDeserializer::new(self))
+    }
+
+    fn deserialize_identifier<V>(self, visitor: V) -> StructResult<V::Value>
+    where
+        V: de::Visitor<'de>,
+    {
+        match self.settings.variant_index_type {
+            super::VariantIndexType::U8 => self.deserialize_u8(visitor),
+            super::VariantIndexType::U16 => self.deserialize_u16(visitor),
+            super::VariantIndexType::U32 => self.deserialize_u32(visitor),
+            super::VariantIndexType::U64 => self.deserialize_u64(visitor),
+        }
+    }
+
+    #[inline]
+    fn deserialize_ignored_any<V>(self, visitor: V) -> StructResult<V::Value>
+    where
+        V: de::Visitor<'de>,
+    {
+        self.deserialize_any(visitor)
+    }
+}
+
+impl<'a, 'de> de::SeqAccess<'de> for SeqDeserializer<'a, 'de> {
+    type Error = ArchiveError<StructError>;
+
+    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
+    where
+        T: de::DeserializeSeed<'de>,
+    {
+        if self.len == 0 {
+            return Ok(None);
+        }
+        seed.deserialize(&mut *self.de).map(Some)
+    }
+}
+
+impl<'a, 'de> de::EnumAccess<'de> for EnumDeserializer<'a, 'de> {
+    type Error = ArchiveError<StructError>;
+    type Variant = Self;
+
+    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error>
+    where
+        V: de::DeserializeSeed<'de>,
+    {
+        Ok((seed.deserialize(&mut *self.de)?, self))
+    }
+}
+
+impl<'a, 'de> de::VariantAccess<'de> for EnumDeserializer<'a, 'de> {
+    type Error = ArchiveError<StructError>;
+
+    fn unit_variant(self) -> Result<(), Self::Error> {
+        Ok(())
+    }
+
+    fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Self::Error>
+    where
+        T: de::DeserializeSeed<'de>,
+    {
+        seed.deserialize(&mut *self.de)
+    }
+
+    fn tuple_variant<V>(self, len: usize, visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: de::Visitor<'de>,
+    {
+        de::Deserializer::deserialize_tuple(self.de, len, visitor)
+    }
+
+    fn struct_variant<V>(
+        self,
+        fields: &'static [&'static str],
+        visitor: V,
+    ) -> Result<V::Value, Self::Error>
+    where
+        V: de::Visitor<'de>,
+    {
+        de::Deserializer::deserialize_tuple(self.de, fields.len(), visitor)
+    }
+}
diff --git a/src/structs/error.rs b/src/structs/error.rs
index b9d765d..f08c9a3 100644
--- a/src/structs/error.rs
+++ b/src/structs/error.rs
@@ -6,7 +6,9 @@ pub type StructResult<T> = ArchiveResult<T, StructError>;
 
 #[derive(Debug)]
 pub enum StructError {
-    IncorrectEnumVariant,
+    SerializationNotSupported { type_name: &'static str },
+    DeserializationNotSupported { type_name: &'static str },
+    UnexpectedEOF,
 }
 
 impl From<StructError> for ArchiveError<StructError> {
@@ -21,7 +23,13 @@ impl From<StructError> for ArchiveError<StructError> {
 impl Display for StructError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
-            StructError::IncorrectEnumVariant => write!(f, "Can't cast enum variant type"),
+            StructError::SerializationNotSupported { type_name } => {
+                writeln!(f, "Serialization for type '{type_name}' not supported")
+            }
+            StructError::DeserializationNotSupported { type_name } => {
+                writeln!(f, "Deserialization for type '{type_name}' not supported")
+            }
+            StructError::UnexpectedEOF => writeln!(f, "Unexpected EOF"),
         }
     }
 }
diff --git a/src/structs/mod.rs b/src/structs/mod.rs
index feb37dd..36bc33e 100644
--- a/src/structs/mod.rs
+++ b/src/structs/mod.rs
@@ -3,6 +3,7 @@ mod error;
 pub mod ser;
 mod settings;
 
+pub use de::ArchiveDeserializer;
 pub use error::{StructError, StructResult};
 pub use ser::ArchiveSerializer;
 pub use settings::{ByteOrder, Settings, VariantIndexType};
diff --git a/src/structs/ser.rs b/src/structs/ser.rs
index 8aa95a5..6833fb8 100644
--- a/src/structs/ser.rs
+++ b/src/structs/ser.rs
@@ -43,17 +43,17 @@ impl ser::Serializer for &mut ArchiveSerializer {
     }
 
     fn serialize_i16(self, v: i16) -> StructResult<()> {
-        self.bytes.append(&mut self.settings.byte_order.i16(v));
+        self.bytes.append(&mut self.settings.byte_order.form_i16(v));
         Ok(())
     }
 
     fn serialize_i32(self, v: i32) -> StructResult<()> {
-        self.bytes.append(&mut self.settings.byte_order.i32(v));
+        self.bytes.append(&mut self.settings.byte_order.form_i32(v));
         Ok(())
     }
 
     fn serialize_i64(self, v: i64) -> StructResult<()> {
-        self.bytes.append(&mut self.settings.byte_order.i64(v));
+        self.bytes.append(&mut self.settings.byte_order.form_i64(v));
         Ok(())
     }
 
@@ -63,54 +63,57 @@ impl ser::Serializer for &mut ArchiveSerializer {
     }
 
     fn serialize_u16(self, v: u16) -> StructResult<()> {
-        self.bytes.append(&mut self.settings.byte_order.u16(v));
+        self.bytes.append(&mut self.settings.byte_order.form_u16(v));
         Ok(())
     }
 
     fn serialize_u32(self, v: u32) -> StructResult<()> {
-        self.bytes.append(&mut self.settings.byte_order.u32(v));
+        self.bytes.append(&mut self.settings.byte_order.form_u32(v));
         Ok(())
     }
 
     fn serialize_u64(self, v: u64) -> StructResult<()> {
-        self.bytes.append(&mut self.settings.byte_order.u64(v));
+        self.bytes.append(&mut self.settings.byte_order.form_u64(v));
         Ok(())
     }
 
     fn serialize_f32(self, v: f32) -> StructResult<()> {
-        self.bytes.append(&mut self.settings.byte_order.f32(v));
+        self.bytes.append(&mut self.settings.byte_order.form_f32(v));
         Ok(())
     }
 
     fn serialize_f64(self, v: f64) -> StructResult<()> {
-        self.bytes.append(&mut self.settings.byte_order.f64(v));
+        self.bytes.append(&mut self.settings.byte_order.form_f64(v));
         Ok(())
     }
 
     fn serialize_char(self, v: char) -> StructResult<()> {
-        self.bytes.push(v as u8);
-        Ok(())
+        Err(StructError::SerializationNotSupported { type_name: "char" }.into())
     }
 
-    fn serialize_str(self, v: &str) -> StructResult<()> {
-        self.bytes.append(&mut v.as_bytes().to_vec());
-        Ok(())
+    fn serialize_str(self, _v: &str) -> StructResult<()> {
+        Err(StructError::SerializationNotSupported { type_name: "str" }.into())
     }
 
-    fn serialize_bytes(self, v: &[u8]) -> StructResult<()> {
-        self.bytes.append(&mut v.to_vec());
-        Ok(())
+    fn serialize_bytes(self, _v: &[u8]) -> StructResult<()> {
+        Err(StructError::SerializationNotSupported { type_name: "bytes" }.into())
     }
 
     fn serialize_none(self) -> StructResult<()> {
-        Ok(())
+        Err(StructError::SerializationNotSupported {
+            type_name: "optional",
+        }
+        .into())
     }
 
     fn serialize_some<T>(self, value: &T) -> StructResult<()>
     where
         T: ?Sized + Serialize,
     {
-        value.serialize(self)
+        Err(StructError::SerializationNotSupported {
+            type_name: "optional",
+        }
+        .into())
     }
 
     fn serialize_unit(self) -> StructResult<()> {
@@ -131,7 +134,7 @@ impl ser::Serializer for &mut ArchiveSerializer {
             &mut self
                 .settings
                 .variant_index_type
-                .cast(variant_index, &self.settings.byte_order)?,
+                .cast(variant_index, &self.settings.byte_order),
         );
         Ok(())
     }
@@ -157,13 +160,13 @@ impl ser::Serializer for &mut ArchiveSerializer {
             &mut self
                 .settings
                 .variant_index_type
-                .cast(variant_index, &self.settings.byte_order)?,
+                .cast(variant_index, &self.settings.byte_order),
         );
         value.serialize(self)
     }
 
     fn serialize_seq(self, _len: Option<usize>) -> StructResult<Self::SerializeSeq> {
-        Ok(self)
+        Err(StructError::SerializationNotSupported { type_name: "seq" }.into())
     }
 
     fn serialize_tuple(self, _len: usize) -> StructResult<Self::SerializeTuple> {
@@ -189,13 +192,13 @@ impl ser::Serializer for &mut ArchiveSerializer {
             &mut self
                 .settings
                 .variant_index_type
-                .cast(variant_index, &self.settings.byte_order)?,
+                .cast(variant_index, &self.settings.byte_order),
         );
         Ok(self)
     }
 
     fn serialize_map(self, _len: Option<usize>) -> StructResult<Self::SerializeMap> {
-        Ok(self)
+        Err(StructError::SerializationNotSupported { type_name: "map" }.into())
     }
 
     fn serialize_struct(
@@ -217,7 +220,7 @@ impl ser::Serializer for &mut ArchiveSerializer {
             &mut self
                 .settings
                 .variant_index_type
-                .cast(variant_index, &self.settings.byte_order)?,
+                .cast(variant_index, &self.settings.byte_order),
         );
         Ok(self)
     }
@@ -227,15 +230,15 @@ impl ser::SerializeSeq for &mut ArchiveSerializer {
     type Ok = ();
     type Error = ArchiveError<StructError>;
 
-    fn serialize_element<T>(&mut self, value: &T) -> StructResult<()>
+    fn serialize_element<T>(&mut self, _value: &T) -> StructResult<()>
     where
         T: ?Sized + Serialize,
     {
-        value.serialize(&mut **self)
+        Err(StructError::SerializationNotSupported { type_name: "seq" }.into())
     }
 
     fn end(self) -> StructResult<()> {
-        Ok(())
+        Err(StructError::SerializationNotSupported { type_name: "seq" }.into())
     }
 }
 
@@ -291,22 +294,22 @@ impl ser::SerializeMap for &mut ArchiveSerializer {
     type Ok = ();
     type Error = ArchiveError<StructError>;
 
-    fn serialize_key<T>(&mut self, key: &T) -> StructResult<()>
+    fn serialize_key<T>(&mut self, _key: &T) -> StructResult<()>
     where
         T: ?Sized + Serialize,
     {
-        key.serialize(&mut **self)
+        Err(StructError::SerializationNotSupported { type_name: "map" }.into())
     }
 
-    fn serialize_value<T>(&mut self, value: &T) -> StructResult<()>
+    fn serialize_value<T>(&mut self, _value: &T) -> StructResult<()>
     where
         T: ?Sized + Serialize,
     {
-        value.serialize(&mut **self)
+        Err(StructError::SerializationNotSupported { type_name: "map" }.into())
     }
 
     fn end(self) -> StructResult<()> {
-        Ok(())
+        Err(StructError::SerializationNotSupported { type_name: "map" }.into())
     }
 }
 
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 {
diff --git a/src/structs/tests.rs b/src/structs/tests.rs
index 0fa5347..9ee7ce5 100644
--- a/src/structs/tests.rs
+++ b/src/structs/tests.rs
@@ -1,27 +1,26 @@
 use crate::structs::{ByteOrder, Settings, VariantIndexType};
-use serde::Serialize;
+use serde::{Deserialize, Serialize};
 
-#[derive(Serialize)]
-struct Struct<'a> {
+#[derive(Serialize, Deserialize, Debug, PartialEq)]
+struct Struct {
     u8: u8,
     u16: u16,
     u32: u32,
     u64: u64,
     u8arr: [u8; 3],
     tuple: (u16, u8),
-    str: &'a str,
 }
 
-#[derive(Serialize)]
-enum Enum<'a> {
+#[derive(Serialize, Deserialize, Debug, PartialEq)]
+enum Enum {
     Unit,
     Type(u16),
-    Tuple(u16, &'a str),
+    Tuple(u16, u8),
     Struct { u32: u32, u64: u64 },
 }
 
 #[test]
-fn struct_serialize_test() {
+fn struct_serialize() {
     let object = Struct {
         u8: 42,
         u16: 26,
@@ -29,7 +28,6 @@ fn struct_serialize_test() {
         u64: 11,
         u8arr: [37, 74, 111],
         tuple: (24, 13),
-        str: "yes",
     };
 
     let bytes = Settings::default()
@@ -38,8 +36,7 @@ fn struct_serialize_test() {
         .unwrap();
     assert_eq!(
         bytes,
-        //u8|-u16--|----u32-----|----------u64-----------|[0]-[1]--[2]|.0 --.1---|-y----e----s|
-        [42, 26, 0, 69, 0, 0, 0, 11, 0, 0, 0, 0, 0, 0, 0, 37, 74, 111, 24, 0, 13, 121, 101, 115]
+        [42, 26, 0, 69, 0, 0, 0, 11, 0, 0, 0, 0, 0, 0, 0, 37, 74, 111, 24, 0, 13]
     );
 
     let bytes = Settings::default()
@@ -48,13 +45,12 @@ fn struct_serialize_test() {
         .unwrap();
     assert_eq!(
         bytes,
-        //u8|-u16--|----u32-----|----------u64-----------|[0]-[1]--[2]|.0 --.1---|-y----e----s|
-        [42, 0, 26, 0, 0, 0, 69, 0, 0, 0, 0, 0, 0, 0, 11, 37, 74, 111, 0, 24, 13, 121, 101, 115]
+        [42, 0, 26, 0, 0, 0, 69, 0, 0, 0, 0, 0, 0, 0, 11, 37, 74, 111, 0, 24, 13]
     );
 }
 
 #[test]
-fn enum_serialize_test() {
+fn enum_serialize() {
     let bytes = Settings::default()
         .byte_order(ByteOrder::Le)
         .variant_index_type(VariantIndexType::U8)
@@ -72,9 +68,9 @@ fn enum_serialize_test() {
     let bytes = Settings::default()
         .byte_order(ByteOrder::Le)
         .variant_index_type(VariantIndexType::U32)
-        .serialize(&Enum::Tuple(26, "yes"))
+        .serialize(&Enum::Tuple(26, 15))
         .unwrap();
-    assert_eq!(bytes, [2, 0, 0, 0, 26, 0, 121, 101, 115]);
+    assert_eq!(bytes, [2, 0, 0, 0, 26, 0, 15]);
 
     let bytes = Settings::default()
         .byte_order(ByteOrder::Be)
@@ -86,3 +82,70 @@ fn enum_serialize_test() {
         [0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 69, 0, 0, 0, 0, 0, 0, 0, 37]
     );
 }
+
+#[test]
+fn struct_deserialize() {
+    let object = Struct {
+        u8: 42,
+        u16: 26,
+        u32: 69,
+        u64: 11,
+        u8arr: [37, 74, 111],
+        tuple: (24, 13),
+    };
+
+    assert_eq!(
+        Settings::default()
+            .byte_order(ByteOrder::Le)
+            .deserialize::<Struct>(&[
+                42, 26, 0, 69, 0, 0, 0, 11, 0, 0, 0, 0, 0, 0, 0, 37, 74, 111, 24, 0, 13,
+            ])
+            .unwrap(),
+        object
+    );
+    assert_eq!(
+        Settings::default()
+            .byte_order(ByteOrder::Be)
+            .deserialize::<Struct>(&[
+                42, 0, 26, 0, 0, 0, 69, 0, 0, 0, 0, 0, 0, 0, 11, 37, 74, 111, 0, 24, 13
+            ])
+            .unwrap(),
+        object
+    );
+}
+
+#[test]
+fn enum_deserialize() {
+    assert_eq!(
+        Settings::default()
+            .byte_order(ByteOrder::Le)
+            .variant_index_type(VariantIndexType::U8)
+            .deserialize::<Enum>(&[0])
+            .unwrap(),
+        Enum::Unit
+    );
+    assert_eq!(
+        Settings::default()
+            .byte_order(ByteOrder::Le)
+            .variant_index_type(VariantIndexType::U16)
+            .deserialize::<Enum>(&[1, 0, 42, 0])
+            .unwrap(),
+        Enum::Type(42)
+    );
+    assert_eq!(
+        Settings::default()
+            .byte_order(ByteOrder::Le)
+            .variant_index_type(VariantIndexType::U32)
+            .deserialize::<Enum>(&[2, 0, 0, 0, 26, 0, 15])
+            .unwrap(),
+        Enum::Tuple(26, 15)
+    );
+    assert_eq!(
+        Settings::default()
+            .byte_order(ByteOrder::Be)
+            .variant_index_type(VariantIndexType::U64)
+            .deserialize::<Enum>(&[0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 69, 0, 0, 0, 0, 0, 0, 0, 37])
+            .unwrap(),
+        Enum::Struct { u32: 69, u64: 37 }
+    );
+}
diff --git a/src/zip/driver.rs b/src/zip/driver.rs
index d575509..e5aa58d 100644
--- a/src/zip/driver.rs
+++ b/src/zip/driver.rs
@@ -1,6 +1,6 @@
 use crate::driver::{ArchiveRead, ArchiveWrite, Driver};
 use crate::zip::error::{ZipError, ZipResult};
-use crate::zip::structs::{EOCDR64Locator, CDR, EOCDR, EOCDR64};
+use crate::zip::structs::{deserialize, EOCDR64Locator, CDR, EOCDR, EOCDR64};
 use crate::zip::ZipFile;
 use std::collections::HashMap as Map;
 use std::fs::File;
@@ -41,7 +41,7 @@ impl<IO: Read + Seek> ArchiveRead for Zip<IO> {
             io.read(&mut buf)?;
             buf
         };
-        let eocdr: EOCDR = bincode::deserialize(&buf).map_err(|_| ZipError::InvalidEOCDR)?;
+        let eocdr: EOCDR = deserialize(&buf).map_err(|_| ZipError::InvalidEOCDR)?;
         let comment = {
             let mut buf: Vec<u8> = vec![0; eocdr.comment_len as usize];
             io.read(&mut buf)?;
@@ -55,31 +55,31 @@ impl<IO: Read + Seek> ArchiveRead for Zip<IO> {
             io.read(&mut buf)?;
             buf
         };
-        let (cd_pointer, cd_size, cd_records) =
-            if u32::from_le_bytes(buf[0..4].try_into().unwrap()) == 0x07064b50 {
-                let eocdr64locator: EOCDR64Locator =
-                    bincode::deserialize(&buf[4..]).map_err(|_| ZipError::InvalidEOCDR64Locator)?;
-
-                io.seek(SeekFrom::Start(eocdr64locator.eocdr64_pointer))?;
-                let buf = {
-                    let mut buf = [0; 56];
-                    io.read(&mut buf)?;
-                    buf
-                };
-                if u32::from_le_bytes(buf[0..4].try_into().unwrap()) != 0x06064b50 {
-                    return Err(ZipError::InvalidEOCDR64Signature.into());
-                }
-                let eocdr64: EOCDR64 =
-                    bincode::deserialize(&buf[4..]).map_err(|_| ZipError::InvalidEOCDR64)?;
-
-                (eocdr64.cd_pointer, eocdr64.cd_size, eocdr64.cd_records)
-            } else {
-                (
-                    eocdr.cd_pointer as u64,
-                    eocdr.cd_size as u64,
-                    eocdr.cd_records as u64,
-                )
+        let (cd_pointer, cd_size, cd_records) = if u32::from_le_bytes(buf[0..4].try_into().unwrap())
+            == 0x07064b50
+        {
+            let eocdr64locator: EOCDR64Locator =
+                deserialize(&buf[4..]).map_err(|_| ZipError::InvalidEOCDR64Locator)?;
+
+            io.seek(SeekFrom::Start(eocdr64locator.eocdr64_pointer))?;
+            let buf = {
+                let mut buf = [0; 56];
+                io.read(&mut buf)?;
+                buf
             };
+            if u32::from_le_bytes(buf[0..4].try_into().unwrap()) != 0x06064b50 {
+                return Err(ZipError::InvalidEOCDR64Signature.into());
+            }
+            let eocdr64: EOCDR64 = deserialize(&buf[4..]).map_err(|_| ZipError::InvalidEOCDR64)?;
+
+            (eocdr64.cd_pointer, eocdr64.cd_size, eocdr64.cd_records)
+        } else {
+            (
+                eocdr.cd_pointer as u64,
+                eocdr.cd_size as u64,
+                eocdr.cd_records as u64,
+            )
+        };
 
         // Read cd records
         let mut files = Map::with_capacity(cd_records as usize);
@@ -96,8 +96,7 @@ impl<IO: Read + Seek> ArchiveRead for Zip<IO> {
                 return Err(ZipError::InvalidCDRSignature.into());
             }
             p += 4;
-            let cdr: CDR =
-                bincode::deserialize(&buf[p..p + 42]).map_err(|_| ZipError::InvalidCDR)?;
+            let cdr: CDR = deserialize(&buf[p..p + 42]).map_err(|_| ZipError::InvalidCDR)?;
             p += 42;
             let name = String::from_utf8(buf[p..p + cdr.name_len as usize].into()).unwrap();
             p += cdr.name_len as usize;
diff --git a/src/zip/structs.rs b/src/zip/structs.rs
index e38f9f0..0f9579e 100644
--- a/src/zip/structs.rs
+++ b/src/zip/structs.rs
@@ -1,3 +1,4 @@
+use crate::structs::{Settings, StructResult};
 use serde::{Deserialize, Serialize};
 
 #[derive(Serialize, Deserialize)]
@@ -50,3 +51,11 @@ pub struct CDR {
     pub external_attributes: u32,
     pub header_pointer: u32,
 }
+
+pub fn serialize<T: Serialize>(object: &mut T) -> StructResult<Vec<u8>> {
+    Settings::default().serialize(object)
+}
+
+pub fn deserialize<'de, T: Deserialize<'de>>(object: &'de [u8]) -> StructResult<T> {
+    Settings::default().deserialize(object)
+}
diff --git a/tests/usage.rs b/tests/usage.rs
deleted file mode 100644
index 2faf517..0000000
--- a/tests/usage.rs
+++ /dev/null
@@ -1,19 +0,0 @@
-use archivator::{Archive, Zip};
-use std::fs::File;
-use std::time::{SystemTime, UNIX_EPOCH};
-
-fn time() -> f64 {
-    SystemTime::now()
-        .duration_since(UNIX_EPOCH)
-        .unwrap()
-        .as_secs_f64()
-}
-
-// #[test]
-fn time_test() {
-    let file = File::open("tests/files/1M.zip").unwrap();
-
-    let start = time();
-    let archive = Archive::<Zip>::new(file).unwrap();
-    println!("{}", time() - start);
-}