1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

use fj_math::Point;

use crate::{
    objects::{Cycle, Face, Surface},
    partial::HasPartial,
    stores::{Handle, Stores},
};

/// API for building a [`Face`]
///
/// Also see [`Face::builder`].
pub struct FaceBuilder<'a> {
    /// The stores that the created objects are put in
    pub stores: &'a Stores,

    /// The surface that the [`Face`] is defined in
    pub surface: Handle<Surface>,

    /// The exterior cycle that bounds the [`Face`] on the outside
    ///
    /// Must be provided by the caller, directly or using one of the `with_`
    /// methods, before [`FaceBuilder::build`] is called.
    pub exterior: Option<Cycle>,

    /// The interior cycles that form holes in the [`Face`]
    pub interiors: Vec<Cycle>,
}

impl<'a> FaceBuilder<'a> {
    /// Build the [`Face`] with an exterior polygon from the provided points
    pub fn with_exterior_polygon_from_points(
        mut self,
        points: impl IntoIterator<Item = impl Into<Point<2>>>,
    ) -> Self {
        self.exterior = Some(
            Cycle::partial()
                .with_surface(Some(self.surface.clone()))
                .with_poly_chain_from_points(points)
                .close_with_line_segment()
                .build(self.stores),
        );
        self
    }

    /// Build the [`Face`] with an interior polygon from the provided points
    pub fn with_interior_polygon_from_points(
        mut self,
        points: impl IntoIterator<Item = impl Into<Point<2>>>,
    ) -> Self {
        self.interiors.push(
            Cycle::partial()
                .with_surface(Some(self.surface.clone()))
                .with_poly_chain_from_points(points)
                .close_with_line_segment()
                .build(self.stores),
        );
        self
    }

    /// Construct a polygon from a list of points
    pub fn build(self) -> Face {
        let exterior = self
            .exterior
            .expect("Can't build `Face` without exterior cycle");
        Face::from_exterior(exterior).with_interiors(self.interiors)
    }
}