routee-compass-core 0.11.3

The core routing algorithms and data structures of the RouteE-Compass energy-aware routing engine
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

use super::{map_error::MapError, matching_type::MatchingType};
use crate::model::unit::{Distance, DistanceUnit};
use serde::{Deserialize, Serialize};
use serde_json::Value;
use std::str::FromStr;

#[derive(Serialize, Deserialize, Clone, Debug)]
#[serde(tag = "type")]
pub enum MapModelConfig {
    #[serde(rename = "vertex")]
    VertexMapModelConfig {
        // #[serde(deserialize_with = "de_tolerance")]
        tolerance: Option<DistanceTolerance>,
        geometry_input_file: Option<String>,
        queries_without_destinations: bool,
        matching_type: Option<Vec<String>>,
    },
    #[serde(rename = "edge")]
    EdgeMapModelConfig {
        // #[serde(deserialize_with = "de_tolerance")]
        tolerance: Option<DistanceTolerance>,
        geometry_input_file: String,
        queries_without_destinations: bool,
        matching_type: Option<Vec<String>>,
    },
}

impl MapModelConfig {
    pub fn get_matching_type(&self) -> Result<MatchingType, MapError> {
        let matching_type = match self {
            MapModelConfig::VertexMapModelConfig {
                tolerance: _,
                geometry_input_file: _,
                queries_without_destinations: _,
                matching_type,
            } => matching_type,
            MapModelConfig::EdgeMapModelConfig {
                tolerance: _,
                geometry_input_file: _,
                queries_without_destinations: _,
                matching_type,
            } => matching_type,
        };
        match matching_type {
            None => Ok(MatchingType::default()),
            Some(string_list) => {
                let deserialized = string_list
                    .iter()
                    .map(|s| MatchingType::from_str(s.as_str()))
                    .collect::<Result<Vec<_>, _>>()?;
                match deserialized[..] {
                    [MatchingType::Point] => Ok(MatchingType::Point),
                    [MatchingType::VertexId] => Ok(MatchingType::VertexId),
                    [MatchingType::EdgeId] => Ok(MatchingType::EdgeId),
                    _ => Ok(MatchingType::Combined(deserialized)),
                }
            }
        }
    }
}

impl Default for MapModelConfig {
    fn default() -> Self {
        MapModelConfig::VertexMapModelConfig {
            tolerance: None,
            geometry_input_file: None,
            queries_without_destinations: true,
            matching_type: Some(MatchingType::names()),
        }
    }
}

impl TryFrom<Option<&Value>> for MapModelConfig {
    type Error = String;

    fn try_from(value: Option<&Value>) -> Result<Self, Self::Error> {
        match value {
            None => Ok(MapModelConfig::default()),
            Some(json) => {
                let map_model_str = serde_json::to_string_pretty(&json).unwrap_or_default();
                let map_model_config: MapModelConfig =
                    serde_json::from_value(json.clone()).map_err(|e| {
                        format!(
                            "unable to deserialize map model configuration section due to '{}'. input data: \n{}",
                            e,
                            map_model_str
                        )
                    })?;
                Ok(map_model_config)
            }
        }
    }
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct DistanceTolerance {
    pub distance: Distance,
    pub unit: DistanceUnit,
}

impl DistanceTolerance {
    pub fn unpack(&self) -> (Distance, DistanceUnit) {
        (self.distance, self.unit)
    }
}