blaise 0.1.4

A fast, local-first engine for GTFS transit data. Handles routing, fuzzy search, and geospatial queries without relying on external APIs.
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 crate::{
    raptor::Point,
    shared::{Time, time},
};

#[derive(Debug, Clone)]
pub(crate) struct Update {
    pub stop_idx: u32,
    pub arrival_time: Time,
    pub parent: Parent,
}

impl Update {
    pub fn new(stop_idx: u32, arrival_time: Time, parent: Parent) -> Self {
        Self {
            stop_idx,
            arrival_time,
            parent,
        }
    }
}

#[derive(Debug, Clone, Copy)]
pub(crate) struct Parent {
    pub from: Point,
    pub to: Point,
    pub parent_type: ParentType,
    pub departure_time: Time,
    pub arrival_time: Time,
}

impl Parent {
    pub fn new_transit(
        from: Point,
        to: Point,
        trip: u32,
        departure_time: Time,
        arrival_time: Time,
    ) -> Self {
        Self {
            from,
            to,
            parent_type: ParentType::Transit(trip),
            departure_time,
            arrival_time,
        }
    }
    pub fn new_transfer(from: Point, to: Point, departure_time: Time, arrival_time: Time) -> Self {
        Self {
            from,
            to,
            parent_type: ParentType::Transfer,
            departure_time,
            arrival_time,
        }
    }
    pub fn new_walk(from: Point, to: Point, departure_time: Time, arrival_time: Time) -> Self {
        Self {
            from,
            to,
            parent_type: ParentType::Walk,
            departure_time,
            arrival_time,
        }
    }
}

#[derive(Debug, Clone, Copy)]
pub(crate) enum ParentType {
    Transit(u32),
    Transfer,
    Walk,
}

impl ParentType {
    pub fn is_transit(&self) -> bool {
        matches!(self, ParentType::Transit(_))
    }
}

#[derive(Debug, Clone)]
pub(crate) struct Target {
    pub stops: Vec<u32>,
    pub tau_star: Time,
    pub best_stop: Option<u32>,
    pub best_round: Option<usize>,
}

impl Target {
    pub fn new() -> Self {
        Self {
            stops: vec![],
            tau_star: time::MAX,
            best_stop: None,
            best_round: None,
        }
    }

    pub fn clear(&mut self) {
        self.stops.clear();
        self.tau_star = time::MAX;
        self.best_stop = None;
        self.best_round = None;
    }
}