Rename coord::LatLon -> coord::LatLonDeg

src/coord.rs

 /// latitude: [-90.0, 90.0]
 /// longitude: [-180, 180.0]
 #[derive(Copy, Debug, PartialEq, Clone)]
-pub struct LatLon {
+pub struct LatLonDeg {
     pub lat: f64,
     pub lon: f64,
 }
 
-impl LatLon {
+impl LatLonDeg {
     pub fn new(lat: f64, lon: f64) -> Self {
-        LatLon { lat, lon }
+        LatLonDeg { lat, lon }
     }
 
     pub fn to_radians(&self) -> LatLonRad {
         LatLonRad { lat, lon }
     }
 
-    pub fn to_degrees(&self) -> LatLon {
+    pub fn to_degrees(&self) -> LatLonDeg {
         let f = 180.0 * FRAC_1_PI;
-        LatLon {
+        LatLonDeg {
             lat: self.lat * f,
             lon: self.lon * f,
         }
     pub y: f64,
 }
 
-impl From<LatLon> for MapCoord
+impl From<LatLonDeg> for MapCoord
 {
-    fn from(pos: LatLon) -> MapCoord {
+    fn from(pos: LatLonDeg) -> MapCoord {
         let x = pos.lon * (1.0 / 360.0) + 0.5;
         let pi_lat = pos.lat * (PI / 180.0);
         let y = f64::ln(f64::tan(pi_lat) + 1.0 / f64::cos(pi_lat)) * (-0.5 * FRAC_1_PI) + 0.5;
         }
     }
 
-    pub fn to_latlon_deg(&self) -> LatLon {
-        LatLon {
+    pub fn to_latlon_deg(&self) -> LatLonDeg {
+        LatLonDeg {
             lat: (PI - self.y * (2.0 * PI)).sinh().atan() * (180.0 * FRAC_1_PI),
             lon: self.x * 360.0 - 180.0,
         }
     #[test]
     fn degree_radians() {
         {
-            let rad = LatLon::new(0.0, 0.0).to_radians();
+            let rad = LatLonDeg::new(0.0, 0.0).to_radians();
             assert!(approx_eq(rad.lat, 0.0));
             assert!(approx_eq(rad.lon, 0.0));
             let deg = rad.to_degrees();
             assert!(approx_eq(deg.lon, 0.0));
         }
         {
-            let rad = LatLon::new(-45.0, 180.0).to_radians();
+            let rad = LatLonDeg::new(-45.0, 180.0).to_radians();
             assert!(approx_eq(rad.lat, -PI / 4.0));
             assert!(approx_eq(rad.lon, PI));
             let deg = rad.to_degrees();
         }
 
         {
-            let mc = MapCoord::from(LatLon::new(23.45, 123.45));
+            let mc = MapCoord::from(LatLonDeg::new(23.45, 123.45));
             let deg = mc.to_latlon_rad().to_degrees();
             assert!(approx_eq(deg.lat, 23.45));
             assert!(approx_eq(deg.lon, 123.45));

src/main.rs

 pub mod url_template;
 pub mod vertex_attrib;
 
-use coord::{LatLon, ScreenCoord};
+use coord::{LatLonDeg, ScreenCoord};
 use glutin::{ControlFlow, ElementState, Event, GlContext, MouseButton, MouseScrollDelta, VirtualKeyCode, WindowEvent};
 use map_view_gl::MapViewGl;
 use std::error::Error;
     map: &mut MapViewGl,
     input_state: &mut InputState,
     sources: &mut TileSources,
-    marker_rx: &mpsc::Receiver<Vec<LatLon>>,
+    marker_rx: &mpsc::Receiver<Vec<LatLonDeg>>,
 ) -> Action {
     match *event {
         Event::Awakened => {

src/search.rs

-use coord::LatLon;
+use coord::LatLonDeg;
 use osmpbf::{Blob, BlobDecode, BlobReader, PrimitiveBlock};
 use regex::Regex;
 use scoped_threadpool::Pool;
     finished_func: G,
 ) -> Result<thread::JoinHandle<()>, String>
 where P: AsRef<Path>,
-      F: Fn(Vec<LatLon>) -> ControlFlow + Send + 'static,
+      F: Fn(Vec<LatLonDeg>) -> ControlFlow + Send + 'static,
       G: Fn(Result<(), String>) + Send + 'static,
 {
     let pbf_path = PathBuf::from(pbf_path.as_ref());
     found_func: F,
 ) -> Result<(), String>
 where P: AsRef<Path>,
-      F: Fn(Vec<LatLon>) -> ControlFlow + Send + 'static,
+      F: Fn(Vec<LatLonDeg>) -> ControlFlow + Send + 'static,
 {
     let re = Regex::new(search_pattern)
         .map_err(|e| format!("{}", e))?;
         for node in block.groups().flat_map(|g| g.nodes()) {
             for (_key, val) in node.tags() {
                 if re.is_match(val) {
-                    let pos = LatLon::new(node.lat(), node.lon());
+                    let pos = LatLonDeg::new(node.lat(), node.lon());
                     matches.push(pos);
                     break;
                 }
         for node in block.groups().flat_map(|g| g.dense_nodes()) {
             for (_key, val) in node.tags() {
                 if re.is_match(val) {
-                    let pos = LatLon::new(node.lat(), node.lon());
+                    let pos = LatLonDeg::new(node.lat(), node.lon());
                     matches.push(pos);
                     break;
                 }
 
         for node in block.groups().flat_map(|g| g.nodes()) {
             if way_node_ids.contains(&node.id()) {
-                let pos = LatLon::new(node.lat(), node.lon());
+                let pos = LatLonDeg::new(node.lat(), node.lon());
                 matches.push(pos);
             }
         }
 
         for node in block.groups().flat_map(|g| g.dense_nodes()) {
             if way_node_ids.contains(&node.id) {
-                let pos = LatLon::new(node.lat(), node.lon());
+                let pos = LatLonDeg::new(node.lat(), node.lon());
                 matches.push(pos);
             }
         }