From bb41e396aca01fee9f81785681fac0a79d0fd9d8 Mon Sep 17 00:00:00 2001
From: zirkonya <zirkonya@iridium.lan>
Date: Thu, 27 Aug 2026 09:45:12 +0200
Subject: split event and enhance context

---
 src/codec/encode.rs | 33 +++++++++++++++++----------------
 1 file changed, 17 insertions(+), 16 deletions(-)

(limited to 'src/codec/encode.rs')

diff --git a/src/codec/encode.rs b/src/codec/encode.rs
index c8d1c7b..b9ac961 100644
--- a/src/codec/encode.rs
+++ b/src/codec/encode.rs
@@ -1,12 +1,13 @@
 //! Encoding: writing protocol values into a byte stream.
 use crate::codec::error::Error;
+use crate::context::Context;
 use std::{io::Write, sync::Arc};
 
 macro_rules! impl_encode {
     ($t: ty) => {
-        impl<Ctx> Encode<Ctx> for $t {
+        impl<Data> Encode<Data> for $t {
             /// write number using big endian
-            fn encode(&self, buffer: &mut dyn Write, _: &mut Ctx) -> Result<usize, Error> {
+            fn encode(&self, buffer: &mut dyn Write, _: &Context<Data>) -> Result<usize, Error> {
                 let size = buffer.write(&self.to_be_bytes())?;
                 Ok(size)
             }
@@ -15,20 +16,20 @@ macro_rules! impl_encode {
 }
 
 /// Write a value into a byte stream
-pub trait Encode<Ctx> {
-    fn encode(&self, buffer: &mut dyn Write, ctx: &mut Ctx) -> Result<usize, Error>;
+pub trait Encode<Data> {
+    fn encode(&self, buffer: &mut dyn Write, ctx: &Context<Data>) -> Result<usize, Error>;
 }
 
-impl<Ctx> Encode<Ctx> for bool {
-    fn encode(&self, buffer: &mut dyn Write, _: &mut Ctx) -> Result<usize, Error> {
+impl<Data> Encode<Data> for bool {
+    fn encode(&self, buffer: &mut dyn Write, _: &Context<Data>) -> Result<usize, Error> {
         let size = buffer.write(&[*self as u8])?;
         Ok(size)
     }
 }
 
-impl<Ctx, T: Encode<Ctx>> Encode<Ctx> for Option<T> {
+impl<Data, T: Encode<Data>> Encode<Data> for Option<T> {
     /// Encode `T` if Some(T) or do nothing if None
-    fn encode(&self, buffer: &mut dyn Write, ctx: &mut Ctx) -> Result<usize, Error> {
+    fn encode(&self, buffer: &mut dyn Write, ctx: &Context<Data>) -> Result<usize, Error> {
         match self {
             Some(val) => {
                 let size = val.encode(buffer, ctx)?;
@@ -39,11 +40,11 @@ impl<Ctx, T: Encode<Ctx>> Encode<Ctx> for Option<T> {
     }
 }
 
-impl<Ctx, T: Encode<Ctx>> Encode<Ctx> for Vec<T> {
+impl<Data, T: Encode<Data>> Encode<Data> for Vec<T> {
     /// Encode each element of vector
     /// use `CountPrefix` to prefix the vector with number of elements
     /// use `LenPrefix` to prefix the vector with encoded byte size
-    fn encode(&self, buffer: &mut dyn Write, ctx: &mut Ctx) -> Result<usize, Error> {
+    fn encode(&self, buffer: &mut dyn Write, ctx: &Context<Data>) -> Result<usize, Error> {
         let mut size = 0;
         for item in self {
             size += item.encode(buffer, ctx)?;
@@ -52,30 +53,30 @@ impl<Ctx, T: Encode<Ctx>> Encode<Ctx> for Vec<T> {
     }
 }
 
-impl<Ctx> Encode<Ctx> for String {
+impl<Data> Encode<Data> for String {
     /// Encode the string using utf8
     /// use `CountPrefix` to prefix the string with char length
     /// use `LenPrefix` to prefix the string with utf8 bytes length
-    fn encode(&self, buffer: &mut dyn Write, _: &mut Ctx) -> Result<usize, Error> {
+    fn encode(&self, buffer: &mut dyn Write, _: &Context<Data>) -> Result<usize, Error> {
         let utf8 = self.as_bytes();
         buffer.write_all(utf8)?;
         Ok(utf8.len())
     }
 }
 
-impl<Ctx> Encode<Ctx> for Arc<[u8]> {
+impl<Data> Encode<Data> for Arc<[u8]> {
     /// write raw slice into the buffer
     /// use `LenPrefix` to prefix with byte length
-    fn encode(&self, buffer: &mut dyn Write, _: &mut Ctx) -> Result<usize, Error> {
+    fn encode(&self, buffer: &mut dyn Write, _: &Context<Data>) -> Result<usize, Error> {
         let len = buffer.write(self)?;
         Ok(len)
     }
 }
 
-impl<Ctx, const S: usize> Encode<Ctx> for [u8; S] {
+impl<Data, const S: usize> Encode<Data> for [u8; S] {
     /// write raw slice into the buffer
     /// use `LenPrefix` to prefix with byte length
-    fn encode(&self, buffer: &mut dyn Write, _ctx: &mut Ctx) -> Result<usize, Error> {
+    fn encode(&self, buffer: &mut dyn Write, _: &Context<Data>) -> Result<usize, Error> {
         let len = buffer.write(self)?;
         Ok(len)
     }
-- 
cgit v1.2.3