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

use serde::{Deserialize, Serialize};

use crate::model::unit::{DistanceUnit, EnergyUnit, GradeUnit, SpeedUnit, TimeUnit};

use super::OutputFeature;

/// defines the required input feature and its requested unit type for a given state variable
///
/// if a unit type is provided, then the state variable is provided in the requested unit to the model.
#[derive(Serialize, Deserialize, Clone, Debug, Hash, Eq, PartialEq)]
#[serde(tag = "type", content = "convert", rename_all = "snake_case")]
pub enum InputFeature {
    Distance(Option<DistanceUnit>),
    Speed(Option<SpeedUnit>),
    Time(Option<TimeUnit>),
    Energy(Option<EnergyUnit>),
    Grade(Option<GradeUnit>),
    Custom { name: String, unit: String },
}

impl std::fmt::Display for InputFeature {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let s = serde_json::to_string_pretty(self).unwrap_or_default();
        write!(f, "{}", s)
    }
}

impl From<&OutputFeature> for InputFeature {
    fn from(value: &OutputFeature) -> Self {
        match value {
            OutputFeature::Distance {
                distance_unit,
                initial: _,
                accumulator: _,
            } => InputFeature::Distance(Some(*distance_unit)),
            OutputFeature::Time {
                time_unit,
                initial: _,
                accumulator: _,
            } => InputFeature::Time(Some(*time_unit)),
            OutputFeature::Energy {
                energy_unit,
                initial: _,
                accumulator: _,
            } => InputFeature::Energy(Some(*energy_unit)),
            OutputFeature::Speed {
                speed_unit,
                initial: _,
                accumulator: _,
            } => InputFeature::Speed(Some(*speed_unit)),
            OutputFeature::Grade {
                grade_unit,
                initial: _,
                accumulator: _,
            } => InputFeature::Grade(Some(*grade_unit)),
            OutputFeature::Custom {
                name,
                unit,
                format: _,
                accumulator: _,
            } => InputFeature::Custom {
                name: name.clone(),
                unit: unit.clone(),
            },
        }
    }
}