routee-compass-core 0.6.0

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

use super::search_error::SearchError;
use crate::model::cost::cost_model::CostModel;
use crate::model::road_network::edge_id::EdgeId;
use crate::model::road_network::graph::Graph;
use crate::model::traversal::state::traversal_state::TraversalState;
use crate::model::traversal::traversal_model::TraversalModel;
use crate::model::unit::Cost;
use serde::{Deserialize, Serialize};
use std::sync::Arc;
use std::{fmt::Display, sync::RwLockReadGuard};

#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct EdgeTraversal {
    pub edge_id: EdgeId,
    pub access_cost: Cost,
    pub traversal_cost: Cost,
    pub result_state: TraversalState,
}

impl EdgeTraversal {
    pub fn edge_cost(&self) -> Cost {
        self.access_cost + self.traversal_cost
    }
}

impl Display for EdgeTraversal {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(
            f,
            "edge {} acost:{} tcost:{} state:{:?}",
            self.edge_id, self.access_cost, self.traversal_cost, self.result_state
        )
    }
}

impl EdgeTraversal {
    /// traverses an edge, possibly after traversing some previous edge,
    /// collecting the access and traversal costs. returns the
    /// accumulated cost and updated search state.
    pub fn perform_traversal(
        edge_id: EdgeId,
        prev_edge_id: Option<EdgeId>,
        prev_state: &TraversalState,
        g: &RwLockReadGuard<Graph>,
        tm: &Arc<dyn TraversalModel>,
        um: &CostModel,
    ) -> Result<EdgeTraversal, SearchError> {
        let (src, edge, dst) = g
            .edge_triplet_attrs(edge_id)
            .map_err(SearchError::GraphError)?;

        let (access_state, access_cost) = prev_edge_id
            .map(|prev_e| {
                let prev_edge = g.get_edge(prev_e).map_err(SearchError::GraphError)?;
                let prev_src_v = g
                    .get_vertex(prev_edge.src_vertex_id)
                    .map_err(SearchError::GraphError)?;

                // we are coming from some previous edge and need to access the next edge first to proceed
                // with traversal. if there is an access state, compute the access cost.
                tm.access_edge(prev_src_v, prev_edge, src, edge, dst, prev_state)
                    .map_err(SearchError::TraversalModelFailure)
                    .and_then(|next_state_opt| match next_state_opt {
                        Some(next_state) => {
                            let cost = um
                                .access_cost(prev_edge, edge, prev_state, &next_state)
                                .map_err(SearchError::CostError)?;
                            Ok((next_state, cost))
                        }
                        None => Ok((prev_state.to_owned(), Cost::ZERO)),
                    })
            })
            .unwrap_or(Ok((prev_state.to_owned(), Cost::ZERO)))?;

        let result_state = tm
            .traverse_edge(src, edge, dst, &access_state)
            .map_err(SearchError::TraversalModelFailure)?;

        let traversal_cost = um
            .traversal_cost(edge, prev_state, &result_state)
            .map_err(SearchError::CostError)?;

        let result = EdgeTraversal {
            edge_id,
            access_cost,
            traversal_cost,
            result_state,
        };

        Ok(result)
    }
}