Added handling for GPX Routes

Author: RCCoop

Sources/RCGPX/GPXDocument.swift

@@ -17,15 +17,19 @@ public struct GPXDocument {
     public var waypoints: [GPXWaypoint]
     /// An array of `GPXTrack` contained in this GPX file
     public var tracks: [GPXTrack]
+    /// An array of `GPXRoute` contained in this GPX file
+    public var routes: [GPXRoute]
 
     public init(
         creator: String? = nil,
         waypoints: [GPXWaypoint] = [],
-        tracks: [GPXTrack] = []
+        tracks: [GPXTrack] = [],
+        routes: [GPXRoute] = []
     ) {
         self.creator = creator
         self.waypoints = waypoints
         self.tracks = tracks
+        self.routes = routes
     }
 }
 
@@ -34,7 +38,7 @@ public struct GPXDocument {
 public extension GPXDocument {
     /// Returns an array of all `GPXFeatures` in the document in no particular order.
     var features: [GPXFeature] {
-        waypoints + tracks
+        waypoints + tracks + routes
     }
 
     /// Returns the full string representation of the GPX file.

Sources/RCGPX/GPXRoute.swift

@@ -0,0 +1,67 @@
+//
+//  GPXRoute.swift
+//  
+//
+//  Created by Ryan Linn on 3/28/23.
+//
+
+import AEXML
+import CoreLocation
+import Foundation
+
+/// A representation of a route of travel.
+public struct GPXRoute: GPXFeature {
+    public var name: String
+    public var gpxDescription: String?
+    public var routePoints: [GPXRoute.Point]
+    
+    public init(
+        name: String,
+        description: String?,
+        routePoints: [GPXRoute.Point]
+    ) {
+        self.name = name
+        self.gpxDescription = description
+        self.routePoints = routePoints
+    }
+    
+    public init(
+        name: String,
+        description: String?,
+        coordinates: [CLLocationCoordinate2D]
+    ) {
+        self.name = name
+        self.gpxDescription = description
+        self.routePoints = coordinates.map(Point.init)
+    }
+}
+
+extension GPXRoute {
+    public struct Point {
+        public var latitude: Double
+        public var longitude: Double
+        
+        public var coordinate: CLLocationCoordinate2D {
+            get {
+                CLLocationCoordinate2D(latitude: latitude, longitude: longitude)
+            }
+            set {
+                latitude = newValue.latitude
+                longitude = newValue.longitude
+            }
+        }
+        
+        public init(
+            latitude: Double,
+            longitude: Double
+        ) {
+            self.latitude = latitude
+            self.longitude = longitude
+        }
+        
+        public init(_ coordinate: CLLocationCoordinate2D) {
+            self.latitude = coordinate.latitude
+            self.longitude = coordinate.longitude
+        }
+    }
+}

Sources/RCGPX/Internal/GPXDocument+Internals.swift

@@ -21,13 +21,16 @@ extension GPXDocument: GPXElement {
         waypoints = try waypointElements.map { try GPXWaypoint(xml: $0) }
         let trackElements = xml.children.filter { $0.name == GPXTrack.xmlTag }
         tracks = try trackElements.map { try GPXTrack(xml: $0) }
+        let routeElements = xml.children.filter { $0.name == GPXRoute.xmlTag }
+        routes = try routeElements.map { try GPXRoute(xml: $0) }
     }
 
     var xmlElement: AEXMLElement {
         let element = AEXMLElement(name: Self.xmlTag)
         element.attributes["creator"] = creator
         element.addChildren(waypoints.map(\.xmlElement))
         element.addChildren(tracks.map(\.xmlElement))
+        element.addChildren(routes.map(\.xmlElement))
         return element
     }
 }

Sources/RCGPX/Internal/GPXRoute+Internals.swift

@@ -0,0 +1,77 @@
+//
+//  GPXRoute+Internals.swift
+//  
+//
+//  Created by Ryan Linn on 3/28/23.
+//
+
+import AEXML
+import Foundation
+
+// MARK: GPXRoute: GPXElement
+
+extension GPXRoute: GPXElement {
+    static var xmlTag: String {
+        "rte"
+    }
+
+    init(xml: AEXMLElement) throws {
+        guard let nameElement = xml["name"].value else {
+            throw GPXError.missingRequiredElement("name")
+        }
+        name = nameElement
+
+        gpxDescription = xml["desc"].value
+
+        routePoints = try xml
+            .children
+            .filter { $0.name == GPXRoute.Point.xmlTag }
+            .map { try GPXRoute.Point(xml: $0) }
+    }
+
+    var xmlElement: AEXMLElement {
+        let element = AEXMLElement(name: Self.xmlTag)
+        element.addChild(name: "name", value: name)
+        if let desc = gpxDescription {
+            element.addChild(name: "desc", value: desc)
+        }
+        element.addChildren(routePoints.map(\.xmlElement))
+        return element
+    }
+}
+
+// MARK: GPXRoute.Point: GPXElement
+
+extension GPXRoute.Point: GPXElement {
+    static var xmlTag: String {
+        "rtept"
+    }
+
+    init(xml: AEXMLElement) throws {
+        // longitude
+        guard let longitudeString = xml.attributes["lon"],
+              let longitudeDouble = Double(longitudeString)
+        else {
+            throw GPXError.missingRequiredElement("longitude")
+        }
+        longitude = longitudeDouble
+
+        // latitude
+        guard let latitudeString = xml.attributes["lat"],
+              let latitudeDouble = Double(latitudeString)
+        else {
+            throw GPXError.missingRequiredElement("latitude")
+        }
+        latitude = latitudeDouble
+    }
+
+    var xmlElement: AEXMLElement {
+        let attributes = [
+            "lat": "\(latitude)",
+            "lon": "\(longitude)",
+        ]
+        let element = AEXMLElement(name: Self.xmlTag, attributes: attributes)
+
+        return element
+    }
+}