physdes-rs 0.1.5

Physical Design in Rust
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

//! Error types for physdes-rs
//!
//! This module provides comprehensive error handling for geometric operations.

use std::fmt;

/// Error type for geometric operations
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum GeomError {
    /// Invalid polygon construction
    InvalidPolygon(String),

    /// Invalid interval (lower bound > upper bound)
    InvalidInterval { lower: i64, upper: i64 },

    /// Self-intersecting polygon
    SelfIntersectingPolygon,

    /// Degenerate polygon (too few vertices)
    DegeneratePolygon { vertex_count: usize },

    /// Numerical stability issue
    NumericalError(String),

    /// Invalid point
    InvalidPoint(String),
}

impl fmt::Display for GeomError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            GeomError::InvalidPolygon(msg) => write!(f, "Invalid polygon: {}", msg),
            GeomError::InvalidInterval { lower, upper } => {
                write!(
                    f,
                    "Invalid interval: lower bound {} > upper bound {}",
                    lower, upper
                )
            }
            GeomError::SelfIntersectingPolygon => {
                write!(f, "Self-intersecting polygon not allowed")
            }
            GeomError::DegeneratePolygon { vertex_count } => {
                write!(
                    f,
                    "Degenerate polygon: insufficient vertices ({} vertices, minimum 3 required)",
                    vertex_count
                )
            }
            GeomError::NumericalError(msg) => write!(f, "Numerical error: {}", msg),
            GeomError::InvalidPoint(msg) => write!(f, "Invalid point: {}", msg),
        }
    }
}

impl std::error::Error for GeomError {}

/// Result type for geometric operations
pub type GeomResult<T> = Result<T, GeomError>;

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

    #[test]
    fn test_error_display() {
        let err = GeomError::InvalidPolygon("test message".to_string());
        assert_eq!(format!("{}", err), "Invalid polygon: test message");

        let err = GeomError::InvalidInterval {
            lower: 10,
            upper: 5,
        };
        assert_eq!(
            format!("{}", err),
            "Invalid interval: lower bound 10 > upper bound 5"
        );

        let err = GeomError::SelfIntersectingPolygon;
        assert_eq!(format!("{}", err), "Self-intersecting polygon not allowed");

        let err = GeomError::DegeneratePolygon { vertex_count: 2 };
        assert_eq!(
            format!("{}", err),
            "Degenerate polygon: insufficient vertices (2 vertices, minimum 3 required)"
        );
    }
}