Make import functions return Result

adnathanail · adnathanail · commit edcf33f81443 · 2023-03-12T04:09:36.000Z
diff --git a/benches/benchmarks.rs b/benches/benchmarks.rs
@@ -24,7 +24,7 @@ fn shortest_path_benchmark(c: &mut Criterion) {
         },
     );
 
-    let dimacs_g = load_tsplib_file("test_data/dimacs_tsp/d1291.tsp", usize::MAX);
+    let dimacs_g = load_tsplib_file("test_data/dimacs_tsp/d1291.tsp", usize::MAX).unwrap();
     group.bench_with_input(
         BenchmarkId::new("DIMCAS d1291", &dimacs_g),
         &dimacs_g,
@@ -36,7 +36,7 @@ fn shortest_path_benchmark(c: &mut Criterion) {
         },
     );
 
-    let monaco_g = load_pbf_file("test_data/geofabrik/monaco-latest.osm.pbf");
+    let monaco_g = load_pbf_file("test_data/geofabrik/monaco-latest.osm.pbf").unwrap();
     let mut monaco_cc = ConnectedComponents::new(&monaco_g);
     monaco_cc.run();
     let monaco_largest_g = monaco_cc.get_largest_connected_subgraphs();
@@ -73,14 +73,14 @@ fn shortest_path_benchmark(c: &mut Criterion) {
 fn travelling_salesman_benchmark(c: &mut Criterion) {
     let mut group = c.benchmark_group("Travelling salesman");
 
-    let dimacs_g = load_tsplib_file("test_data/dimacs_tsp/d1291.tsp", usize::MAX);
+    let dimacs_g = load_tsplib_file("test_data/dimacs_tsp/d1291.tsp", usize::MAX).unwrap();
     group.bench_with_input(
         BenchmarkId::new("DIMCAS d1291", &dimacs_g),
         &dimacs_g,
         |b, g| b.iter(|| travelling_salesman(g, false)),
     );
 
-    let monaco_g = load_pbf_file("test_data/geofabrik/monaco-latest.osm.pbf");
+    let monaco_g = load_pbf_file("test_data/geofabrik/monaco-latest.osm.pbf").unwrap();
 
     let mut monaco_cc = ConnectedComponents::new(&monaco_g);
     monaco_cc.run();
@@ -102,7 +102,7 @@ fn travelling_salesman_benchmark(c: &mut Criterion) {
 }
 
 fn connected_components_benchmark(c: &mut Criterion) {
-    let g = load_pbf_file("test_data/geofabrik/monaco-latest.osm.pbf");
+    let g = load_pbf_file("test_data/geofabrik/monaco-latest.osm.pbf").unwrap();
 
     let mut group = c.benchmark_group("Connected components");
 
diff --git a/src/graphs/algorithms/shortest_path.rs b/src/graphs/algorithms/shortest_path.rs
@@ -1,4 +1,4 @@
-use super::super::super::algorithms::PriorityQueue;
+use crate::algorithms::PriorityQueue;
 use crate::graphs::datastructures::GraphPath;
 use crate::graphs::datastructures::{Digraph, NodeIndex};
 
diff --git a/src/graphs/input/pbf.rs b/src/graphs/input/pbf.rs
@@ -3,8 +3,21 @@ use crate::graphs::datastructures::{ALDigraph, LatLng};
 use crate::graphs::datastructures::{Digraph, NodeID};
 use osmpbf::{Element, ElementReader};
 
-pub fn load_pbf_file(pbf_path: &str) -> ALDigraph {
-    let reader = ElementReader::from_path(pbf_path).unwrap();
+#[derive(Debug)]
+pub enum PBFImportError {
+    OSMPBFError(osmpbf::Error),
+}
+
+impl From<osmpbf::Error> for PBFImportError {
+    fn from(err: osmpbf::Error) -> PBFImportError {
+        PBFImportError::OSMPBFError(err)
+    }
+}
+
+type Result<T> = std::result::Result<T, PBFImportError>;
+
+pub fn load_pbf_file(pbf_path: &str) -> Result<ALDigraph> {
+    let reader = ElementReader::from_path(pbf_path)?;
 
     let num_nodes = reader
         .par_map_reduce(
@@ -15,16 +28,15 @@ pub fn load_pbf_file(pbf_path: &str) -> ALDigraph {
             },
             || 0_u64,     // Zero is the identity value for addition
             |a, b| a + b, // Sum the partial results
-        )
-        .unwrap();
+        )?;
 
     println!("Number of nodes: {num_nodes}");
 
     let mut g = ALDigraph::new(num_nodes as usize);
 
     println!("Graph initialised");
 
-    let reader = ElementReader::from_path(pbf_path).unwrap();
+    let reader = ElementReader::from_path(pbf_path)?;
 
     reader
         .for_each(|element| {
@@ -45,14 +57,13 @@ pub fn load_pbf_file(pbf_path: &str) -> ALDigraph {
                     },
                 )
             }
-        })
-        .unwrap();
+        })?;
 
     println!("Nodes added");
 
     let mut ways = 0_u64;
 
-    let reader = ElementReader::from_path(pbf_path).unwrap();
+    let reader = ElementReader::from_path(pbf_path)?;
 
     reader
         .for_each(|element| {
@@ -74,10 +85,9 @@ pub fn load_pbf_file(pbf_path: &str) -> ALDigraph {
                 }
                 ways += 1;
             }
-        })
-        .unwrap();
+        })?;
 
     println!("Edges added");
 
-    g
+    Ok(g)
 }
diff --git a/src/graphs/input/tsplib.rs b/src/graphs/input/tsplib.rs
@@ -3,42 +3,30 @@ use rand::{thread_rng, Rng};
 use std::{cmp, fs, io::Cursor};
 use tsplib::NodeCoord;
 
-pub fn generate_random_tsplib_file(num_nodes: usize) -> String {
-    let mut rng = thread_rng();
-
-    let mut lines: Vec<String> = Vec::with_capacity(num_nodes);
-
-    lines.push("NAME : example".to_string());
-    lines.push("TYPE : TSP".to_string());
-    lines.push(format!("DIMENSION : {}", num_nodes + 1));
-    lines.push("EDGE_WEIGHT_TYPE: EUC_2D".to_string());
-    lines.push("NODE_COORD_SECTION".to_string());
+#[derive(Debug)]
+pub enum TSPLIBImportError {
+    IOError(std::io::Error),
+    OtherError(String),
+}
 
-    let grid_size = num_nodes * 10;
-    for i in 0..num_nodes {
-        lines.push(format!(
-            "{} {} {}",
-            i,
-            rng.gen::<f32>() * (grid_size as f32),
-            rng.gen::<f32>() * (grid_size as f32)
-        ))
+impl From<std::io::Error> for TSPLIBImportError {
+    fn from(err: std::io::Error) -> TSPLIBImportError {
+        TSPLIBImportError::IOError(err)
     }
-
-    lines.push("EOF".to_string());
-
-    lines.join("\n")
 }
 
-pub fn load_tsplib_file(file_path: &str, num_nodes: usize) -> AMDigraph {
-    let tsp_string = fs::read_to_string(file_path).unwrap();
-    let instance = tsplib::parse(Cursor::new(&tsp_string[..])).unwrap();
+type Result<T> = std::result::Result<T, TSPLIBImportError>;
+
+pub fn load_tsplib_file(file_path: &str, num_nodes: usize) -> Result<AMDigraph> {
+    let tsp_string = fs::read_to_string(file_path)?;
+    let instance = tsplib::parse(Cursor::new(&tsp_string[..]))?;
 
     let actual_num_nodes = cmp::min(num_nodes, instance.dimension);
 
-    let coords = match instance.node_coord.unwrap() {
-        NodeCoord::Two(x) => x,
-        _ => panic!("Wrong format"),
-    };
+    let coords = match instance.node_coord.ok_or(TSPLIBImportError::OtherError("No node coords found".to_string()))? {
+        NodeCoord::Two(x) => Ok(x),
+        _ => Err(TSPLIBImportError::OtherError("No node coords found".to_string())),
+    }?;
 
     let mut g = AMDigraph::new(actual_num_nodes);
 
@@ -64,5 +52,31 @@ pub fn load_tsplib_file(file_path: &str, num_nodes: usize) -> AMDigraph {
         }
     }
 
-    g
+    Ok(g)
+}
+
+pub fn generate_random_tsplib_file(num_nodes: usize) -> String {
+    let mut rng = thread_rng();
+
+    let mut lines: Vec<String> = Vec::with_capacity(num_nodes);
+
+    lines.push("NAME : example".to_string());
+    lines.push("TYPE : TSP".to_string());
+    lines.push(format!("DIMENSION : {}", num_nodes + 1));
+    lines.push("EDGE_WEIGHT_TYPE: EUC_2D".to_string());
+    lines.push("NODE_COORD_SECTION".to_string());
+
+    let grid_size = num_nodes * 10;
+    for i in 0..num_nodes {
+        lines.push(format!(
+            "{} {} {}",
+            i,
+            rng.gen::<f32>() * (grid_size as f32),
+            rng.gen::<f32>() * (grid_size as f32)
+        ))
+    }
+
+    lines.push("EOF".to_string());
+
+    lines.join("\n")
 }
diff --git a/src/main.rs b/src/main.rs
@@ -1,17 +1,19 @@
 #[macro_use]
 extern crate rocket;
 
+use std::ops::Deref;
+use std::sync::{Arc, RwLock};
+
+use rocket::fairing::{Fairing, Info, Kind};
+use rocket::http::Header;
+use rocket::serde::{Deserialize, Serialize};
+use rocket::serde::json::Json;
+
 use broute::graphs::algorithms::{
-    form_abstracted_graph, travelling_salesman, ConnectedComponents, Dijkstra,
+    ConnectedComponents, Dijkstra, form_abstracted_graph, travelling_salesman,
 };
 use broute::graphs::datastructures::{ALDigraph, Digraph, LatLng, NodeID};
 use broute::graphs::input::load_pbf_file;
-use rocket::fairing::{Fairing, Info, Kind};
-use rocket::http::Header;
-use rocket::serde::json::Json;
-use rocket::serde::{Deserialize, Serialize};
-use std::ops::Deref;
-use std::sync::{Arc, RwLock};
 
 #[cfg(test)]
 mod tests;
@@ -170,7 +172,7 @@ impl Fairing for CORS {
 }
 
 async fn get_graph() -> ALDigraph {
-    let g = load_pbf_file("test_data/geofabrik/monaco-latest.osm.pbf");
+    let g = load_pbf_file("test_data/geofabrik/monaco-latest.osm.pbf").unwrap();
 
     println!("Original graph {:} nodes", g.num_vertices());
 

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-use super::super::super::algorithms::PriorityQueue;`
	`1`	`+use crate::algorithms::PriorityQueue;`
`2`	`2`	`use crate::graphs::datastructures::GraphPath;`
`3`	`3`	`use crate::graphs::datastructures::{Digraph, NodeIndex};`
`4`	`4`