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);
}
}