rmpca 0.1.1

Enterprise-grade route optimization engine — Chinese Postman Problem solver with Eulerian circuit detection, Lean 4 FFI boundary, and property-based testing
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
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

//! Core geographic types used across the routing engine.
//!
//! // Aligns with `Lean4`: structure `Coordinate`, structure `GeoWay`

use serde::{Deserialize, Serialize};
use std::collections::HashMap;

/// A geographic coordinate (latitude, longitude).
///
/// // Aligns with `Lean4`: def `Coordinate` := `Prod Float Float`
#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)]
pub struct Coordinate {
    pub lat: f64,
    pub lon: f64,
}

impl Coordinate {
    /// Create a new coordinate.
    #[allow(dead_code)]
    #[must_use]
    pub fn new(lat: f64, lon: f64) -> Self {
        Self { lat, lon }
    }
}

/// A geographic way (road segment) with node IDs and geometry.
///
/// Used for Overture/OSM data that carries full geometry per way,
/// as opposed to the simpler `optimizer::Way` which only stores node ID references.
#[allow(dead_code)]
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Way {
    /// Unique identifier for this way
    pub id: String,

    /// Ordered list of node IDs forming this way
    pub node_ids: Vec<String>,

    /// Geometry coordinates corresponding to `node_ids`
    pub geometry: WayGeometry,

    /// OSM tags describing this road segment
    pub tags: HashMap<String, String>,
}

/// Geometry for a way — an ordered sequence of coordinates.
#[allow(dead_code)]
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct WayGeometry {
    pub coordinates: Vec<Coordinate>,
}

impl WayGeometry {
    /// Create geometry from a coordinate vector.
    #[allow(dead_code)]
    #[must_use]
    pub fn new(coordinates: Vec<Coordinate>) -> Self {
        Self { coordinates }
    }

    /// Create empty geometry.
    #[allow(dead_code)]
    #[must_use]
    pub fn empty() -> Self {
        Self { coordinates: Vec::new() }
    }
}

impl Way {
    /// Create a new way with the given ID, node IDs, and geometry.
    #[allow(dead_code)]
    #[must_use]
    pub fn new(id: impl Into<String>, node_ids: Vec<String>, geometry: WayGeometry) -> Self {
        Self {
            id: id.into(),
            node_ids,
            geometry,
            tags: HashMap::new(),
        }
    }

    /// Add a tag to this way.
    #[allow(dead_code)]
    #[must_use]
    pub fn with_tag(mut self, key: impl Into<String>, value: impl Into<String>) -> Self {
        self.tags.insert(key.into(), value.into());
        self
    }

    /// Check if this way is one-way based on OSM tags.
    #[must_use]
    pub fn is_oneway(&self) -> bool {
        self.tags
            .get("oneway")
            .is_some_and(|v| v == "yes" || v == "true" || v == "1")
    }
}

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

    #[test]
    fn test_coordinate_creation() {
        let coord = Coordinate::new(45.5, -73.6);
        assert_eq!(coord.lat, 45.5);
        assert_eq!(coord.lon, -73.6);
    }

    #[test]
    fn test_way_creation() {
        let way = Way::new(
            "way1",
            vec!["n1".to_string(), "n2".to_string()],
            WayGeometry::new(vec![Coordinate::new(45.5, -73.6), Coordinate::new(45.6, -73.7)]),
        );
        assert_eq!(way.id, "way1");
        assert_eq!(way.node_ids.len(), 2);
        assert!(!way.is_oneway());
    }

    #[test]
    fn test_way_oneway() {
        let way = Way::new("w1", vec![], WayGeometry::empty())
            .with_tag("oneway", "yes");
        assert!(way.is_oneway());
    }
}