Index: /trunk/src/org/openstreetmap/josm/data/coor/ILatLon.java
===================================================================
--- /trunk/src/org/openstreetmap/josm/data/coor/ILatLon.java (revision 12164)
+++ /trunk/src/org/openstreetmap/josm/data/coor/ILatLon.java (revision 12164)
@@ -0,0 +1,66 @@
+// License: GPL. For details, see LICENSE file.
+package org.openstreetmap.josm.data.coor;
+
+import org.openstreetmap.josm.Main;
+import org.openstreetmap.josm.data.projection.Projecting;
+
+/**
+ * This interface represents a coordinate in LatLon space.
+ *
+ * It provides methods to get the coordinates. The coordinates may be unknown.
+ * In this case, both {@link #lat()} and {@link #lon()} need to return a NaN value and {@link #isLatLonKnown()} needs to return false.
+ *
+ * Whether the coordinates are immutable or not is implementation specific.
+ *
+ * @author Michael Zangl
+ * @since 12161
+ */
+public interface ILatLon {
+
+ /**
+ * Returns the longitude, i.e., the east-west position in degrees.
+ * @return the longitude or NaN if {@link #isLatLonKnown()} returns false
+ */
+ public double lon();
+
+ /**
+ * Returns the latitude, i.e., the north-south position in degrees.
+ * @return the latitude or NaN if {@link #isLatLonKnown()} returns false
+ */
+ public double lat();
+
+ /**
+ * Determines if this object has valid coordinates.
+ * @return {@code true} if this object has valid coordinates
+ */
+ default boolean isLatLonKnown() {
+ return !Double.isNaN(lat()) && !Double.isNaN(lon());
+ }
+
+ /**
+ *
Replies the projected east/north coordinates.
+ *
+ * Uses the {@link Main#getProjection() global projection} to project the lan/lon-coordinates.
+ *
+ * @return the east north coordinates or {@code null} if #is
+ */
+ default EastNorth getEastNorth() {
+ return getEastNorth(Main.getProjection());
+ }
+
+ /**
+ * Replies the projected east/north coordinates.
+ *
+ * The result of the last conversion may be cached. Null is returned in case this object is invalid.
+ * @param projecting The projection to use.
+ * @return The projected east/north coordinates
+ * @since 10827
+ */
+ default EastNorth getEastNorth(Projecting projecting) {
+ if (!isLatLonKnown()) {
+ return null;
+ } else {
+ return projecting.latlon2eastNorth(this);
+ }
+ }
+}
Index: /trunk/src/org/openstreetmap/josm/data/gpx/GpxData.java
===================================================================
--- /trunk/src/org/openstreetmap/josm/data/gpx/GpxData.java (revision 12163)
+++ /trunk/src/org/openstreetmap/josm/data/gpx/GpxData.java (revision 12164)
@@ -40,7 +40,7 @@
public String creator;
- private ArrayList privateTracks = new ArrayList<>();
- private ArrayList privateRoutes = new ArrayList<>();
- private ArrayList privateWaypoints = new ArrayList<>();
+ private final ArrayList privateTracks = new ArrayList<>();
+ private final ArrayList privateRoutes = new ArrayList<>();
+ private final ArrayList privateWaypoints = new ArrayList<>();
private final GpxTrackChangeListener proxy = e -> fireInvalidate();
@@ -580,8 +580,8 @@
final int prime = 31;
int result = 1;
- result = prime * result + ((dataSources == null) ? 0 : dataSources.hashCode());
- result = prime * result + ((routes == null) ? 0 : routes.hashCode());
- result = prime * result + ((tracks == null) ? 0 : tracks.hashCode());
- result = prime * result + ((waypoints == null) ? 0 : waypoints.hashCode());
+ result = prime * result + dataSources.hashCode();
+ result = prime * result + privateRoutes.hashCode();
+ result = prime * result + privateTracks.hashCode();
+ result = prime * result + privateWaypoints.hashCode();
return result;
}
@@ -601,18 +601,18 @@
} else if (!dataSources.equals(other.dataSources))
return false;
- if (routes == null) {
- if (other.routes != null)
+ if (privateRoutes == null) {
+ if (other.privateRoutes != null)
return false;
- } else if (!routes.equals(other.routes))
+ } else if (!privateRoutes.equals(other.privateRoutes))
return false;
- if (tracks == null) {
- if (other.tracks != null)
+ if (privateTracks == null) {
+ if (other.privateTracks != null)
return false;
- } else if (!tracks.equals(other.tracks))
+ } else if (!privateTracks.equals(other.privateTracks))
return false;
- if (waypoints == null) {
- if (other.waypoints != null)
+ if (privateWaypoints == null) {
+ if (other.privateWaypoints != null)
return false;
- } else if (!waypoints.equals(other.waypoints))
+ } else if (!privateWaypoints.equals(other.privateWaypoints))
return false;
return true;
Index: /trunk/test/unit/org/openstreetmap/josm/data/gpx/GpxDataTest.java
===================================================================
--- /trunk/test/unit/org/openstreetmap/josm/data/gpx/GpxDataTest.java (revision 12163)
+++ /trunk/test/unit/org/openstreetmap/josm/data/gpx/GpxDataTest.java (revision 12164)
@@ -2,4 +2,12 @@
package org.openstreetmap.josm.data.gpx;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import java.util.Collections;
+
+import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
@@ -22,4 +30,316 @@
public JOSMTestRules test = new JOSMTestRules();
+ private GpxData data;
+
+ /**
+ * @throws java.lang.Exception
+ */
+ @Before
+ public void setUp() throws Exception {
+ data = new GpxData();
+ }
+
+
+ /**
+ * Test method for {@link GpxData#mergeFrom(GpxData)}.
+ */
+ @Test
+ public void testMergeFrom() {
+ fail("Not yet implemented");
+ }
+
+ /**
+ * Test method for {@link GpxData#getTracks()}, {@link GpxData#addTrack(GpxTrack)}, {@link GpxData#removeTrack(GpxTrack)}.
+ */
+ @Test
+ public void testTracks() {
+ assertEquals(0, data.getTracks().size());
+
+ ImmutableGpxTrack track1 = emptyGpxTrack();
+ ImmutableGpxTrack track2 = emptyGpxTrack();
+ data.addTrack(track1);
+ assertEquals(1, data.getTracks().size());
+ data.addTrack(track2);
+ assertEquals(2, data.getTracks().size());
+ assertTrue(data.getTracks().contains(track1));
+ assertTrue(data.getTracks().contains(track2));
+
+ data.removeTrack(track1);
+ assertEquals(1, data.getTracks().size());
+ assertFalse(data.getTracks().contains(track1));
+ assertTrue(data.getTracks().contains(track2));
+ }
+
+ /**
+ * Test method for {@link GpxData#addTrack(GpxTrack)}.
+ */
+ @Test(expected = IllegalArgumentException.class)
+ public void testAddTrackFails() {
+ ImmutableGpxTrack track1 = emptyGpxTrack();
+ data.addTrack(track1);
+ data.addTrack(track1);
+ }
+
+ /**
+ * Test method for {@link GpxData#removeTrack(GpxTrack)}.
+ */
+ @Test(expected = IllegalArgumentException.class)
+ public void testRemoveTrackFails() {
+ ImmutableGpxTrack track1 = emptyGpxTrack();
+ data.addTrack(track1);
+ data.removeTrack(track1);
+ data.removeTrack(track1);
+ }
+
+ /**
+ * Test method for {@link GpxData#getRoutes()}, {@link GpxData#addRoute(GpxRoute)}, {@link GpxData#removeRoute(GpxRoute)}.
+ */
+ @Test
+ public void testRoutes() {
+ assertEquals(0, data.getTracks().size());
+
+ GpxRoute route1 = new GpxRoute();
+ GpxRoute route2 = new GpxRoute();
+ data.addRoute(route1);
+ assertEquals(1, data.getRoutes().size());
+ data.addRoute(route2);
+ assertEquals(2, data.getRoutes().size());
+ assertTrue(data.getRoutes().contains(route1));
+ assertTrue(data.getRoutes().contains(route2));
+
+ data.removeRoute(route1);
+ assertEquals(1, data.getRoutes().size());
+ assertFalse(data.getRoutes().contains(route1));
+ assertTrue(data.getRoutes().contains(route2));
+ }
+
+ /**
+ * Test method for {@link GpxData#addRoute(GpxRoute)}.
+ */
+ @Test(expected = IllegalArgumentException.class)
+ public void testAddRouteFails() {
+ GpxRoute route1 = new GpxRoute();
+ data.addRoute(route1);
+ data.addRoute(route1);
+ }
+
+ /**
+ * Test method for {@link GpxData#removeRoute(GpxRoute)}.
+ */
+ @Test(expected = IllegalArgumentException.class)
+ public void testRemoveRouteFails() {
+ GpxRoute route1 = new GpxRoute();
+ data.addRoute(route1);
+ data.removeRoute(route1);
+ data.removeRoute(route1);
+ }
+
+ /**
+ * Test method for {@link GpxData#getWaypoints()}, {@link GpxData#addWaypoint(WayPoint)}, {@link GpxData#removeWaypoint(WayPoint)}.
+ */
+ @Test
+ public void testWaypoints() {
+ assertEquals(0, data.getTracks().size());
+
+ WayPoint waypoint1 = new WayPoint(LatLon.ZERO);
+ WayPoint waypoint2 = new WayPoint(LatLon.ZERO);
+ data.addWaypoint(waypoint1);
+ assertEquals(1, data.getWaypoints().size());
+ data.addWaypoint(waypoint2);
+ assertEquals(2, data.getWaypoints().size());
+ assertTrue(data.getWaypoints().contains(waypoint1));
+ assertTrue(data.getWaypoints().contains(waypoint2));
+
+ data.removeWaypoint(waypoint1);
+ assertEquals(1, data.getWaypoints().size());
+ assertFalse(data.getWaypoints().contains(waypoint1));
+ assertTrue(data.getWaypoints().contains(waypoint2));
+ }
+
+ /**
+ * Test method for {@link GpxData#addWaypoint(WayPoint)}.
+ */
+ @Test(expected = IllegalArgumentException.class)
+ public void testAddWaypointFails() {
+ WayPoint waypoint1 = new WayPoint(LatLon.ZERO);
+ data.addWaypoint(waypoint1);
+ data.addWaypoint(waypoint1);
+ }
+
+ /**
+ * Test method for {@link GpxData#removeWaypoint(WayPoint)}.
+ */
+ @Test(expected = IllegalArgumentException.class)
+ public void testRemoveWaypointFails() {
+ WayPoint waypoint1 = new WayPoint(LatLon.ZERO);
+ data.addWaypoint(waypoint1);
+ data.removeWaypoint(waypoint1);
+ data.removeWaypoint(waypoint1);
+ }
+
+ /**
+ * Test method for {@link GpxData#hasTrackPoints()}.
+ */
+ @Test
+ public void testHasTrackPoints() {
+ assertFalse(data.hasTrackPoints());
+ ImmutableGpxTrack track1 = emptyGpxTrack();
+ data.addTrack(track1);
+ assertFalse(data.hasTrackPoints());
+ ImmutableGpxTrack track2 = singleWaypointGpxTrack();
+ data.addTrack(track2);
+ assertTrue(data.hasTrackPoints());
+ }
+
+ /**
+ * Test method for {@link GpxData#getTrackPoints()}.
+ */
+ @Test
+ public void testGetTrackPoints() {
+ assertEquals(0, data.getTrackPoints().count());
+ ImmutableGpxTrack track1 = singleWaypointGpxTrack();
+ data.addTrack(track1);
+ assertEquals(1, data.getTrackPoints().count());
+ ImmutableGpxTrack track2 = singleWaypointGpxTrack();
+ data.addTrack(track2);
+ assertEquals(2, data.getTrackPoints().count());
+ }
+
+ /**
+ * Test method for {@link GpxData#hasRoutePoints()}.
+ */
+ @Test
+ public void testHasRoutePoints() {
+ fail("Not yet implemented");
+ }
+
+ /**
+ * Test method for {@link GpxData#isEmpty()}.
+ */
+ @Test
+ public void testIsEmpty() {
+ fail("Not yet implemented");
+ }
+
+ /**
+ * Test method for {@link GpxData#getMetaBounds()}.
+ */
+ @Test
+ public void testGetMetaBounds() {
+ fail("Not yet implemented");
+ }
+
+ /**
+ * Test method for {@link GpxData#recalculateBounds()}.
+ */
+ @Test
+ public void testRecalculateBounds() {
+ fail("Not yet implemented");
+ }
+
+ /**
+ * Test method for {@link GpxData#length()}.
+ */
+ @Test
+ public void testLength() {
+ fail("Not yet implemented");
+ }
+
+ /**
+ * Test method for {@link GpxData#getMinMaxTimeForTrack(GpxTrack)}.
+ */
+ @Test
+ public void testGetMinMaxTimeForTrack() {
+ fail("Not yet implemented");
+ }
+
+ /**
+ * Test method for {@link GpxData#getMinMaxTimeForAllTracks()}.
+ */
+ @Test
+ public void testGetMinMaxTimeForAllTracks() {
+ fail("Not yet implemented");
+ }
+
+ /**
+ * Test method for {@link GpxData#nearestPointOnTrack(org.openstreetmap.josm.data.coor.EastNorth, double)}.
+ */
+ @Test
+ public void testNearestPointOnTrack() {
+ fail("Not yet implemented");
+ }
+
+ /**
+ * Test method for {@link GpxData#getLinesIterable(boolean[])}.
+ */
+ @Test
+ public void testGetLinesIterable() {
+ fail("Not yet implemented");
+ }
+
+ /**
+ * Test method for {@link GpxData#resetEastNorthCache()}.
+ */
+ @Test
+ public void testResetEastNorthCache() {
+ fail("Not yet implemented");
+ }
+
+ /**
+ * Test method for {@link GpxData#getDataSources()}.
+ */
+ @Test
+ public void testGetDataSources() {
+ fail("Not yet implemented");
+ }
+
+ /**
+ * Test method for {@link GpxData#getDataSourceArea()}.
+ */
+ @Test
+ public void testGetDataSourceArea() {
+ fail("Not yet implemented");
+ }
+
+ /**
+ * Test method for {@link GpxData#getDataSourceBounds()}.
+ */
+ @Test
+ public void testGetDataSourceBounds() {
+ fail("Not yet implemented");
+ }
+
+ /**
+ * Test method for {@link GpxData#addChangeListener(GpxData.GpxDataChangeListener)}.
+ */
+ @Test
+ public void testAddChangeListener() {
+ fail("Not yet implemented");
+ }
+
+ /**
+ * Test method for {@link GpxData#addWeakChangeListener(GpxData.GpxDataChangeListener)}.
+ */
+ @Test
+ public void testAddWeakChangeListener() {
+ fail("Not yet implemented");
+ }
+
+ /**
+ * Test method for {@link GpxData#removeChangeListener(GpxData.GpxDataChangeListener)}.
+ */
+ @Test
+ public void testRemoveChangeListener() {
+ fail("Not yet implemented");
+ }
+
+ private static ImmutableGpxTrack emptyGpxTrack() {
+ return new ImmutableGpxTrack(Collections.emptyList(), Collections.emptyMap());
+ }
+
+ private static ImmutableGpxTrack singleWaypointGpxTrack() {
+ return new ImmutableGpxTrack(Collections.singleton(Collections.singleton(new WayPoint(LatLon.ZERO))), Collections.emptyMap());
+ }
+
/**
* Unit test of methods {@link GpxData#equals} and {@link GpxData#hashCode}.
@@ -28,5 +348,5 @@
public void testEqualsContract() {
EqualsVerifier.forClass(GpxData.class).usingGetClass()
- .withIgnoredFields("attr", "creator", "fromServer", "storageFile")
+ .withIgnoredFields("attr", "creator", "fromServer", "storageFile", "listeners")
.withPrefabValues(WayPoint.class, new WayPoint(LatLon.NORTH_POLE), new WayPoint(LatLon.SOUTH_POLE))
.verify();