92 lines
2.8 KiB
Rust
92 lines
2.8 KiB
Rust
use std::fmt;
|
|
|
|
// Error type
|
|
struct SparseSetError;
|
|
|
|
#[derive(Debug, Copy, Clone)]
|
|
struct DenseItem<T> {
|
|
index: usize,
|
|
value: T
|
|
}
|
|
|
|
// TODO: Use arrays+slices instead of vecs
|
|
#[derive(Debug)]
|
|
struct SparseSet<T> {
|
|
sparse: Vec<Option<usize>>,
|
|
dense: Vec<DenseItem<T>>
|
|
}
|
|
|
|
impl<T> SparseSet<T> {
|
|
pub fn new() -> SparseSet<T> {
|
|
SparseSet {
|
|
sparse: vec![],
|
|
dense: vec![]
|
|
}
|
|
}
|
|
|
|
// Add an item to the dense vector and record its index in the sparse vector
|
|
fn insert(&mut self, value: T) {
|
|
let item = DenseItem {
|
|
index: self.dense.len(),
|
|
value: value
|
|
};
|
|
self.dense.push(item);
|
|
let dense_index = self.dense.len() - 1;
|
|
self.sparse.push(Some(dense_index));
|
|
}
|
|
|
|
// Remove an item at the supplied target index from the set
|
|
// Replaces the selected target with the last item in the dense vector
|
|
fn remove(&mut self, target_sparse_index: usize) -> Result<(), SparseSetError> {
|
|
// Find the dense index of the target (need to decide what to do from there)
|
|
let target_dense_index = self.sparse[target_sparse_index].unwrap();
|
|
|
|
// If the target points to the last item in the dense set, this'll be easier
|
|
if target_dense_index + 1 == self.dense.len() {
|
|
// Remove the target from the dense set
|
|
self.dense.pop();
|
|
|
|
// Overwrite the target's sparse index
|
|
self.sparse[target_sparse_index] = None;
|
|
} else {
|
|
// Get the last item in the dense set as a source to switch with
|
|
// Change its index to the target sparse index, as it's replacing the target
|
|
let source_item = match self.dense.pop() {
|
|
Some(item) => { item },
|
|
None => { return Err(SparseSetError) }
|
|
};
|
|
|
|
// Redirect the source item's sparse index to replace the target sparse index
|
|
self.sparse[source_item.index] = Some(target_sparse_index);
|
|
|
|
// Assign the source item to the target's place in the dense set
|
|
self.dense[target_dense_index] = source_item;
|
|
|
|
// Overwrite the target's sparse index
|
|
self.sparse[target_dense_index] = None;
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
fn main() {
|
|
let mut test_set: SparseSet<f32> = SparseSet::new();
|
|
test_set.insert(69.0);
|
|
test_set.insert(420.0);
|
|
test_set.insert(9001.0);
|
|
println!("{:?}", test_set);
|
|
test_set.remove(1);
|
|
println!("{:?}", test_set);
|
|
|
|
// Create a mutable array (contiguous memory!)
|
|
let mut array: [Option<DenseItem<f32>>; 8] = [None; 8];
|
|
|
|
// Create a mutable slice of that whole array
|
|
let slice: &[Option<DenseItem<f32>>] = &mut array[..];
|
|
|
|
for item in slice {
|
|
println!("{:?}", item);
|
|
}
|
|
}
|