decal 0.6.0

Declarative DSL for describing scenes and rendering them to SVG or PNG
Documentation 
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

use crate::{
    macros::pf32,
    utils::FloatWriter,
};
use std::fmt::{
    Display,
    Formatter,
    Write,
};
use strict_num::PositiveF32;

/// The pair of non-negative float values.
#[derive(Debug, Hash, Eq, PartialEq, Copy, Clone)]
pub struct PositiveF32Pair(PositiveF32, PositiveF32);

impl PositiveF32Pair {
    /// Returns `true` if both values in the pair are zero.
    pub(crate) fn is_zero(&self) -> bool {
        self.0 == PositiveF32::ZERO && self.1 == PositiveF32::ZERO
    }
}

impl Default for PositiveF32Pair {
    fn default() -> Self {
        PositiveF32Pair(PositiveF32::ZERO, PositiveF32::ZERO)
    }
}

impl From<f32> for PositiveF32Pair {
    fn from(value: f32) -> Self {
        let value = pf32!(value);
        PositiveF32Pair(value, value)
    }
}

impl From<(f32, f32)> for PositiveF32Pair {
    fn from((x, y): (f32, f32)) -> Self {
        PositiveF32Pair(pf32!(x), pf32!(y))
    }
}

impl Display for PositiveF32Pair {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        f.write_float(self.0.get())?;

        if self.0 != self.1 {
            f.write_char(' ')?;
            f.write_float(self.1.get())?;
        }

        Ok(())
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn defaults_to_zero() {
        let pair = PositiveF32Pair::default();
        assert!(pair.is_zero());
        assert_eq!(pair, PositiveF32Pair(PositiveF32::ZERO, PositiveF32::ZERO));
    }

    #[test]
    fn is_zero() {
        assert!(PositiveF32Pair::from(0.0).is_zero());
        assert!(!PositiveF32Pair::from((0.0, 1.0)).is_zero());
        assert!(!PositiveF32Pair::from((1.0, 0.0)).is_zero());
    }

    #[test]
    fn from_single_value() {
        assert_eq!(
            PositiveF32Pair::from(2.5),
            PositiveF32Pair(pf32!(2.5), pf32!(2.5))
        );
    }

    #[test]
    fn from_tuple() {
        assert_eq!(
            PositiveF32Pair::from((1.5, 2.5)),
            PositiveF32Pair(pf32!(1.5), pf32!(2.5))
        );
    }

    #[test]
    fn renders_single_value() {
        assert_eq!(PositiveF32Pair::from(3.5).to_string(), "3.5");
    }

    #[test]
    fn renders_tuple() {
        assert_eq!(PositiveF32Pair::from((3.2, 4.5)).to_string(), "3.2 4.5");
    }
}