Merge remote-tracking branch 'origin/gwt' into gwt

java/com.sap.sailing.domain/src/com/sap/sailing/domain/tracking/impl/DynamicTrackedRaceImpl.java

@@ -373,6 +373,7 @@ public class DynamicTrackedRaceImpl extends TrackedRaceImpl implements
     @Override
     public void setWindSource(WindSource windSource) {
         this.currentWindSource = windSource;
+        updated(/* timepoint */ null);
     }
 
 }

java/com.sap.sailing.domain/src/com/sap/sailing/domain/tracking/impl/TrackedRaceImpl.java

@@ -6,6 +6,7 @@ import java.util.Collections;
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.LinkedHashMap;
+import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
 import java.util.NavigableSet;
@@ -23,6 +24,7 @@ import com.sap.sailing.domain.base.CourseListener;
 import com.sap.sailing.domain.base.Leg;
 import com.sap.sailing.domain.base.RaceDefinition;
 import com.sap.sailing.domain.base.SpeedWithBearing;
+import com.sap.sailing.domain.base.Timed;
 import com.sap.sailing.domain.base.Waypoint;
 import com.sap.sailing.domain.base.impl.DouglasPeucker;
 import com.sap.sailing.domain.base.impl.KnotSpeedWithBearingImpl;
@@ -42,6 +44,7 @@ import com.sap.sailing.domain.common.WindSource;
 import com.sap.sailing.domain.common.impl.RacePlaceOrderImpl;
 import com.sap.sailing.domain.common.impl.Util;
 import com.sap.sailing.domain.common.impl.Util.Pair;
+import com.sap.sailing.domain.common.impl.Util.Triple;
 import com.sap.sailing.domain.tracking.GPSFix;
 import com.sap.sailing.domain.tracking.GPSFixMoving;
 import com.sap.sailing.domain.tracking.GPSFixTrack;
@@ -103,6 +106,12 @@ public abstract class TrackedRaceImpl implements TrackedRace, CourseListener {
      */
     private final Map<Waypoint, NavigableSet<MarkPassing>> markPassingsForWaypoint;
     
+    /**
+     * Values are the <code>from</code> and <code>to</code> time points between which the maneuvers have been previously
+     * computed. Clients wanting to know maneuvers for the competitor outside of this time interval need to (re-)compute them.
+     */
+    private final Map<Competitor, Triple<TimePoint, TimePoint, List<Maneuver>>> maneuverCache;
+    
     /**
      * A tracked race can maintain a number of sources for wind information from which a client
      * can select. As all intra-leg computations are done dynamically based on wind information,
@@ -126,6 +135,7 @@ public abstract class TrackedRaceImpl implements TrackedRace, CourseListener {
         this.race = race;
         this.millisecondsOverWhichToAverageSpeed = millisecondsOverWhichToAverageSpeed;
         this.startToNextMarkCacheInvalidationListeners = new HashMap<Buoy, TrackedRaceImpl.StartToNextMarkCacheInvalidationListener>();
+        this.maneuverCache = new HashMap<Competitor, Util.Triple<TimePoint,TimePoint,List<Maneuver>>>();
         this.buoyTracks = new HashMap<Buoy, GPSFixTrack<Buoy, GPSFix>>();
         int i = 0;
         for (Waypoint waypoint : race.getCourse().getWaypoints()) {
@@ -485,6 +495,9 @@ public abstract class TrackedRaceImpl implements TrackedRace, CourseListener {
         synchronized (competitorRankings) {
             competitorRankings.clear();
         }
+        synchronized (maneuverCache) {
+            maneuverCache.clear();
+        }
     }
 
     @Override
@@ -726,9 +739,53 @@ public abstract class TrackedRaceImpl implements TrackedRace, CourseListener {
         return douglasPeucker.approximate(maxDistance, from, to);
     }
     
+    /**
+     * Caches results in {@link #maneuverCache}. The cache is {@link #clearAllCaches() invalidated} by any
+     * {@link #updated(TimePoint) update}. Therefore, it is mainly useful for completed races. The cache tries to grow
+     * the time interval for which the maneuvers of a competitor have been computed. If <code>from</code> and
+     * <code>to</code> are within an interval already cached, the interval requested is
+     * {@link #extractInterval(TimePoint, TimePoint, List) extracted} from the maneuver list cached. Otherwise,
+     * the cached interval (empty in case no maneuvers were cached for <code>competitor</code> yet) is extended to
+     * include <code>from..to</code> by computing and caching the maneuvers for the new, extended interval. From the resulting
+     * extended maneuver list the interval requested is then {@link #extractInterval(TimePoint, TimePoint, List) extracted}.
+     */
     @Override
     public List<Maneuver> getManeuvers(Competitor competitor, TimePoint from, TimePoint to) throws NoWindException {
-        return detectManeuvers(competitor, approximate(competitor, getRace().getBoatClass().getMaximumDistanceForCourseApproximation(), from, to));
+        List<Maneuver> result;
+        Triple<TimePoint, TimePoint, List<Maneuver>> fromToAndManeuvers;
+        synchronized (maneuverCache) {
+            fromToAndManeuvers = maneuverCache.get(competitor);
+        }
+        if (fromToAndManeuvers != null && from.compareTo(fromToAndManeuvers.getA()) >= 0
+                && to.compareTo(fromToAndManeuvers.getB()) <= 0) {
+            // cached maneuver list contains interval requested
+            result = extractInterval(from, to, fromToAndManeuvers.getC());
+        } else {
+            TimePoint extendedFrom = fromToAndManeuvers == null ? from
+                    : from.compareTo(fromToAndManeuvers.getA()) <= 0 ? from : fromToAndManeuvers.getA();
+            TimePoint extendedTo = fromToAndManeuvers == null ? to : to.compareTo(fromToAndManeuvers.getB()) >= 0 ? to
+                    : fromToAndManeuvers.getB();
+            List<Maneuver> extendedResultForCache = detectManeuvers(competitor,
+                    approximate(competitor, getRace().getBoatClass().getMaximumDistanceForCourseApproximation(),
+                            extendedFrom, extendedTo));
+            result = extractInterval(from, to, extendedResultForCache);
+            synchronized (maneuverCache) {
+                maneuverCache.put(competitor, new Triple<TimePoint, TimePoint, List<Maneuver>>(extendedFrom,
+                        extendedTo, extendedResultForCache));
+            }
+        }
+        return result;
+    }
+
+    private <T extends Timed> List<T> extractInterval(TimePoint from, TimePoint to, List<T> listOfTimed) {
+        List<T> result;
+        result = new LinkedList<T>();
+        for (T timed : listOfTimed) {
+            if (timed.getTimePoint().compareTo(from) >= 0 && timed.getTimePoint().compareTo(to) <= 0) {
+                result.add(timed);
+            }
+        }
+        return result;
     }
     
     /**

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/leaderboard/AbstractChartPanel.java

@@ -101,14 +101,17 @@ public abstract class AbstractChartPanel<SettingsType extends ChartSettings> ext
     private final HashMap<String, String> markPassingBuoyName;
     private int width, height;
 
-    private DetailType dataToShow = DetailType.WINDWARD_DISTANCE_TO_OVERALL_LEADER;
+    private DetailType dataToShow;
     private AbsolutePanel loadingPanel;
     private final CompetitorSelectionProvider competitorSelectionProvider;
 
-    public AbstractChartPanel(SailingServiceAsync sailingService, CompetitorSelectionProvider competitorSelectionProvider,
-            RaceIdentifier[] races, final StringMessages stringMessages, int chartWidth, int chartHeight, ErrorReporter errorReporter) {
-    	width = chartWidth;
+    public AbstractChartPanel(SailingServiceAsync sailingService,
+            CompetitorSelectionProvider competitorSelectionProvider, RaceIdentifier[] races,
+            final StringMessages stringMessages, int chartWidth, int chartHeight, ErrorReporter errorReporter,
+            DetailType dataToShow) {
+        width = chartWidth;
     	height = chartHeight;
+    	this.dataToShow = dataToShow;
     	this.competitorSelectionProvider = competitorSelectionProvider;
     	competitorSelectionProvider.addCompetitorSelectionChangeListener(this);
     	this.errorReporter = errorReporter;

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/leaderboard/ChartPanel.java

@@ -6,6 +6,7 @@ import com.sap.sailing.gwt.ui.client.SailingServiceAsync;
 import com.sap.sailing.gwt.ui.client.StringMessages;
 import com.sap.sailing.gwt.ui.shared.components.Component;
 import com.sap.sailing.gwt.ui.shared.components.SettingsDialogComponent;
+import com.sap.sailing.server.api.DetailType;
 import com.sap.sailing.server.api.RaceIdentifier;
 
 /**
@@ -23,9 +24,10 @@ import com.sap.sailing.server.api.RaceIdentifier;
 public class ChartPanel extends AbstractChartPanel<ChartSettings> implements Component<ChartSettings> {
 
     public ChartPanel(SailingServiceAsync sailingService, CompetitorSelectionProvider competitorSelectionProvider,
-            RaceIdentifier[] races, StringMessages stringMessages, int chartWidth, int chartHeight,
-            ErrorReporter errorReporter) {
-        super(sailingService, competitorSelectionProvider, races, stringMessages, chartWidth, chartHeight, errorReporter);
+            RaceIdentifier[] races, DetailType dataToShow, StringMessages stringMessages, int chartWidth,
+            int chartHeight, ErrorReporter errorReporter) {
+        super(sailingService, competitorSelectionProvider, races, stringMessages, chartWidth, chartHeight,
+                errorReporter, dataToShow);
     }
 
     @Override

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/leaderboard/MultiChartPanel.java

@@ -6,6 +6,7 @@ import com.sap.sailing.gwt.ui.client.SailingServiceAsync;
 import com.sap.sailing.gwt.ui.client.StringMessages;
 import com.sap.sailing.gwt.ui.shared.components.Component;
 import com.sap.sailing.gwt.ui.shared.components.SettingsDialogComponent;
+import com.sap.sailing.server.api.DetailType;
 import com.sap.sailing.server.api.RaceIdentifier;
 
 /**
@@ -22,8 +23,10 @@ import com.sap.sailing.server.api.RaceIdentifier;
  */
 public class MultiChartPanel extends AbstractChartPanel<MultiChartSettings> implements Component<MultiChartSettings> {
     public MultiChartPanel(SailingServiceAsync sailingService, CompetitorSelectionProvider competitorSelectionProvider,
-            RaceIdentifier[] races, final StringMessages stringMessages, int chartWidth, int chartHeight, ErrorReporter errorReporter) {
-        super(sailingService, competitorSelectionProvider, races, stringMessages, chartWidth, chartHeight, errorReporter);
+            RaceIdentifier[] races, final StringMessages stringMessages, int chartWidth, int chartHeight,
+            ErrorReporter errorReporter) {
+        super(sailingService, competitorSelectionProvider, races, stringMessages, chartWidth, chartHeight,
+                errorReporter, /* show initially: */ DetailType.WINDWARD_DISTANCE_TO_OVERALL_LEADER);
     }
 
     @Override