fn compact()

in Rust/src/pointstore.rs [323:393]

• 66 lines of code
• 14 McCabe index (conditional complexity)

    fn compact(&mut self) {
        let base = self.dimensions / self.shingle_size;
        let mut reverse_reference: Vec<(usize, usize)> = Vec::new();
        for i in 0..self.location.len() {
            if self.location[i] != L::MAX {
                reverse_reference.push((self.location[i].try_into().unwrap(), i));
            }
        }
        reverse_reference.sort();
        let mut fresh_start: usize = 0;
        let mut j_static: usize = 0;
        let mut j_dynamic: usize = 0;
        let end: usize = reverse_reference.len();
        while j_static < end {
            let mut block_start: usize = reverse_reference[j_static].0;
            block_start = block_start * base;
            let mut block_end: usize = block_start + self.dimensions;
            let initial = if self.internal_rotation {
                (self.dimensions - fresh_start + block_start) % self.dimensions
            } else {
                0
            };

            let mut k = j_static + 1;
            j_dynamic = j_static + 1;
            while k < end {
                let new_locn: usize = reverse_reference[k].0;
                let new_elem: usize = base * new_locn;
                if block_end >= new_elem {
                    k += 1;
                    j_dynamic += 1;
                    if block_end < new_elem + self.dimensions {
                        block_end = new_elem + self.dimensions;
                    }
                } else {
                    k = end;
                }
            }

            // aligning the boundaries
            for _i in 0..initial {
                self.store[fresh_start] = 0.0;
                fresh_start += 1;
            }

            for i in block_start..block_end {
                self.store[fresh_start] = self.store[i];
                assert!(
                    !self.internal_rotation || fresh_start % self.dimensions == i % self.dimensions
                );
                if j_static < end {
                    let locn: usize = reverse_reference[j_static].0;
                    if i == base * locn {
                        let new_idx: usize = reverse_reference[j_static].1;
                        self.location[new_idx] = (fresh_start / base).try_into().unwrap();
                        j_static += 1;
                    }
                }
                fresh_start += 1;
            }

            if j_static != j_dynamic {
                println!(
                    "There is discrepancy in indices between '{}' versus '{}'",
                    j_static, j_dynamic
                );
                panic!();
            }
        }
        self.start_free_region = fresh_start.try_into().unwrap();
    }