torrentdht 0.1.1

DHT discovery with mTLS handshake handoff; optional BitTorrent when the host opts in
Documentation
use std::collections::HashSet;

#[derive(Debug)]
pub struct PieceAssembly {
    piece_size: u32,
    block_size: u32,
    received: HashSet<u32>,
}

impl PieceAssembly {
    pub fn new(piece_size: u32, block_size: u32) -> Self {
        Self {
            piece_size,
            block_size: block_size.max(1),
            received: HashSet::new(),
        }
    }

    pub fn block_count(&self) -> u32 {
        self.piece_size.div_ceil(self.block_size)
    }

    pub fn mark_block(&mut self, begin: u32) -> bool {
        if begin < self.piece_size && begin.is_multiple_of(self.block_size) {
            self.received.insert(begin)
        } else {
            false
        }
    }

    pub fn is_complete(&self) -> bool {
        let count = self.block_count();
        if count == 0 {
            return true;
        }
        if self.received.len() as u32 != count {
            return false;
        }
        for index in 0..count {
            let begin = index.saturating_mul(self.block_size);
            if begin >= self.piece_size {
                break;
            }
            if !self.received.contains(&begin) {
                return false;
            }
        }
        true
    }

    pub fn next_block(&self) -> Option<u32> {
        let count = self.block_count();
        for index in 0..count {
            let begin = index * self.block_size;
            if begin >= self.piece_size {
                break;
            }
            if !self.received.contains(&begin) {
                return Some(begin);
            }
        }
        None
    }

    pub fn block_length(&self, begin: u32) -> u32 {
        self.block_size
            .min(self.piece_size.saturating_sub(begin))
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn complete_requires_aligned_coverage() {
        let mut a = PieceAssembly::new(48, 16);
        a.mark_block(0);
        a.mark_block(16);
        assert!(!a.is_complete());
        a.mark_block(32);
        assert!(a.is_complete());
    }

    #[test]
    fn rejects_misaligned_begins_for_completion() {
        let mut a = PieceAssembly::new(32, 16);
        a.mark_block(1);
        a.mark_block(2);
        a.mark_block(3);
        assert!(!a.is_complete());
        assert_eq!(a.received.len(), 0);
    }
}