Changeset 12156 in josm for trunk/src/org/openstreetmap/josm/data/gpx/GpxData.java

Timestamp:

2017-05-15T14:14:40+02:00 (9 years ago)

Author:

michael2402

Message:

See #14120: Don't make gpx tracks depend on the isChanged method, use a listener based approach instead.

File:

• trunk/src/org/openstreetmap/josm/data/gpx/GpxData.java (modified) (15 diffs)

trunk/src/org/openstreetmap/josm/data/gpx/GpxData.java

@@ -3 +3 @@
 
 import java.io.File;
+import java.text.MessageFormat;
+import java.util.AbstractCollection;
+import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
@@ -9 +12 @@
 import java.util.HashSet;
 import java.util.Iterator;
-import java.util.LinkedList;
 import java.util.Map;
 import java.util.NoSuchElementException;
 import java.util.Set;
+import java.util.stream.Stream;
 
 import org.openstreetmap.josm.Main;
@@ -19 +22 @@
 import org.openstreetmap.josm.data.DataSource;
 import org.openstreetmap.josm.data.coor.EastNorth;
+import org.openstreetmap.josm.data.gpx.GpxTrack.GpxTrackChangeListener;
+import org.openstreetmap.josm.tools.ListenerList;
 
 /**
@@ -35 +40 @@
     public String creator;
 
-    /** Tracks */
-    public final Collection<GpxTrack> tracks = new LinkedList<>();
-    /** Routes */
-    public final Collection<GpxRoute> routes = new LinkedList<>();
-    /** Waypoints */
-    public final Collection<WayPoint> waypoints = new LinkedList<>();
+    private ArrayList<GpxTrack> privateTracks = new ArrayList<>();
+    private ArrayList<GpxRoute> privateRoutes = new ArrayList<>();
+    private ArrayList<WayPoint> privateWaypoints = new ArrayList<>();
+    private final GpxTrackChangeListener proxy = e -> fireInvalidate();
+
+    /**
+     * Tracks. Access is discouraged, use {@link #getTracks()} to read.
+     * @see #getTracks()
+     */
+    public final Collection<GpxTrack> tracks = new ListeningCollection<GpxTrack>(privateTracks, this::fireInvalidate) {
+
+        @Override
+        protected void removed(GpxTrack cursor) {
+            cursor.removeListener(proxy);
+            super.removed(cursor);
+        }
+
+        @Override
+        protected void added(GpxTrack cursor) {
+            super.added(cursor);
+            cursor.addListener(proxy);
+        }
+    };
+
+    /**
+     * Routes. Access is discouraged, use {@link #getTracks()} to read.
+     * @see #getRoutes()
+     */
+    public final Collection<GpxRoute> routes = new ListeningCollection<>(privateRoutes, this::fireInvalidate);
+
+    /**
+     * Waypoints. Access is discouraged, use {@link #getTracks()} to read.
+     * @see #getWaypoints()
+     */
+    public final Collection<WayPoint> waypoints = new ListeningCollection<>(privateWaypoints, this::fireInvalidate);
 
     /**
@@ -49 +83 @@
      */
     public final Set<DataSource> dataSources = new HashSet<>();
+
+    private final ListenerList<GpxDataChangeListener> listeners = ListenerList.create();
 
     /**
@@ -72 +108 @@
             }
         }
-        tracks.addAll(other.tracks);
-        routes.addAll(other.routes);
-        waypoints.addAll(other.waypoints);
+        privateTracks.addAll(other.getTracks());
+        privateRoutes.addAll(other.getRoutes());
+        privateWaypoints.addAll(other.getWaypoints());
         dataSources.addAll(other.dataSources);
+        fireInvalidate();
+    }
+
+    /**
+     * Get all tracks contained in this data set.
+     * @return The tracks.
+     */
+    public Collection<GpxTrack> getTracks() {
+        return Collections.unmodifiableCollection(privateTracks);
+    }
+
+    /**
+     * Add a new track
+     * @param track The new track
+     * @since 12156
+     */
+    public void addTrack(GpxTrack track) {
+        if (privateTracks.contains(track)) {
+            throw new IllegalArgumentException(MessageFormat.format("The track was already added to this data: {0}", track));
+        }
+        privateTracks.add(track);
+        track.addListener(proxy);
+        fireInvalidate();
+    }
+
+    /**
+     * Remove a track
+     * @param track The old track
+     * @since 12156
+     */
+    public void removeTrack(GpxTrack track) {
+        if (!privateTracks.remove(track)) {
+            throw new IllegalArgumentException(MessageFormat.format("The track was not in this data: {0}", track));
+        }
+        track.removeListener(proxy);
+        fireInvalidate();
+    }
+
+    /**
+     * Gets the list of all routes defined in this data set.
+     * @return The routes
+     * @since 12156
+     */
+    public Collection<GpxRoute> getRoutes() {
+        return Collections.unmodifiableCollection(privateRoutes);
+    }
+
+    /**
+     * Add a new route
+     * @param route The new route
+     * @since 12156
+     */
+    public void addRoute(GpxRoute route) {
+        if (privateRoutes.contains(route)) {
+            throw new IllegalArgumentException(MessageFormat.format("The route was already added to this data: {0}", route));
+        }
+        privateRoutes.add(route);
+        fireInvalidate();
+    }
+
+    /**
+     * Remove a route
+     * @param route The old route
+     * @since 12156
+     */
+    public void removeRoute(GpxRoute route) {
+        if (!privateRoutes.remove(route)) {
+            throw new IllegalArgumentException(MessageFormat.format("The route was not in this data: {0}", route));
+        }
+        fireInvalidate();
+    }
+
+    /**
+     * Gets a list of all way points in this data set.
+     * @return The way points.
+     * @since 12156
+     */
+    public Collection<WayPoint> getWaypoints() {
+        return Collections.unmodifiableCollection(privateWaypoints);
+    }
+
+    /**
+     * Add a new waypoint
+     * @param waypoint The new waypoint
+     * @since 12156
+     */
+    public void addWaypoint(WayPoint waypoint) {
+        if (privateWaypoints.contains(waypoint)) {
+            throw new IllegalArgumentException(MessageFormat.format("The route was already added to this data: {0}", waypoint));
+        }
+        privateWaypoints.add(waypoint);
+        fireInvalidate();
+    }
+
+    /**
+     * Remove a waypoint
+     * @param waypoint The old waypoint
+     * @since 12156
+     */
+    public void removeWaypoint(WayPoint waypoint) {
+        if (!privateWaypoints.remove(waypoint)) {
+            throw new IllegalArgumentException(MessageFormat.format("The route was not in this data: {0}", waypoint));
+        }
+        fireInvalidate();
     }
 
@@ -83 +223 @@
      */
     public boolean hasTrackPoints() {
-        for (GpxTrack trk : tracks) {
-            for (GpxTrackSegment trkseg : trk.getSegments()) {
-                if (!trkseg.getWayPoints().isEmpty())
-                    return true;
-            }
-        }
-        return false;
+        return getTrackPoints().findAny().isPresent();
+    }
+
+    /**
+     * Gets a stream of all track points in the segments of the tracks of this data.
+     * @return The stream
+     * @see #getTracks()
+     * @see GpxTrack#getSegments()
+     * @see GpxTrackSegment#getWayPoints()
+     * @since 12156
+     */
+    public Stream<WayPoint> getTrackPoints() {
+        return getTracks().stream().flatMap(trk -> trk.getSegments().stream()).flatMap(trkseg -> trkseg.getWayPoints().stream());
     }
 
@@ -97 +243 @@
      */
     public boolean hasRoutePoints() {
-        for (GpxRoute rte : routes) {
-            if (!rte.routePoints.isEmpty())
-                return true;
-        }
-        return false;
+        return getRoutes().stream().anyMatch(rte -> !rte.routePoints.isEmpty());
     }
 
@@ -144 +286 @@
     public Bounds recalculateBounds() {
         Bounds bounds = null;
-        for (WayPoint wpt : waypoints) {
+        for (WayPoint wpt : getWaypoints()) {
             if (bounds == null) {
                 bounds = new Bounds(wpt.getCoor());
@@ -151 +293 @@
             }
         }
-        for (GpxRoute rte : routes) {
+        for (GpxRoute rte : getRoutes()) {
             for (WayPoint wpt : rte.routePoints) {
                 if (bounds == null) {
@@ -160 +302 @@
             }
         }
-        for (GpxTrack trk : tracks) {
+        for (GpxTrack trk : getTracks()) {
             Bounds trkBounds = trk.getBounds();
             if (trkBounds != null) {
@@ -178 +320 @@
      */
     public double length() {
-        double result = 0.0; // in meters
-
-        for (GpxTrack trk : tracks) {
-            result += trk.length();
-        }
-
-        return result;
+        return getTracks().stream().mapToDouble(GpxTrack::length).sum();
     }
 
@@ -261 +397 @@
         double py = p.north();
         double rx = 0.0, ry = 0.0, sx, sy, x, y;
-        if (tracks == null)
-            return null;
-        for (GpxTrack track : tracks) {
+        for (GpxTrack track : getTracks()) {
             for (GpxTrackSegment seg : track.getSegments()) {
                 WayPoint r = null;
@@ -352 +486 @@
      */
     public void resetEastNorthCache() {
-        if (waypoints != null) {
-            for (WayPoint wp : waypoints) {
+        getWaypoints().forEach(WayPoint::invalidateEastNorthCache);
+        getTrackPoints().forEach(WayPoint::invalidateEastNorthCache);
+        for (GpxRoute route: getRoutes()) {
+            if (route.routePoints == null) {
+                continue;
+            }
+            for (WayPoint wp: route.routePoints) {
                 wp.invalidateEastNorthCache();
-            }
-        }
-        if (tracks != null) {
-            for (GpxTrack track: tracks) {
-                for (GpxTrackSegment segment: track.getSegments()) {
-                    for (WayPoint wp: segment.getWayPoints()) {
-                        wp.invalidateEastNorthCache();
-                    }
-                }
-            }
-        }
-        if (routes != null) {
-            for (GpxRoute route: routes) {
-                if (route.routePoints == null) {
-                    continue;
-                }
-                for (WayPoint wp: route.routePoints) {
-                    wp.invalidateEastNorthCache();
-                }
             }
         }
@@ -498 +618 @@
         return true;
     }
+
+    /**
+     * Adds a listener that gets called whenever the data changed.
+     * @param listener The listener
+     * @since 12156
+     */
+    public void addChangeListener(GpxDataChangeListener listener) {
+        listeners.addListener(listener);
+    }
+
+    /**
+     * Adds a listener that gets called whenever the data changed. It is added with a weak link
+     * @param listener The listener
+     */
+    public void addWeakChangeListener(GpxDataChangeListener listener) {
+        listeners.addWeakListener(listener);
+    }
+
+    /**
+     * Removes a listener that gets called whenever the data changed.
+     * @param listener The listener
+     * @since 12156
+     */
+    public void removeChangeListener(GpxDataChangeListener listener) {
+        listeners.removeListener(listener);
+    }
+
+    private void fireInvalidate() {
+        GpxDataChangeEvent e = new GpxDataChangeEvent(this);
+        listeners.fireEvent(l -> l.gpxDataChanged(e));
+    }
+
+    /**
+     * This is a proxy of a collection that notifies a listener on every collection change
+     * @author Michael Zangl
+     *
+     * @param <T> The entry type
+     * @since 12156
+     */
+    private static class ListeningCollection<T> extends AbstractCollection<T> {
+        private final ArrayList<T> base;
+        private final Runnable runOnModification;
+
+        ListeningCollection(ArrayList<T> base, Runnable runOnModification) {
+            this.base = base;
+            this.runOnModification = runOnModification;
+        }
+
+        @Override
+        public Iterator<T> iterator() {
+            Iterator<T> it = base.iterator();
+            return new Iterator<T>() {
+                private T cursor;
+
+                @Override
+                public boolean hasNext() {
+                    return it.hasNext();
+                }
+
+                @Override
+                public T next() {
+                    cursor = it.next();
+                    return cursor;
+                }
+
+                @Override
+                public void remove() {
+                    if (cursor != null) {
+                        removed(cursor);
+                        cursor = null;
+                    }
+                    it.remove();
+                }
+            };
+        }
+
+        @Override
+        public int size() {
+            return base.size();
+        }
+
+        @Override
+        public boolean remove(Object o) {
+            boolean remove = base.remove(o);
+            if (remove) {
+                removed((T) o);
+            }
+            return remove;
+        }
+
+        @Override
+        public boolean add(T e) {
+            boolean add = base.add(e);
+            added(e);
+            return add;
+        }
+
+        protected void removed(T cursor) {
+            runOnModification.run();
+        }
+
+        protected void added(T cursor) {
+            runOnModification.run();
+        }
+    }
+
+    /**
+     * A listener that listens to GPX data changes.
+     * @author Michael Zangl
+     * @since 12156
+     */
+    @FunctionalInterface
+    public interface GpxDataChangeListener {
+        /**
+         * Called when the gpx data changed.
+         * @param e The event
+         */
+        void gpxDataChanged(GpxDataChangeEvent e);
+    }
+
+    /**
+     * A data change event in any of the gpx data.
+     * @author Michael Zangl
+     * @since 12156
+     */
+    public static class GpxDataChangeEvent {
+        private final GpxData source;
+
+        GpxDataChangeEvent(GpxData source) {
+            super();
+            this.source = source;
+        }
+
+        /**
+         * Get the data that was changed.
+         * @return The data.
+         */
+        public GpxData getSource() {
+            return source;
+        }
+    }
 }