Method compute

atomic-remote/src/streaming/negotiation.rs:95–120

Compute the negotiation result from a manifest and a "have" list. The "have" list is a set of chunk hashes that the receiver already possesses. Any chunk in the manifest whose hash matches a "have" entry is skipped — only the remaining chunks need to be transferred. # Arguments `manifest` - The full chunk manifest of the change. `have_hashes` - Chunk hashes the receiver already has. # Returns

(manifest: &ChunkManifest, have_hashes: &[[u8; 32]])

    ///
    /// A `ChunkNegotiation` describing what still needs to be transferred.
    pub fn compute(manifest: &ChunkManifest, have_hashes: &[[u8; 32]]) -> Self {
        let have_set: HashSet<[u8; 32]> = have_hashes.iter().copied().collect();

        let mut needed = Vec::new();
        let mut already_have = 0usize;
        let mut bytes_saved = 0u64;
        let mut bytes_needed = 0u64;

        for entry in &manifest.entries {
            if have_set.contains(&entry.hash) {
                already_have += 1;
                bytes_saved += entry.compressed_size as u64;
            } else {
                bytes_needed += entry.compressed_size as u64;
                needed.push(*entry);
            }
        }

        Self {
            needed,
            already_have,
            bytes_saved,
            bytes_needed,
            total_chunks: manifest.chunk_count(),
        }
    }

    /// Returns `true` if all chunks are already present (nothing to transfer).
    pub fn is_complete(&self) -> bool {