refactor!: delete the i-cell collection structures

Cargo.toml

@@ -36,6 +36,7 @@ honeycomb-render = { version = "0.6.0", path = "./honeycomb-render" }
 
 # common
 cfg-if = "1"
+itertools = "0.13.0"
 rayon = "1.10.0"
 rustversion = "1.0.18"
 thiserror = "2.0.3"

benches/benches/core/cmap2/constructors.rs

@@ -67,32 +67,32 @@ library_benchmark_group!(
 #[bench::small(&mut get_map(16))]
 #[bench::medium(&mut get_map(64))]
 #[bench::large(&mut get_map(256))]
-fn fetch_vertices(map: &mut CMap2<FloatType>) {
-    black_box(map.fetch_vertices());
+fn iter_vertices(map: &mut CMap2<FloatType>) {
+    black_box(map.iter_vertices().collect::<Vec<_>>());
 }
 
 #[library_benchmark]
 #[bench::small(&mut get_map(16))]
 #[bench::medium(&mut get_map(64))]
 #[bench::large(&mut get_map(256))]
-fn fetch_edges(map: &mut CMap2<FloatType>) {
-    black_box(map.fetch_edges());
+fn iter_edges(map: &mut CMap2<FloatType>) {
+    black_box(map.iter_edges().collect::<Vec<_>>());
 }
 
 #[library_benchmark]
 #[bench::small(&mut get_map(16))]
 #[bench::medium(&mut get_map(64))]
 #[bench::large(&mut get_map(256))]
-fn fetch_faces(map: &mut CMap2<FloatType>) {
-    black_box(map.fetch_faces());
+fn iter_faces(map: &mut CMap2<FloatType>) {
+    black_box(map.iter_faces().collect::<Vec<_>>());
 }
 
 library_benchmark_group!(
     name = bench_fetches;
     benchmarks =
-        fetch_vertices,
-        fetch_edges,
-        fetch_faces,
+        iter_vertices,
+        iter_edges,
+        iter_faces,
 );
 
 // --- i-cell group

benches/benches/core/cmap2/fetch_icells.rs

@@ -15,19 +15,19 @@ pub fn criterion_benchmark(c: &mut Criterion) {
 
     group.bench_with_input(BenchmarkId::new("fetch-vertices", ""), &map, |b, m| {
         b.iter(|| {
-            let mut vertices = m.fetch_vertices();
+            let mut vertices: Vec<_> = m.iter_vertices().collect();
             black_box(&mut vertices);
         })
     });
     group.bench_with_input(BenchmarkId::new("fetch-edges", ""), &map, |b, m| {
         b.iter(|| {
-            let mut edges = m.fetch_edges();
+            let mut edges: Vec<_> = m.iter_edges().collect();
             black_box(&mut edges);
         })
     });
     group.bench_with_input(BenchmarkId::new("fetch-faces", ""), &map, |b, m| {
         b.iter(|| {
-            let mut faces = m.fetch_faces();
+            let mut faces: Vec<_> = m.iter_faces().collect();
             black_box(&mut faces);
         })
     });

benches/benches/triangulate/quads.rs

@@ -15,7 +15,7 @@ fn fan_bench() -> Result<(), TriangulateError> {
     let mut map: CMap2<FloatType> = CMapBuilder::default().vtk_file(PATH).build().unwrap();
 
     // prealloc darts
-    let faces = map.fetch_faces().identifiers.clone();
+    let faces: Vec<_> = map.iter_faces().collect();
     let n_darts_per_face: Vec<_> = faces
         .iter()
         .map(|id| (Orbit2::new(&map, OrbitPolicy::Face, *id as DartIdType).count() - 3) * 2)
@@ -49,7 +49,7 @@ fn earclip_bench() -> Result<(), TriangulateError> {
     let mut map: CMap2<FloatType> = CMapBuilder::default().vtk_file(PATH).build().unwrap();
 
     // prealloc darts
-    let faces = map.fetch_faces().identifiers.clone();
+    let faces: Vec<_> = map.iter_faces().collect();
     let n_darts_per_face: Vec<_> = faces
         .iter()
         .map(|id| (Orbit2::new(&map, OrbitPolicy::Face, *id as DartIdType).count() - 3) * 2)

benches/src/shift.rs

@@ -50,9 +50,7 @@ fn main() {
 
     // fetch all vertices that are not on the boundary of the map
     let tmp: Vec<(VertexIdType, Vec<VertexIdType>)> = map
-        .fetch_vertices()
-        .identifiers
-        .into_iter()
+        .iter_vertices()
         .filter_map(|v| {
             if Orbit2::new(&map, OrbitPolicy::Vertex, v as DartIdType)
                 .any(|d| map.beta::<2>(d) == NULL_DART_ID)

benches/src/shift_no_conflict.rs

@@ -53,24 +53,20 @@ fn main() {
     let map: CMap2<f64> = CMapBuilder::unit_grid(n_squares).build().unwrap();
 
     // fetch all vertices that are not on the boundary of the map
-    let tmp = map
-        .fetch_vertices()
-        .identifiers
-        .into_iter()
-        .filter_map(|v| {
-            if Orbit2::new(&map, OrbitPolicy::Vertex, v as DartIdType)
-                .any(|d| map.beta::<2>(d) == NULL_DART_ID)
-            {
-                None
-            } else {
-                Some((
-                    v,
-                    Orbit2::new(&map, OrbitPolicy::Vertex, v as DartIdType)
-                        .map(|d| map.vertex_id(map.beta::<2>(d)))
-                        .collect(),
-                ))
-            }
-        });
+    let tmp = map.iter_vertices().filter_map(|v| {
+        if Orbit2::new(&map, OrbitPolicy::Vertex, v as DartIdType)
+            .any(|d| map.beta::<2>(d) == NULL_DART_ID)
+        {
+            None
+        } else {
+            Some((
+                v,
+                Orbit2::new(&map, OrbitPolicy::Vertex, v as DartIdType)
+                    .map(|d| map.vertex_id(map.beta::<2>(d)))
+                    .collect(),
+            ))
+        }
+    });
 
     #[allow(clippy::type_complexity)]
     let (first_batch, second_batch): (

examples/examples/io/write.rs

@@ -26,8 +26,8 @@ fn main() {
 
     println!("I: Start quad split process...");
     let now = Instant::now();
-    map.fetch_faces()
-        .identifiers
+    let faces: Vec<_> = map.iter_faces().collect();
+    faces
         .iter()
         .filter(|square| splits[**square as usize % n_split])
         .for_each(|square| {

examples/examples/parallel_shift.rs

@@ -47,9 +47,7 @@ fn main() {
 
     // fetch all vertices that are not on the boundary of the map
     let nodes: Vec<(VertexIdType, Vec<VertexIdType>)> = map
-        .fetch_vertices()
-        .identifiers
-        .into_iter()
+        .iter_vertices()
         .filter_map(|v| {
             // the condition detects if we're on the boundary
             if Orbit2::new(&map, OrbitPolicy::Vertex, v as DartIdType)

honeycomb-core/Cargo.toml

@@ -20,6 +20,7 @@ utils = []
 
 [dependencies]
 downcast-rs.workspace = true
+itertools.workspace = true
 loom.workspace= true
 num-traits.workspace = true
 stm.workspace = true

honeycomb-core/src/cmap/builder/grid/building_routines.rs

@@ -95,7 +95,7 @@ pub fn build_2d_grid<T: CoordsFloat>(
     // check the number of built faces
     // this is set as debug only because the operation cost scales with map size
     // this can quickly overshadow the exectime of all previous code
-    debug_assert_eq!(map.fetch_faces().identifiers.len(), n_square_x * n_square_y);
+    debug_assert_eq!(map.iter_faces().count(), n_square_x * n_square_y);
 
     map
 }
@@ -202,10 +202,7 @@ pub fn build_2d_splitgrid<T: CoordsFloat>(
     // check the number of built faces
     // this is set as debug only because the operation cost scales with map size
     // this can quickly overshadow the exectime of all previous code
-    debug_assert_eq!(
-        map.fetch_faces().identifiers.len(),
-        2 * n_square_x * n_square_y
-    );
+    debug_assert_eq!(map.iter_faces().count(), 2 * n_square_x * n_square_y);
 
     map
 }

honeycomb-core/src/cmap/builder/io/tests.rs

@@ -13,13 +13,12 @@ fn io_read() {
     let cmap: CMap2<f32> = super::build_2d_from_vtk(vtk, AttrStorageManager::default()).unwrap();
 
     // check result
-    let faces = cmap.fetch_faces();
-    assert_eq!(faces.identifiers.len(), 4);
-    assert_eq!(cmap.fetch_edges().identifiers.len(), 12);
-    assert_eq!(cmap.fetch_vertices().identifiers.len(), 9);
+    let faces: Vec<_> = cmap.iter_faces().collect();
+    assert_eq!(faces.len(), 4);
+    assert_eq!(cmap.iter_edges().count(), 12);
+    assert_eq!(cmap.iter_vertices().count(), 9);
 
     let mut n_vertices_per_face: Vec<usize> = faces
-        .identifiers
         .iter()
         .map(|id| Orbit2::new(&cmap, OrbitPolicy::Face, *id as DartIdType).count())
         .collect();

honeycomb-core/src/cmap/components/mod.rs

@@ -1,7 +1,6 @@
 //! Common components of the `CMap2` implementation
 
 pub mod betas;
-pub mod collections;
 pub mod identifiers;
 pub mod orbits;
 pub mod unused;