Merge pull request #1198 from hannobraun/objects

Rename `Stores` to `Objects`, move it to `Objects`

crates/fj-kernel/src/algorithms/approx/curve.rs

@@ -14,7 +14,7 @@ use std::collections::BTreeMap;
 use crate::{
     objects::{Curve, GlobalCurve},
     path::{GlobalPath, SurfacePath},
-    stores::{Handle, ObjectId},
+    storage::{Handle, ObjectId},
 };
 
 use super::{path::RangeOnPath, Approx, ApproxPoint, Tolerance};
@@ -197,25 +197,25 @@ mod tests {
 
     use crate::{
         algorithms::approx::{path::RangeOnPath, Approx, ApproxPoint},
-        objects::{Curve, Surface},
+        objects::{Curve, Objects, Surface},
         partial::HasPartial,
         path::GlobalPath,
-        stores::{Handle, Stores},
+        storage::Handle,
     };
 
     use super::CurveApprox;
 
     #[test]
     fn approx_line_on_flat_surface() {
-        let stores = Stores::new();
+        let objects = Objects::new();
 
-        let surface = stores
+        let surface = objects
             .surfaces
             .insert(Surface::new(GlobalPath::x_axis(), [0., 0., 1.]));
         let curve = Handle::<Curve>::partial()
             .with_surface(Some(surface))
             .as_line_from_points([[1., 1.], [2., 1.]])
-            .build(&stores);
+            .build(&objects);
         let range = RangeOnPath::from([[0.], [1.]]);
 
         let approx = (&curve, range).approx(1.);
@@ -225,16 +225,16 @@ mod tests {
 
     #[test]
     fn approx_line_on_curved_surface_but_not_along_curve() {
-        let stores = Stores::new();
+        let objects = Objects::new();
 
-        let surface = stores.surfaces.insert(Surface::new(
+        let surface = objects.surfaces.insert(Surface::new(
             GlobalPath::circle_from_radius(1.),
             [0., 0., 1.],
         ));
         let curve = Handle::<Curve>::partial()
             .with_surface(Some(surface))
             .as_line_from_points([[1., 1.], [1., 2.]])
-            .build(&stores);
+            .build(&objects);
         let range = RangeOnPath::from([[0.], [1.]]);
 
         let approx = (&curve, range).approx(1.);
@@ -244,14 +244,14 @@ mod tests {
 
     #[test]
     fn approx_line_on_curved_surface_along_curve() {
-        let stores = Stores::new();
+        let objects = Objects::new();
 
         let path = GlobalPath::circle_from_radius(1.);
-        let surface = stores.surfaces.insert(Surface::new(path, [0., 0., 1.]));
+        let surface = objects.surfaces.insert(Surface::new(path, [0., 0., 1.]));
         let curve = Handle::<Curve>::partial()
             .with_surface(Some(surface.clone()))
             .as_line_from_points([[0., 1.], [1., 1.]])
-            .build(&stores);
+            .build(&objects);
 
         let range = RangeOnPath::from([[0.], [TAU]]);
         let tolerance = 1.;
@@ -274,15 +274,15 @@ mod tests {
 
     #[test]
     fn approx_circle_on_flat_surface() {
-        let stores = Stores::new();
+        let objects = Objects::new();
 
-        let surface = stores
+        let surface = objects
             .surfaces
             .insert(Surface::new(GlobalPath::x_axis(), [0., 0., 1.]));
         let curve = Handle::<Curve>::partial()
             .with_surface(Some(surface))
             .as_circle_from_radius(1.)
-            .build(&stores);
+            .build(&objects);
 
         let range = RangeOnPath::from([[0.], [TAU]]);
         let tolerance = 1.;

crates/fj-kernel/src/algorithms/approx/mod.rs

@@ -20,7 +20,7 @@ use std::{
 
 use fj_math::Point;
 
-use crate::{objects::Curve, stores::Handle};
+use crate::{objects::Curve, storage::Handle};
 
 pub use self::tolerance::{InvalidTolerance, Tolerance};
 

crates/fj-kernel/src/algorithms/intersect/curve_edge.rs

@@ -75,26 +75,26 @@ mod tests {
     use fj_math::Point;
 
     use crate::{
-        objects::{Curve, HalfEdge, Surface},
+        objects::{Curve, HalfEdge, Objects, Surface},
         partial::HasPartial,
-        stores::{Handle, Stores},
+        storage::Handle,
     };
 
     use super::CurveEdgeIntersection;
 
     #[test]
     fn compute_edge_in_front_of_curve_origin() {
-        let stores = Stores::new();
+        let objects = Objects::new();
 
-        let surface = stores.surfaces.insert(Surface::xy_plane());
+        let surface = objects.surfaces.insert(Surface::xy_plane());
         let curve = Handle::<Curve>::partial()
             .with_surface(Some(surface.clone()))
             .as_u_axis()
-            .build(&stores);
+            .build(&objects);
         let half_edge = HalfEdge::partial()
             .with_surface(Some(surface))
             .as_line_segment_from_points([[1., -1.], [1., 1.]])
-            .build(&stores);
+            .build(&objects);
 
         let intersection = CurveEdgeIntersection::compute(&curve, &half_edge);
 
@@ -108,17 +108,17 @@ mod tests {
 
     #[test]
     fn compute_edge_behind_curve_origin() {
-        let stores = Stores::new();
+        let objects = Objects::new();
 
-        let surface = stores.surfaces.insert(Surface::xy_plane());
+        let surface = objects.surfaces.insert(Surface::xy_plane());
         let curve = Handle::<Curve>::partial()
             .with_surface(Some(surface.clone()))
             .as_u_axis()
-            .build(&stores);
+            .build(&objects);
         let half_edge = HalfEdge::partial()
             .with_surface(Some(surface))
             .as_line_segment_from_points([[-1., -1.], [-1., 1.]])
-            .build(&stores);
+            .build(&objects);
 
         let intersection = CurveEdgeIntersection::compute(&curve, &half_edge);
 
@@ -132,17 +132,17 @@ mod tests {
 
     #[test]
     fn compute_edge_parallel_to_curve() {
-        let stores = Stores::new();
+        let objects = Objects::new();
 
-        let surface = stores.surfaces.insert(Surface::xy_plane());
+        let surface = objects.surfaces.insert(Surface::xy_plane());
         let curve = Handle::<Curve>::partial()
             .with_surface(Some(surface.clone()))
             .as_u_axis()
-            .build(&stores);
+            .build(&objects);
         let half_edge = HalfEdge::partial()
             .with_surface(Some(surface))
             .as_line_segment_from_points([[-1., -1.], [1., -1.]])
-            .build(&stores);
+            .build(&objects);
 
         let intersection = CurveEdgeIntersection::compute(&curve, &half_edge);
 
@@ -151,17 +151,17 @@ mod tests {
 
     #[test]
     fn compute_edge_on_curve() {
-        let stores = Stores::new();
+        let objects = Objects::new();
 
-        let surface = stores.surfaces.insert(Surface::xy_plane());
+        let surface = objects.surfaces.insert(Surface::xy_plane());
         let curve = Handle::<Curve>::partial()
             .with_surface(Some(surface.clone()))
             .as_u_axis()
-            .build(&stores);
+            .build(&objects);
         let half_edge = HalfEdge::partial()
             .with_surface(Some(surface))
             .as_line_segment_from_points([[-1., 0.], [1., 0.]])
-            .build(&stores);
+            .build(&objects);
 
         let intersection = CurveEdgeIntersection::compute(&curve, &half_edge);
 

crates/fj-kernel/src/algorithms/intersect/curve_face.rs

@@ -156,23 +156,23 @@ where
 #[cfg(test)]
 mod tests {
     use crate::{
-        objects::{Curve, Face, Surface},
+        objects::{Curve, Face, Objects, Surface},
         partial::HasPartial,
-        stores::{Handle, Stores},
+        storage::Handle,
     };
 
     use super::CurveFaceIntersection;
 
     #[test]
     fn compute() {
-        let stores = Stores::new();
+        let objects = Objects::new();
 
-        let surface = stores.surfaces.insert(Surface::xy_plane());
+        let surface = objects.surfaces.insert(Surface::xy_plane());
 
         let curve = Handle::<Curve>::partial()
             .with_surface(Some(surface.clone()))
             .as_line_from_points([[-3., 0.], [-2., 0.]])
-            .build(&stores);
+            .build(&objects);
 
         #[rustfmt::skip]
         let exterior = [
@@ -189,7 +189,7 @@ mod tests {
             [ 1., -1.],
         ];
 
-        let face = Face::builder(&stores, surface)
+        let face = Face::builder(&objects, surface)
             .with_exterior_polygon_from_points(exterior)
             .with_interior_polygon_from_points(interior)
             .build();

crates/fj-kernel/src/algorithms/intersect/face_face.rs

@@ -1,6 +1,6 @@
 use crate::{
-    objects::{Curve, Face},
-    stores::{Handle, Stores},
+    objects::{Curve, Face, Objects},
+    storage::Handle,
 };
 
 use super::{CurveFaceIntersection, SurfaceSurfaceIntersection};
@@ -24,11 +24,11 @@ pub struct FaceFaceIntersection {
 
 impl FaceFaceIntersection {
     /// Compute the intersections between two faces
-    pub fn compute(faces: [&Face; 2], stores: &Stores) -> Option<Self> {
+    pub fn compute(faces: [&Face; 2], objects: &Objects) -> Option<Self> {
         let surfaces = faces.map(|face| face.surface().clone());
 
         let intersection_curves =
-            SurfaceSurfaceIntersection::compute(surfaces, stores)?
+            SurfaceSurfaceIntersection::compute(surfaces, objects)?
                 .intersection_curves;
 
         // Can be cleaned up, once `zip` is stable:
@@ -64,16 +64,16 @@ mod tests {
 
     use crate::{
         algorithms::intersect::CurveFaceIntersection,
-        objects::{Curve, Face, Surface},
+        objects::{Curve, Face, Objects, Surface},
         partial::HasPartial,
-        stores::{Handle, Stores},
+        storage::Handle,
     };
 
     use super::FaceFaceIntersection;
 
     #[test]
     fn compute_no_intersection() {
-        let stores = Stores::new();
+        let objects = Objects::new();
 
         #[rustfmt::skip]
         let points = [
@@ -84,20 +84,20 @@ mod tests {
         ];
         let [a, b] =
             [Surface::xy_plane(), Surface::xz_plane()].map(|surface| {
-                let surface = stores.surfaces.insert(surface);
-                Face::builder(&stores, surface)
+                let surface = objects.surfaces.insert(surface);
+                Face::builder(&objects, surface)
                     .with_exterior_polygon_from_points(points)
                     .build()
             });
 
-        let intersection = FaceFaceIntersection::compute([&a, &b], &stores);
+        let intersection = FaceFaceIntersection::compute([&a, &b], &objects);
 
         assert!(intersection.is_none());
     }
 
     #[test]
     fn compute_one_intersection() {
-        let stores = Stores::new();
+        let objects = Objects::new();
 
         #[rustfmt::skip]
         let points = [
@@ -107,20 +107,20 @@ mod tests {
             [-1.,  1.],
         ];
         let surfaces = [Surface::xy_plane(), Surface::xz_plane()]
-            .map(|surface| stores.surfaces.insert(surface));
+            .map(|surface| objects.surfaces.insert(surface));
         let [a, b] = surfaces.clone().map(|surface| {
-            Face::builder(&stores, surface)
+            Face::builder(&objects, surface)
                 .with_exterior_polygon_from_points(points)
                 .build()
         });
 
-        let intersection = FaceFaceIntersection::compute([&a, &b], &stores);
+        let intersection = FaceFaceIntersection::compute([&a, &b], &objects);
 
         let expected_curves = surfaces.map(|surface| {
             Handle::<Curve>::partial()
                 .with_surface(Some(surface))
                 .as_line_from_points([[0., 0.], [1., 0.]])
-                .build(&stores)
+                .build(&objects)
         });
         let expected_intervals =
             CurveFaceIntersection::from_intervals([[[-1.], [1.]]]);