fn register_dependencies()

in progress_tracking/src/upload_tracking.rs [132:204]
51 lines of code
4 McCabe index (conditional complexity)

    fn register_dependencies(&mut self, dependencies: &[FileXorbDependency]) -> ProgressUpdate {
        let mut item_updates = Vec::new();

        let mut file_bytes_processed = 0;

        for dep in dependencies {
            let file_entry = &mut self.files[dep.file_id as usize];

            if dep.is_external {
                // This is the freebie case, where we can just increment the progress.
                file_entry.completed_bytes += dep.n_bytes;
                debug_assert_le!(file_entry.completed_bytes, file_entry.total_bytes);

                let progress_update = ItemProgressUpdate {
                    item_name: file_entry.name.clone(),
                    total_bytes: file_entry.total_bytes,
                    bytes_completed: file_entry.completed_bytes,
                    bytes_completion_increment: dep.n_bytes,
                };

                file_bytes_processed += dep.n_bytes;

                item_updates.push(progress_update);
            } else {
                // Make sure we aren't putting in an unfinished xorb, which
                // tracks with MerkleHash::marker().
                debug_assert_ne!(dep.xorb_hash, MerkleHash::marker());

                let entry = self.xorbs.entry(dep.xorb_hash).or_default();

                // If the entry has already been completed, then just mark this as completed.
                if entry.is_completed {
                    file_entry.completed_bytes += dep.n_bytes;
                    debug_assert_le!(file_entry.completed_bytes, file_entry.total_bytes);

                    let progress_update = ItemProgressUpdate {
                        item_name: file_entry.name.clone(),
                        total_bytes: file_entry.total_bytes,
                        bytes_completed: file_entry.completed_bytes,
                        bytes_completion_increment: dep.n_bytes,
                    };
                    item_updates.push(progress_update);
                    file_bytes_processed += dep.n_bytes;
                } else {
                    // Set the reference here to this file
                    entry.file_indices.insert(dep.file_id as usize);

                    // Set the reference here to the xorb
                    file_entry.remaining_xorbs_parts.entry(dep.xorb_hash).or_default().n_bytes += dep.n_bytes;
                }
            }
        }

        // Register that this much has been completed already
        self.total_bytes_completed += file_bytes_processed;

        debug_assert_le!(self.total_bytes_completed, self.total_bytes);

        // There may be a lot of per-file updates, but these don't actually count against the new byte total;
        // this is counted only using xorbs.
        ProgressUpdate {
            item_updates,
            total_bytes: self.total_bytes,
            total_bytes_increment: 0,
            total_bytes_completed: self.total_bytes_completed,
            total_bytes_completion_increment: file_bytes_processed,
            total_transfer_bytes: self.total_upload_bytes,
            total_transfer_bytes_increment: 0,
            total_transfer_bytes_completed: self.total_upload_bytes_completed,
            total_transfer_bytes_completion_increment: 0,
            ..Default::default()
        }
    }