Get rid of a bunch of unwrap()s

Cross.toml

@@ -1,8 +0,0 @@
-[build]
-default-target = "aarch64-unknown-linux-gnu"   # use this target if none is explicitly provided
-pre-build = [                                  # additional commands to run prior to building the package
-    "dpkg --add-architecture $CROSS_DEB_ARCH", 
-    "apt update",
-    "apt --assume-yes install apt-utils:$CROSS_DEB_ARCH",
-    "apt --assume-yes install libsdl3-dev:$CROSS_DEB_ARCH"
-]                 

src/gtfs/loader.rs

@@ -1,6 +1,6 @@
 use log::debug;
 use gtfs_structures::{Calendar, CalendarDate, RawStopTime, RawTrip, Route, Stop};
-use serde::de::DeserializeOwned;
+use serde::de::{DeserializeOwned, value::MapAccessDeserializer};
 use std::{
     collections::{HashMap, HashSet},
     fs::File,
@@ -14,14 +14,14 @@ use crate::gtfs::{
 };
 
 trait Filter<T> {
-    fn accept(&self, v: &T) -> bool;
+    fn accept(&self, v: &T) -> Option<bool>;
 }
 
 // No filter on loaded records
 struct LoadAll {}
 impl<T> Filter<T> for LoadAll {
-    fn accept(&self, _: &T) -> bool {
+    fn accept(&self, _: &T) -> Option<bool> {
-        return true;
+        return Some(true);
     }
 }
 
@@ -29,9 +29,9 @@ struct LoadRoutes<'a> {
     routes: &'a HashSet<String>,
 }
 impl Filter<Route> for LoadRoutes<'_> {
-    fn accept(&self, r: &Route) -> bool {
+    fn accept(&self, r: &Route) -> Option<bool> {
         let short_name = &r.short_name;
-        return short_name.is_some() && self.routes.contains(short_name.as_ref().unwrap());
+        return Some(short_name.is_some() && self.routes.contains(short_name.as_ref()?));
     }
 }
 
@@ -39,9 +39,9 @@ struct LoadStops<'a> {
     stops: &'a HashSet<String>,
 }
 impl Filter<Stop> for LoadStops<'_> {
-    fn accept(&self, s: &Stop) -> bool {
+    fn accept(&self, s: &Stop) -> Option<bool> {
         let stop_code = &s.code;
-        return stop_code.is_some() && self.stops.contains(s.code.as_ref().unwrap());
+        return Some(stop_code.is_some() && self.stops.contains(s.code.as_ref()?));
     }
 }
 
@@ -49,9 +49,9 @@ struct LoadTrips<'a> {
     route_ids: &'a HashSet<String>,
 }
 impl Filter<RawTrip> for LoadTrips<'_> {
-    fn accept(&self, t: &RawTrip) -> bool {
+    fn accept(&self, t: &RawTrip) -> Option<bool> {
         let route_id = &t.route_id;
-        return self.route_ids.contains(route_id);
+        return Some(self.route_ids.contains(route_id));
     }
 }
 
@@ -60,8 +60,8 @@ struct LoadStopTimes<'a> {
     stop_ids: &'a HashSet<String>,
 }
 impl Filter<RawStopTime> for LoadStopTimes<'_> {
-    fn accept(&self, st: &RawStopTime) -> bool {
+    fn accept(&self, st: &RawStopTime) -> Option<bool> {
-        return self.stop_ids.contains(&st.stop_id) && self.trip_ids.contains(&st.trip_id);
+        return Some(self.stop_ids.contains(&st.stop_id) && self.trip_ids.contains(&st.trip_id));
     }
 }
 
@@ -70,14 +70,15 @@ fn load_vector<T: serde::de::DeserializeOwned>(
     destination: &mut Vec<T>,
     zip_reader: &mut ZipArchive<File>,
     table_name: &str,
-) {
+) -> Option<bool> {
-    let file_reader = zip_reader.by_name(table_name).unwrap();
+    let file_reader = zip_reader.by_name(table_name);
-    let mut rdr = csv::Reader::from_reader(file_reader);
+    let mut rdr = csv::Reader::from_reader(file_reader.ok()?);
 
     for row in rdr.deserialize() {
-        let record: T = row.unwrap();
+        let record: T = row.ok()?;
         destination.push(record);
     }
+    return Some(true);
 }
 
 // Loads a HashMap of the selected type, using the provided index function as the key
@@ -87,27 +88,30 @@ fn load_map<K, V, IndexFn, FilterT>(
     table_name: &str,
     index: IndexFn,
     filter: FilterT,
-) where
+)  -> Option<bool>
+    where
     K: Eq + Hash,
     V: DeserializeOwned,
     IndexFn: Fn(&V) -> K,
-    FilterT: Filter<V>,
+    FilterT: Filter<V> 
 {
-    let file_reader = zip_reader.by_name(table_name).unwrap();
+    let file_reader = (zip_reader.by_name(table_name)).ok()?;
     let mut rdr = csv::Reader::from_reader(file_reader);
 
     for row in rdr.deserialize() {
         if row.is_ok() {
-            let record: V = row.unwrap();
+            let record: V = row.ok()?;
-            if filter.accept(&record) {
+            let accepted = filter.accept(&record);
+            if accepted.is_some() && accepted? {
                 let idx: K = index(&record);
                 destination.insert(idx, record);
             }
         } else {
             print!("Row failed to deserialize row {:#?}", row.err());
-            panic!();
+            return None;
         }
     }
+    return Some(true);
 }
 
 // Loads a HashMap of a vector of the selected type, using the provided index function as the key
@@ -118,22 +122,25 @@ fn load_vector_map<'a, K, V, IndexFn, FilterT>(
     table_name: &str,
     index: IndexFn,
     filter: FilterT,
-) where
+) -> Option<bool> 
+    where
     K: Eq + Hash,
     V: DeserializeOwned,
     IndexFn: Fn(&V) -> K,
     FilterT: Filter<V>,
 {
-    let file_reader = zip_reader.by_name(table_name).unwrap();
+    let file_reader = zip_reader.by_name(table_name).ok()?;
     let mut rdr = csv::Reader::from_reader(file_reader);
 
     for row in rdr.deserialize() {
-        let record: V = row.unwrap();
+        let record: V = row.ok()?;
-        if filter.accept(&record) {
+        let accepted = filter.accept(&record);
+        if  accepted.is_some() && accepted? {
             let idx = index(&record);
             destination.entry(idx).or_insert_with(Vec::new).push(record);
         }
     }
+    return Some(true)
 }
 
 pub fn load_gtfs(

src/gtfs/mod.rs

@@ -5,8 +5,7 @@ pub mod structs;
 use chrono::{DateTime, Local, NaiveTime, Timelike};
 use log::{debug};
 use std::{
-    collections::{HashMap, HashSet},
+    collections::{HashMap, HashSet}, fs::File, io::Error
-    fs::File,
 };
 use gtfs_structures::{Exception, RawTrip};
 
@@ -15,7 +14,7 @@ use crate::gtfs::{loader::load_gtfs, structs::{Arrival, Gtfs, Preferences}};
 
 impl Gtfs {
 
-    pub fn get_next_arrivals_for(&self, target_datetime: &DateTime<Local>) -> Vec<Arrival<'_>> {
+    pub fn get_next_arrivals_for(&self, target_datetime: &DateTime<Local>) -> Option<Vec<Arrival<'_>>> {
         let naive_target = target_datetime.naive_local();
         let target_date = naive_target.date();
         
@@ -66,16 +65,13 @@ impl Gtfs {
 
         for (_id, stop_time) in self.stop_times.iter() {
             if trips.contains_key(&stop_time.trip_id) {
-                let stop_timestamp = stop_time.departure_time.or(stop_time.arrival_time).unwrap();
+                let stop_timestamp = stop_time.departure_time.or(stop_time.arrival_time)?;
                 debug!("Stop timestamp {} current timestamp {}", stop_timestamp, current_timestamp);
-                let trip= &self.trips.get(&stop_time.trip_id).unwrap();
                 if current_timestamp < stop_timestamp.into() {
                     let arrival: Arrival = Arrival {
-                        route: self.routes.get(&trip.route_id).unwrap(),
+                        route: self.routes.get(&self.trips.get(&stop_time.trip_id)?.route_id)?,
-                        stop: self.stops.get(&stop_time.stop_id).unwrap(),
+                        stop: self.stops.get(&stop_time.stop_id)?,
-                        stop_time: stop_time,
+                        departure_time: NaiveTime::from_num_seconds_from_midnight_opt(stop_timestamp, 0)?
-                        trip: &trip,
-                        departure_time: NaiveTime::from_num_seconds_from_midnight_opt(stop_timestamp, 0).unwrap()
                     };
                     arrivals.push(arrival);                        
                 }
@@ -83,14 +79,15 @@ impl Gtfs {
         }
         debug!("Found {} arrivals", arrivals.len());
 
-        return arrivals;
+        return Some(arrivals);
     }
         
 
     /// Load a GTFS structure from a zip file
-    pub fn load(src_file: &str, prefs: &Preferences) -> Gtfs {
+    pub fn load(src_file: &str, prefs: &Preferences) -> Result<Gtfs, Error> {
         // Open zip file
-        let mut zip_reader = zip::ZipArchive::new(File::open(src_file).unwrap()).unwrap();
+        let zip_file = File::open(src_file)?;
+        let mut zip_reader = zip::ZipArchive::new(zip_file)?;
 
         let mut gtfs: Gtfs = Gtfs {
             agencies: Vec::new(),
@@ -105,6 +102,6 @@ impl Gtfs {
 
         load_gtfs(&mut gtfs, &mut zip_reader, &prefs.route_numbers, &prefs.stop_codes);
 
-        return gtfs;
+        return Ok(gtfs);
     }
 }

src/gtfs/structs.rs

@@ -35,6 +35,4 @@ pub struct Arrival<'a> {
     pub departure_time: NaiveTime,
     pub route: &'a Route,
     pub stop: &'a Stop,
-    pub stop_time: &'a RawStopTime,
-    pub trip: &'a RawTrip,
 }

src/main.rs

@@ -1,10 +1,10 @@
 mod gtfs;
 mod renderer;
-use std::{collections::{HashSet, btree_map::Entry}, ops::Add, process, rc::Rc, thread::Builder, time::SystemTime};
+use std::{collections::HashSet, ops::Add, os::unix::process::ExitStatusExt, process, thread::Builder, time::SystemTime};
 use chrono::{DateTime, Duration, Local, NaiveTime};
 use log::{Metadata, Record, debug, error, info};
 use sdl3::event::Event;
-use crate::{gtfs::structs::{Arrival, Gtfs}, renderer::structs::{DisplayData, DisplayEntry, Screen}};
+use crate::{gtfs::structs::{Arrival, Gtfs}, renderer::structs::Screen};
 
 const SRC_FILE: &str = "/home/nahuel/Downloads/GTFS_Realtime.zip";
 const NUM_ARRIVALS: usize = 4;
@@ -15,41 +15,21 @@ struct RefreshDataEvent {
 }
 
 
-fn refresh_schedule<'a>(gtfs: &'a Gtfs, screen: &mut Screen<'a>) -> Vec<Arrival<'a>>  {
+fn refresh_schedule(gtfs: &Gtfs) -> Option<Vec<Arrival<'_>>>  {
     let current_timestamp = SystemTime::now();
     let datetime: DateTime<Local> = current_timestamp.clone().into(); 
-    let mut next_arrivals: Vec<Arrival<'_>> = gtfs.get_next_arrivals_for(&datetime);
+    let mut next_arrivals: Vec<Arrival<'_>> = gtfs.get_next_arrivals_for(&datetime)?;
 
     if next_arrivals.len() < NUM_ARRIVALS {
         // If we don't have enough entries today, look for arrivals tomorrow.
         let mut tomorrow: DateTime<Local> = datetime.clone();
         tomorrow = tomorrow.with_time(NaiveTime::from_hms_opt(0, 0, 0).unwrap()).unwrap();
         tomorrow = tomorrow.add(Duration::days(1));
-        next_arrivals.append(&mut gtfs.get_next_arrivals_for(&tomorrow));
+        next_arrivals.append(&mut gtfs.get_next_arrivals_for(&tomorrow)?);
     }
 
     next_arrivals.sort();
-
+    return Some(next_arrivals);
-    // Create the DisplayData structure to render the information to screen
-    let current_time =  Local::now().time();
-    let mut display_data: DisplayData = DisplayData {
-        lines: Vec::<DisplayEntry>::new(),
-        status: None
-    };
-
-    display_data.lines.extend(next_arrivals.iter().map(|arrival| -> DisplayEntry {
-            DisplayEntry {
-                destination: arrival.stop_time.stop_headsign.clone()
-                    .or(arrival.trip.trip_headsign.clone()
-                    .or(Option::Some(String::from("Unknown")
-                ))).unwrap(),
-                route: arrival.route.short_name.clone().or(arrival.route.long_name.clone()).unwrap(),
-                due_in: (arrival.departure_time - current_time).num_minutes().try_into().unwrap()
-            }
-        }));
-
-    screen.update_information(&display_data);
-    return next_arrivals;
 }
 
 
@@ -71,7 +51,7 @@ fn main() {
         fn flush(&self) {}
     }
 
-    log::set_logger(&MY_LOGGER).unwrap();
+    log::set_logger(&MY_LOGGER);
     log::set_max_level(log::LevelFilter::Trace);
 
     // Create preferences structures from config
@@ -88,11 +68,17 @@ fn main() {
 
     // Init GTFS static info
     info!("Loading GTFS data...");
-    let gtfs = Gtfs::load(SRC_FILE, &gtfs_prefs);
+    let res = Gtfs::load(SRC_FILE, &gtfs_prefs);
+
+    if let Err(e) = res {
+        error!("Error loading GTFS data: {}", e);
+        process::exit(-1);
+    } 
+    let gtfs = res.unwrap();
 
     // Init screen
     info!("Initializing screen...");
-    let mut screen = Screen::init(&screen_prefs);
+    let screen = Screen::init(&screen_prefs);
     info!("Startup done.");
 
     // Register our custom event and obtain the event-related objects to interact with the event loop
@@ -115,8 +101,6 @@ fn main() {
             };
         }).unwrap();
 
-    // Do an initial refresh
-    let _ = refresh_schedule(&gtfs, &mut screen);
 
     // Main event loop
     loop {
@@ -134,7 +118,7 @@ fn main() {
                 let refresh_data = event.as_user_event_type::<RefreshDataEvent>();
                 if refresh_data.is_some() {
                     debug!("Received user event: {:#?}", refresh_data.unwrap());
-                    let _data: Vec<Arrival<'_>> = refresh_schedule(&gtfs, &mut screen);
+                    let _data: Option<Vec<Arrival<'_>>> = refresh_schedule(&gtfs);
                     debug!("-------------------------------- Refresh done.");
                 }
             }

src/renderer/mod.rs

@@ -1,96 +1,32 @@
 
 pub mod structs;
-use std::cmp::min;
 
 use sdl3::{Sdl, pixels::Color, rect::Rect};
-use structs::{Prefs, DisplayData};
+use structs::{Prefs};
 
 use crate::renderer::structs::Screen;
 
-const LINE_COUNT: i32 = 6;
-const COLOR_LCD_AMBER   : Color = Color::RGB(0xf4, 0xcb, 0x60);
-const COLOR_LCD_GREEN   : Color = Color::RGB(0xb3, 0xff, 0x00);
-const COLOR_LCD_RED     : Color = Color::RGB(0xff, 0x3a, 0x4a);
-
-//const COLOR_BACKGROUND = pygame.Color(0, 0, 0)
-const UPDATE_INTERVAL_SECONDS: u32 = 62;
-const TEXT_SIZE: u32 = 160;  // Size of the font in pixels
-
-// Offsets of each part within a line
-const XOFFSET_ROUTE: u32 = 24;
-const XOFFSET_DESTINATION: u32 = 300;
-const XOFFSEET_TIME_LEFT: u32 = 1606;
-const INTER_LINE_OVERLAP: u32 = 15; 
-
-
 impl Screen<'_> {
 
     pub fn get_context(&self) -> &Sdl {
         return &self.context;
     }
 
-    fn color_for(&self, due_in: i32) -> Color {
-        if due_in > 15 { return COLOR_LCD_GREEN };
-        if due_in > 10 { return COLOR_LCD_AMBER };
-        return  COLOR_LCD_RED;
-    }
-
-
-    pub fn update_information(&mut self, display_data: &DisplayData) {
-        self.do_clear();
-        let num_arrivals: i32 = min(if display_data.status.is_some() {LINE_COUNT - 1} else {LINE_COUNT}, display_data.lines.len().try_into().unwrap());
-        for line in 0..num_arrivals {
-            // Compose a line of text with all the information 
-            let entry = display_data.lines.get(line as usize).unwrap();
-            let line: u32 = line.try_into().unwrap();
-            let due_in_mins = (entry.due_in / 60) as i32;
-            let arrival_color: Color = self.color_for(due_in_mins);
-
-            self.color = COLOR_LCD_AMBER;
-            self.do_print_at(line, &entry.route, XOFFSET_ROUTE);
-            self.do_print_at(line, &entry.destination, XOFFSET_DESTINATION);
-            self.color = arrival_color;
-            self.do_print_at(line, &due_in_mins.to_string(), XOFFSEET_TIME_LEFT);
-        };
-
-        if display_data.status.is_some() {
-            self.do_print_at(5, display_data.status.as_ref().unwrap(), 0);
-        }
-        self.do_update();
-    }
-
-
     pub fn print(&mut self, line: u32, text: &str) {
-        self.do_print_at(line, text, 0);
+        let rendered_text = self.font.render(text).solid(Color::RED).unwrap();
-        self.do_update();
-    }
-
-
-    fn do_print_at(&mut self, line: u32, text: &str, left: u32) -> u32 {
-        let rendered_text = self.font.render(text).solid(self.color).unwrap();
         let texture_creator = self.canvas.texture_creator();
         let texture = rendered_text.as_texture(&texture_creator).unwrap();
         let _ = self.canvas.copy(&texture, 
             Rect::new(0, 0, rendered_text.width(), rendered_text.height()), 
-            Rect::new(left.try_into().unwrap(), (line * (rendered_text.height() - INTER_LINE_OVERLAP)).try_into().unwrap(), rendered_text.width(), rendered_text.height()));
+            Rect::new(0, (line * rendered_text.height()).try_into().unwrap(), rendered_text.width(), rendered_text.height()));
-        return left + rendered_text.width();
-    }
-
-
-    pub fn clear(&mut self) {
-        self.do_clear();
-        self.do_update();
-    }
-
-
-    fn do_update (&mut self) {
         self.canvas.present();
     }
 
 
-    fn do_clear(&mut self) {
+    pub fn clear(&mut self) {
         self.canvas.set_draw_color(Color::BLACK);
         self.canvas.clear();
+        self.canvas.present();
     }
 
     /// Initialize video, allocate buffers and load fonts
@@ -114,7 +50,6 @@ impl Screen<'_> {
         let mut screen: Screen = Screen {
             canvas:  Box::new(window.into_canvas()), 
             font: Box::new(font),
-            color: COLOR_LCD_AMBER,
             context: Box::new(sdl_context),
         };
 

src/renderer/structs.rs

@@ -1,10 +1,9 @@
-use sdl3::{Sdl, pixels::Color, render::Canvas, ttf::Font, video::Window};
+use sdl3::{Sdl, render::Canvas, ttf::Font, video::Window};
 
 
 pub struct Screen<'a> {
     pub(crate) canvas: Box<Canvas<Window>>,
     pub(crate) font: Box<Font<'a>>,
-    pub(crate) color: Color,
     pub(crate) context: Box<Sdl>
 }
 
@@ -13,15 +12,3 @@ pub struct Prefs {
     pub screen_width: u32,
     pub screen_height: u32,
 }
-
-
-pub struct DisplayEntry {
-    pub route: String,
-    pub destination: String,
-    pub due_in: i32,
-}
-
-pub struct DisplayData {
-    pub lines: Vec<DisplayEntry>,
-    pub status: Option<String>
-}