jellyflow-core 0.2.0

Headless graph model, IDs, type descriptors, and interaction policy primitives for Jellyflow.
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

use serde::{Deserialize, Serialize};

/// A 2D point in canvas space.
#[derive(Debug, Default, Clone, Copy, PartialEq, Serialize, Deserialize)]
pub struct CanvasPoint {
    /// X coordinate.
    pub x: f32,
    /// Y coordinate.
    pub y: f32,
}

impl CanvasPoint {
    pub fn is_finite(self) -> bool {
        self.x.is_finite() && self.y.is_finite()
    }
}

/// A 2D size in canvas space.
#[derive(Debug, Default, Clone, Copy, PartialEq, Serialize, Deserialize)]
pub struct CanvasSize {
    /// Width.
    pub width: f32,
    /// Height.
    pub height: f32,
}

impl CanvasSize {
    pub fn is_finite(self) -> bool {
        self.width.is_finite() && self.height.is_finite()
    }

    pub fn is_positive_finite(self) -> bool {
        self.is_finite() && self.width > 0.0 && self.height > 0.0
    }
}

/// A rectangle in canvas space.
#[derive(Debug, Default, Clone, Copy, PartialEq, Serialize, Deserialize)]
pub struct CanvasRect {
    /// Top-left origin.
    pub origin: CanvasPoint,
    /// Size.
    pub size: CanvasSize,
}

impl CanvasRect {
    pub fn is_finite(self) -> bool {
        self.origin.is_finite() && self.size.is_finite()
    }

    pub fn is_positive_finite(self) -> bool {
        self.origin.is_finite() && self.size.is_positive_finite()
    }
}

#[cfg(test)]
mod tests {
    use super::{CanvasPoint, CanvasRect, CanvasSize};

    #[test]
    fn canvas_rect_is_positive_finite_requires_finite_origin_and_positive_size() {
        let valid = CanvasRect {
            origin: CanvasPoint { x: 1.0, y: -2.0 },
            size: CanvasSize {
                width: 10.0,
                height: 20.0,
            },
        };
        assert!(valid.is_positive_finite());

        let zero_width = CanvasRect {
            size: CanvasSize {
                width: 0.0,
                height: 20.0,
            },
            ..valid
        };
        assert!(!zero_width.is_positive_finite());

        let non_finite_origin = CanvasRect {
            origin: CanvasPoint {
                x: f32::INFINITY,
                y: 0.0,
            },
            ..valid
        };
        assert!(!non_finite_origin.is_positive_finite());
    }
}