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
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103

/// Macro used for fuzzy equal assertions.
#[macro_export]
macro_rules! assert_fuzzy_eq {
    ($left:expr, $right:expr) => {{
        #[allow(unused_imports)]
        use $crate::core::traits::*;
        match (&$left, &$right) {
            (left_val, right_val) => {
                if !(left_val.fuzzy_eq(*right_val)) {
                    panic!(
                        r#"assertion failed: `left.fuzzy_eq(right)`
  left: `{:?}`,
 right: `{:?}`"#,
                        &*left_val, &*right_val
                    )
                }
            }
        }
    }};
    ($left:expr, $right:expr, $eps:expr) => {{
        #[allow(unused_imports)]
        use $crate::core::traits::*;
        match (&$left, &$right, &$eps) {
            (left_val, right_val, eps_val) => {
                if !(left_val.fuzzy_eq_eps(*right_val, *eps_val)) {
                    panic!(
                        r#"assertion failed: `left.fuzzy_eq_eps(right, eps)`
  left: `{:?}`,
 right: `{:?}`
 eps: `{:?}`"#,
                        &*left_val, &*right_val, &*eps_val
                    )
                }
            }
        }
    }};
}

/// Macro used for implementing pline macros. Used for extracting macro repetition count for
/// reserving capacity up front.
#[doc(hidden)]
#[macro_export]
macro_rules! replace_expr {
    ($_t:tt $sub:expr) => {
        $sub
    };
}

/// Construct a open polyline with the vertexes given as a list of (x, y, bulge) tuples.
///
/// # Examples
///
/// ```
/// # use cavalier_contours::pline_open;
/// # use cavalier_contours::polyline::*;
/// let polyline = pline_open![(0.0, 1.0, 1.0), (2.0, 0.0, 0.0)];
/// assert!(!polyline.is_closed());
/// assert_eq!(polyline[0], PlineVertex::new(0.0, 1.0, 1.0));
/// assert_eq!(polyline[1], PlineVertex::new(2.0, 0.0, 0.0));
/// ```
#[macro_export]
macro_rules! pline_open {
    ($( $x:expr ),* $(,)?) => {
        {
            #[allow(unused_imports)]
            use $crate::polyline::*;
            let size = <[()]>::len(&[$(cavalier_contours::replace_expr!(($x) ())),*]);
            let mut pl = Polyline::with_capacity(size, false);
            $(
                pl.add($x.0, $x.1, $x.2);
            )*
            pl
        }
    };
}

/// Construct a closed polyline with the vertexes given as a list of (x, y, bulge) tuples.
///
/// # Examples
///
/// ```
/// # use cavalier_contours::pline_closed;
/// # use cavalier_contours::polyline::*;
/// let polyline = pline_closed![(0.0, 1.0, 1.0), (2.0, 0.0, 0.0)];
/// assert!(polyline.is_closed());
/// assert_eq!(polyline[0], PlineVertex::new(0.0, 1.0, 1.0));
/// assert_eq!(polyline[1], PlineVertex::new(2.0, 0.0, 0.0));
/// ```
#[macro_export]
macro_rules! pline_closed {
    ($( $x:expr ),* $(,)?) => {
        {
            #[allow(unused_imports)]
            use $crate::polyline::*;
            let size = <[()]>::len(&[$(cavalier_contours::replace_expr!(($x) ())),*]);
            let mut pl = Polyline::with_capacity(size, true);
            $(
                pl.add($x.0, $x.1, $x.2);
            )*
            pl
        }
    };
}