osmgraphing 1.1.1

Playing around with graphs created via parsing OpenStreetMap data
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
129
130
131
132
133
134
135
136
137
138
139
140
141

use crate::{
    configs,
    helpers::{self, err},
    network::RoutePair,
};
use std::{
    fs::OpenOptions,
    io::{BufRead, BufReader},
    ops::Range,
};

pub struct Parser {
    route_lines: Range<usize>,
}

impl Parser {
    pub fn new() -> Parser {
        Parser { route_lines: 1..0 }
    }
}

impl super::Parsing for Parser {
    fn preprocess(&mut self, cfg: &configs::routing::Config) -> err::Feedback {
        let route_pairs_file = cfg
            .route_pairs_file
            .as_ref()
            .expect("No routes-file specified.");

        // only functional-lines are counted
        let mut line_number = 0;
        let mut is_taking_counts = false;
        // counts are only metric-count, node-count, edge-count (in this order)
        let mut counts = vec![];
        let file = OpenOptions::new()
            .read(true)
            .open(route_pairs_file)
            .expect(&format!("Couldn't open {}", route_pairs_file.display()));
        for line in BufReader::new(file)
            .lines()
            .map(Result::unwrap)
            .filter(helpers::is_line_functional)
        {
            // If there is a count, remember it.
            // The first occuring count let `is_taking_counts` getting true.
            // If all counts have been processed, `is_taking_counts` would change to false,
            // where the loop should stop and remember the line-number.
            let params: Vec<&str> = line.split_whitespace().collect();
            if params.len() == 1 {
                is_taking_counts = true;

                if let Ok(count) = params[0].parse::<usize>() {
                    counts.push(count);
                }
            } else if is_taking_counts {
                break;
            }

            line_number += 1;
        }

        // add counts
        if counts.len() < 1 {
            return Err("The provided routes-file doesn't have the routes-count.".into());
        }

        // Current state: Last line-number is first route-line.
        let routes_count = counts.pop().expect("Expect counts.len() >= 1");

        let start = line_number;
        let end = start + routes_count;
        self.route_lines = start..end;

        Ok(())
    }

    fn parse_route_pairs(
        &self,
        cfg: &configs::routing::Config,
    ) -> Result<Vec<(RoutePair<i64>, usize)>, String> {
        let mut route_pairs = Vec::with_capacity(self.route_lines.len());
        let route_pairs_file = cfg
            .route_pairs_file
            .as_ref()
            .expect("No routes-file specified.");

        let mut line_number = 0;
        let file = OpenOptions::new()
            .read(true)
            .open(route_pairs_file)
            .expect(&format!("Couldn't open {}", route_pairs_file.display()));
        for line in BufReader::new(file)
            .lines()
            .map(Result::unwrap)
            .filter(helpers::is_line_functional)
        {
            // check if line contains route
            if !self.route_lines.contains(&line_number) {
                line_number += 1;
                continue;
            }
            line_number += 1;

            // create route

            let params: Vec<&str> = line.split_whitespace().collect();
            if params.len() != 3 {
                return Err(format!(
                    "A route-line is expected to consist of (src-id, dst-id, count), \
                     but {} values are provided.",
                    params.len()
                ));
            }

            let param = params[0];
            let src_id = param
                .parse::<i64>()
                .ok()
                .ok_or(format!("Could not parse route's src-id {}", param))?;
            let param = params[1];
            let dst_id = param
                .parse::<i64>()
                .ok()
                .ok_or(format!("Could not parse route's dst-id {}", param))?;
            let param = params[2];
            let n = param
                .parse::<usize>()
                .ok()
                .ok_or(format!("Could not parse route's count {}", param))?;

            route_pairs.push((
                RoutePair {
                    src: src_id,
                    dst: dst_id,
                },
                n,
            ));
        }

        Ok(route_pairs)
    }
}