From be62f065a62048b798e8bb2b8e3699bdd5b6d517 Mon Sep 17 00:00:00 2001
From: zirkonya <zirkonya@iridium.lan>
Date: Tue, 1 Sep 2026 09:51:18 +0200
Subject: add proc macros ; benchmark ; example

---
 src/transport/tcp.rs | 32 +++++++++++++++++---------------
 1 file changed, 17 insertions(+), 15 deletions(-)

(limited to 'src/transport/tcp.rs')

diff --git a/src/transport/tcp.rs b/src/transport/tcp.rs
index 19d02d6..12ecaa0 100644
--- a/src/transport/tcp.rs
+++ b/src/transport/tcp.rs
@@ -1,35 +1,30 @@
 use std::hash::Hash;
-use std::io::Write;
+use std::io::{Read, Write};
 use std::marker::PhantomData;
 use std::net::{SocketAddr, TcpListener as StdTcpListener, TcpStream};
 use std::sync::atomic::{AtomicU64, Ordering};
 use std::sync::{Arc, Mutex};
 
-use crate::codec::Codec;
 use crate::context::Context;
 use crate::transport::connection::Connection;
 use crate::transport::error::TransportError;
 use crate::transport::listener::Listener;
-use crate::transport::receiver::PacketReceiver;
-use crate::transport::sender::PacketSender;
+use crate::transport::receiver::PacketReceiverBuf;
+use crate::transport::sender::PacketSenderBuf;
 use crate::transport::{Result, Transport};
 
-// TODO : check Tcp Transport
-
 #[derive(Clone)]
 pub struct TcpSender {
     stream: Arc<Mutex<TcpStream>>,
 }
 
-impl<Data> PacketSender<Data> for TcpSender {
-    fn send<P: Codec<Data>>(&self, packet: P, ctx: &Context<Data>) -> Result<()> {
-        let mut buf = Vec::new();
-        packet.encode(&mut buf, ctx)?;
+impl<Data> PacketSenderBuf<Data> for TcpSender {
+    fn send_buf(&self, buf: &[u8]) -> Result<()> {
         let mut guard = self
             .stream
             .lock()
             .map_err(|_| TransportError::LockPoisoned)?;
-        guard.write_all(&buf)?;
+        guard.write_all(buf)?;
         guard.flush()?;
         Ok(())
     }
@@ -40,17 +35,24 @@ pub struct TcpReceiver<Uid> {
     uid: Uid,
 }
 
-impl<Data, Uid> PacketReceiver<Data, Uid> for TcpReceiver<Uid>
+impl<Data, Uid> PacketReceiverBuf<Data, Uid> for TcpReceiver<Uid>
 where
     Uid: PartialEq + Clone + Send + Sync,
 {
-    fn recv<P: Codec<Data>>(&self, ctx: &Context<Data>) -> Result<(Uid, P)> {
+    fn recv_buf(&self, _ctx: &Context<Data>) -> Result<(Uid, Vec<u8>)> {
         let mut guard = self
             .stream
             .lock()
             .map_err(|_| TransportError::LockPoisoned)?;
-        let packet = P::decode(&mut *guard, ctx)?;
-        Ok((self.uid.clone(), packet))
+
+        // Read 4-byte big-endian length prefix
+        let mut len_buf = [0u8; 4];
+        guard.read_exact(&mut len_buf)?;
+        let len = u32::from_be_bytes(len_buf) as usize;
+
+        let mut buf = vec![0u8; len];
+        guard.read_exact(&mut buf)?;
+        Ok((self.uid.clone(), buf))
     }
 }
 
-- 
cgit v1.2.3