drew-connect 0.1.0

Couche d'I/O et de décodage de télémétrie agnostique et modulaire : transports (série, UDP) et décodeurs (JSON, binaire) interchangeables via traits.
Documentation
// Copyright (C) 2026 Jorge Andre Castro
// GPL-2.0-or-later

//! Thread de fond reliant un [`Transport`] à un [`Decoder`] via un canal
//! non bloquant.

use crate::decoder::Decoder;
use crate::transport::Transport;
use crossbeam_channel::Receiver;
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::Arc;
use std::thread;

/// Taille par défaut du tampon de lecture, en octets.
const DEFAULT_BUFFER_SIZE: usize = 1024;
/// Capacité par défaut du canal de paquets décodés.
const DEFAULT_CHANNEL_CAPACITY: usize = 100;

/// Lance un thread d'écoute en arrière-plan et expose les paquets décodés
/// via un canal non bloquant.
///
/// Générique sur `P`, le type de paquet produit par le [`Decoder`] utilisé
/// à la construction — `ConnectionWorker` ne connaît donc rien de
/// spécifique à la télémétrie et fonctionne avec n'importe quelle
/// combinaison [`Transport`]/[`Decoder`], y compris des implémentations
/// définies en dehors de ce crate.
pub struct ConnectionWorker<P: Send + 'static> {
    receiver: Receiver<P>,
    running: Arc<AtomicBool>,
}

impl<P: Send + 'static> ConnectionWorker<P> {
    /// Démarre le thread avec le transport et le décodeur choisis, en
    /// utilisant un tampon de lecture de 1024 octets et un canal de
    /// capacité 100. Utilisez [`Self::spawn_with_capacity`] pour
    /// personnaliser ces valeurs.
    pub fn spawn<T, D>(transport: T, decoder: D) -> Self
    where
        T: Transport + 'static,
        D: Decoder<Output = P> + 'static,
    {
        Self::spawn_with_capacity(
            transport,
            decoder,
            DEFAULT_BUFFER_SIZE,
            DEFAULT_CHANNEL_CAPACITY,
        )
    }

    /// Comme [`Self::spawn`], avec une taille de tampon de lecture et une
    /// capacité de canal personnalisées (utile pour des trames plus
    /// grandes, ou pour limiter la mémoire sur cible contrainte).
    pub fn spawn_with_capacity<T, D>(
        mut transport: T,
        mut decoder: D,
        buffer_size: usize,
        channel_capacity: usize,
    ) -> Self
    where
        T: Transport + 'static,
        D: Decoder<Output = P> + 'static,
    {
        let (sender, receiver) = crossbeam_channel::bounded(channel_capacity);
        let running = Arc::new(AtomicBool::new(true));
        let running_clone = Arc::clone(&running);

        thread::spawn(move || {
            let mut buffer = vec![0u8; buffer_size];

            while running_clone.load(Ordering::Relaxed) {
                match transport.read(&mut buffer) {
                    Ok(bytes_read) if bytes_read > 0 => {
                        if let Some(packet) = decoder.decode(&buffer[..bytes_read]) {
                            // Envoie le paquet sans bloquer si le canal est plein
                            // (le paquet le plus récent prime sur l'ancien).
                            let _ = sender.try_send(packet);
                        }
                    }
                    _ => {
                        thread::sleep(std::time::Duration::from_millis(5));
                    }
                }
            }
        });

        Self { receiver, running }
    }

    /// Récupère un paquet reçu (non bloquant).
    pub fn try_recv(&self) -> Option<P> {
        self.receiver.try_recv().ok()
    }

    /// Vide le canal et retourne uniquement le paquet le plus récent — utile
    /// pour une boucle de rendu qui ne veut pas accumuler de retard.
    pub fn drain_latest(&self) -> Option<P> {
        let mut latest = None;
        while let Ok(pkt) = self.receiver.try_recv() {
            latest = Some(pkt);
        }
        latest
    }
}

impl<P: Send + 'static> Drop for ConnectionWorker<P> {
    fn drop(&mut self) {
        self.running.store(false, Ordering::Relaxed);
    }
}