[course] Remove reference to Infallible

No longer needed now that we've removed CourseSetBuilder<GeoPoint>,
which used `TryFrom<GeoPoint> for GeoPoint`

Author: mshroyer

integration-stub/src/main.rs

@@ -5,8 +5,8 @@ use std::path::PathBuf;
 use anyhow::Result;
 use chrono::{DateTime, Utc};
 use clap::{Parser, Subcommand};
-use coursepointer::CourseSetOptions;
-use coursepointer::internal::{CourseFile, CourseSetBuilder, DEG, GeoPoint};
+use coursepointer::course::{CourseSetBuilder, CourseSetOptions};
+use coursepointer::internal::{CourseFile, DEG, GeoPoint};
 use dimensioned::f64prefixes::KILO;
 use dimensioned::si::M;
 use dimensioned::si::f64consts::HR;
@@ -67,10 +67,10 @@ fn write_fit(spec: PathBuf, out: PathBuf) -> Result<()> {
 
     let mut fit_file = BufWriter::new(File::create(&out)?);
     let mut builder = CourseSetBuilder::new(CourseSetOptions::default());
-    builder.add_course();
-    builder.last_course_mut()?.with_name(spec.name);
+    builder.add_route();
+    builder.last_route_mut()?.with_name(spec.name);
     for point in &spec.records {
-        builder.last_course_mut()?.with_route_point(GeoPoint::new(
+        builder.last_route_mut()?.with_route_point(GeoPoint::new(
             point.lat * DEG,
             point.lon * DEG,
             None,

src/algorithm.rs

@@ -10,7 +10,6 @@ use std::ops::{Mul, Sub};
 use dimensioned::si::{M, Meter};
 use thiserror::Error;
 
-use crate::course::CourseError;
 use crate::geographic::{
     GeographicError, geodesic_direct, geodesic_inverse, gnomonic_forward, gnomonic_reverse,
 };
@@ -237,15 +236,13 @@ pub trait FromGeoPoints<'a, P>
 where
     Self: Sized,
     P: HasGeoPoint + TryFrom<GeoPoint>,
-    CourseError: From<<P as TryFrom<GeoPoint>>::Error>,
 {
     fn from_geo_points(start: &'a P, end: &'a P) -> std::result::Result<Self, GeographicError>;
 }
 
 impl<'a, P> FromGeoPoints<'a, P> for GeoSegment<'a, P>
 where
     P: HasGeoPoint + TryFrom<GeoPoint>,
-    CourseError: From<<P as TryFrom<GeoPoint>>::Error>,
 {
     fn from_geo_points(point1: &'a P, point2: &'a P) -> std::result::Result<Self, GeographicError> {
         let inverse = geodesic_inverse(point1.geo(), point2.geo())?;

src/course.rs

@@ -53,7 +53,6 @@
 //! calculations.
 
 use std::cmp::Ordering;
-use std::convert::Infallible;
 
 use dimensioned::si::{M, Meter};
 #[cfg(feature = "rayon")]
@@ -79,8 +78,6 @@ pub enum CourseError {
     Algorithm(#[from] AlgorithmError),
     #[error("Distance is NaN")]
     NaNDistance,
-    #[error("Infallible")]
-    Infallible(#[from] Infallible),
 }
 
 type Result<T> = std::result::Result<T, CourseError>;
@@ -163,7 +160,7 @@ pub struct CourseSet {
 /// Builds routes and waypoints into courses with associated course points
 pub struct CourseSetBuilder {
     options: CourseSetOptions,
-    course_builders: Vec<RouteBuilder>,
+    route_builders: Vec<RouteBuilder>,
     waypoints: Vec<Waypoint>,
 }
 
@@ -172,19 +169,19 @@ impl CourseSetBuilder {
     pub fn new(options: CourseSetOptions) -> Self {
         Self {
             options,
-            course_builders: Vec::new(),
+            route_builders: Vec::new(),
             waypoints: Vec::new(),
         }
     }
 
     /// Adds a new [`RouteBuilder`] to this set builder.
     pub fn add_route(&mut self) -> &mut RouteBuilder {
-        self.course_builders.push(RouteBuilder::new());
-        self.last_course_mut().unwrap()
+        self.route_builders.push(RouteBuilder::new());
+        self.last_route_mut().unwrap()
     }
 
-    pub fn last_course_mut(&mut self) -> Result<&mut RouteBuilder> {
-        match self.course_builders.last_mut() {
+    pub fn last_route_mut(&mut self) -> Result<&mut RouteBuilder> {
+        match self.route_builders.last_mut() {
             Some(course) => Ok(course),
             None => Err(CourseError::MissingCourse),
         }
@@ -195,16 +192,16 @@ impl CourseSetBuilder {
         self
     }
 
-    pub fn num_courses(&self) -> usize {
-        self.course_builders.len()
+    pub fn num_routes(&self) -> usize {
+        self.route_builders.len()
     }
 
     /// Build the courses.
     ///
     /// The geodesic calculations happen in here.
     pub fn build(mut self) -> Result<CourseSet> {
         let mut courses = Vec::new();
-        let mut course_builders = std::mem::take(&mut self.course_builders);
+        let mut course_builders = std::mem::take(&mut self.route_builders);
         let mut segmented_courses = course_builders
             .iter_mut()
             .map(|c| c.segment())

src/lib.rs

@@ -142,11 +142,11 @@ pub fn convert_gpx<R: BufRead, W: Write>(
                 }
 
                 GpxItem::TrackOrRouteName(name) => {
-                    builder.last_course_mut()?.with_name(name);
+                    builder.last_route_mut()?.with_name(name);
                 }
 
                 GpxItem::TrackOrRoutePoint(p) => {
-                    builder.last_course_mut()?.with_route_point(p);
+                    builder.last_route_mut()?.with_route_point(p);
                 }
 
                 GpxItem::Waypoint(wpt) => {
@@ -170,8 +170,8 @@ pub fn convert_gpx<R: BufRead, W: Write>(
         );
     }
 
-    if builder.num_courses() != 1usize {
-        return Err(CoursePointerError::CourseCount(builder.num_courses()));
+    if builder.num_routes() != 1usize {
+        return Err(CoursePointerError::CourseCount(builder.num_routes()));
     }
     let mut course_set = builder.build()?;
     let course = course_set.courses.remove(0);