3 files changed, 160 insertions, 5 deletions
diff --git a/src/codec/decode.rs b/src/codec/decode.rs
index 65f08b5..1059811 100644
--- a/src/codec/decode.rs
+++ b/src/codec/decode.rs
@@ -1,7 +1,91 @@
-use std::io::{self, Read};
+use std::{io::Read, sync::Arc};
+
+use crate::DEFAULT_BUFFER_LEN;
+
+macro_rules! impl_decode {
+    ($type: ty) => {
+        impl Decode for $type {
+            fn decode(reader: &mut dyn Read) -> crate::codec::error::Result<Self>
+            where
+                Self: Sized,
+            {
+                const BYTES: usize = (<$type>::BITS / 8) as usize;
+                let mut bytes = [0; BYTES];
+                reader.read_exact(&mut bytes)?;
+                Ok(<$type>::from_be_bytes(bytes))
+            }
+        }
+    };
+}
 
 pub trait Decode {
-    fn decode(reader: &impl Read) -> io::Result<Self>
+    fn decode(reader: &mut dyn Read) -> crate::codec::error::Result<Self>
     where
         Self: Sized;
 }
+
+impl Decode for bool {
+    fn decode(reader: &mut dyn Read) -> crate::codec::error::Result<Self>
+    where
+        Self: Sized,
+    {
+        let mut byte = [0_u8];
+        reader.read_exact(&mut byte)?;
+        Ok(byte[0] != 0)
+    }
+}
+
+impl Decode for Arc<[u8]> {
+    fn decode(reader: &mut dyn Read) -> crate::codec::error::Result<Self> {
+        let mut buf = Vec::with_capacity(DEFAULT_BUFFER_LEN);
+        reader.read_to_end(&mut buf)?;
+        Ok(Arc::<[u8]>::from(buf.into_boxed_slice()))
+    }
+}
+
+impl<const S: usize> Decode for [u8; S] {
+    fn decode(reader: &mut dyn Read) -> crate::codec::error::Result<Self>
+    where
+        Self: Sized,
+    {
+        let mut slice = [0_u8; S];
+        reader.read_exact(&mut slice)?;
+        Ok(slice)
+    }
+}
+
+impl_decode!(u8);
+impl_decode!(u16);
+impl_decode!(u32);
+impl_decode!(u64);
+impl_decode!(u128);
+impl_decode!(usize);
+
+impl_decode!(i8);
+impl_decode!(i16);
+impl_decode!(i32);
+impl_decode!(i64);
+impl_decode!(i128);
+impl_decode!(isize);
+
+impl Decode for f64 {
+    fn decode(reader: &mut dyn Read) -> crate::codec::error::Result<Self>
+    where
+        Self: Sized,
+    {
+        let bits = u64::decode(reader)?;
+        let value = f64::from_bits(bits);
+        Ok(value)
+    }
+}
+
+impl Decode for f32 {
+    fn decode(reader: &mut dyn Read) -> crate::codec::error::Result<Self>
+    where
+        Self: Sized,
+    {
+        let bits = u32::decode(reader)?;
+        let value = f32::from_bits(bits);
+        Ok(value)
+    }
+}
diff --git a/src/codec/encode.rs b/src/codec/encode.rs
index f23913b..a40f551 100644
--- a/src/codec/encode.rs
+++ b/src/codec/encode.rs
@@ -1,6 +1,55 @@
-use std::io::{self, Write};
+use crate::codec::error::Error;
+use std::{io::Write, sync::Arc};
+
+macro_rules! impl_encode {
+    ($t: ty) => {
+        impl Encode for $t {
+            fn encode(self, buffer: &mut dyn Write) -> Result<usize, Error> {
+                let size = buffer.write(&self.to_be_bytes())?;
+                Ok(size)
+            }
+        }
+    };
+}
 
 pub trait Encode {
-    fn encode(&self, write: &mut dyn Write) -> io::Result<usize>;
-    fn encoded_size(&self) -> Option<usize>;
+    fn encode(self, buffer: &mut dyn Write) -> Result<usize, Error>;
+}
+
+impl Encode for bool {
+    fn encode(self, buffer: &mut dyn Write) -> Result<usize, Error> {
+        let size = buffer.write(&[self as u8])?;
+        Ok(size)
+    }
+}
+
+impl Encode for Arc<[u8]> {
+    fn encode(self, buffer: &mut dyn Write) -> Result<usize, Error> {
+        let len = buffer.write(&self)?;
+        Ok(len)
+    }
 }
+
+impl<const S: usize> Encode for [u8; S] {
+    fn encode(self, buffer: &mut dyn Write) -> Result<usize, Error> {
+        let len = buffer.write(&self)?;
+        Ok(len)
+    }
+}
+
+impl_encode!(u8);
+impl_encode!(u16);
+impl_encode!(u32);
+impl_encode!(u64);
+impl_encode!(u128);
+impl_encode!(usize);
+
+impl_encode!(i8);
+impl_encode!(i16);
+impl_encode!(i32);
+impl_encode!(i64);
+impl_encode!(i128);
+impl_encode!(isize);
+
+impl_encode!(f32);
+impl_encode!(f64);
diff --git a/src/codec/error.rs b/src/codec/error.rs
new file mode 100644
index 0000000..6639c98
--- /dev/null
+++ b/src/codec/error.rs
@@ -0,0 +1,22 @@
+use std::fmt::Display;
+
+#[derive(Debug)]
+pub enum Error {
+    IoError(std::io::Error),
+}
+
+impl std::error::Error for Error {}
+
+impl Display for Error {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{self:?}")
+    }
+}
+
+pub type Result<T> = core::result::Result<T, Error>;
+
+impl From<std::io::Error> for Error {
+    fn from(value: std::io::Error) -> Self {
+        Self::IoError(value)
+    }
+}