refactored listener interfaces

java/com.sap.sailing.domain.test/src/com/sap/sailing/domain/test/FetchTracksAndStoreLocallyTest.java

@@ -16,11 +16,10 @@ import com.sap.sailing.domain.tracking.DynamicTrackedEvent;
 import com.sap.sailing.domain.tracking.DynamicTrackedRace;
 import com.sap.sailing.domain.tracking.GPSFix;
 import com.sap.sailing.domain.tracking.GPSFixMoving;
-import com.sap.sailing.domain.tracking.MarkPassing;
 import com.sap.sailing.domain.tracking.RaceChangeListener;
 import com.sap.sailing.domain.tracking.RaceListener;
 import com.sap.sailing.domain.tracking.TrackedRace;
-import com.sap.sailing.domain.tracking.Wind;
+import com.sap.sailing.domain.tracking.impl.AbstractRaceChangeListener;
 import com.sap.sailing.domain.tracking.impl.DynamicGPSFixMovingTrackImpl;
 import com.sap.sailing.domain.tracking.impl.GPSFixMovingImpl;
 import com.sap.sailing.domain.tractracadapter.ReceiverType;
@@ -51,9 +50,9 @@ public class FetchTracksAndStoreLocallyTest extends OnlineTracTracBasedTest {
      */
     private void setUp(String eventName, String raceId) throws MalformedURLException, IOException, InterruptedException, URISyntaxException {
         super.setUpWithoutLaunchingController(eventName, raceId);
-        final RaceChangeListener<Competitor> positionListener = new RaceChangeListener<Competitor>() {
+        final RaceChangeListener positionListener = new AbstractRaceChangeListener() {
             @Override
-            public void gpsFixReceived(GPSFix fix, Competitor competitor) {
+            public void competitorPositionChanged(GPSFix fix, Competitor competitor) {
                 DynamicGPSFixTrack<Competitor, GPSFixMoving> track = tracks.get(competitor);
                 if (track == null) {
                     track = new DynamicGPSFixMovingTrackImpl<Competitor>(competitor, /* millisecondsOverWhichToAverage */ 40000);
@@ -61,22 +60,6 @@ public class FetchTracksAndStoreLocallyTest extends OnlineTracTracBasedTest {
                 }
                 track.addGPSFix((GPSFixMoving) fix);
             }
-            @Override
-            public void markPassingReceived(MarkPassing oldMarkPassing, MarkPassing markPassing) {
-            }
-            @Override
-            public void windDataReceived(Wind wind) {
-            }
-            @Override
-            public void windDataRemoved(Wind wind) {
-            }
-            @Override
-            public void speedAveragingChanged(long oldMillisecondsOverWhichToAverage, long newMillisecondsOverWhichToAverage) {
-            }
-            @Override
-            public void windAveragingChanged(long oldMillisecondsOverWhichToAverage,
-                    long newMillisecondsOverWhichToAverage) {
-            }
         };
         DynamicTrackedEvent trackedEvent = getTrackedEvent();
         trackedEvent.addRaceListener(new RaceListener() {

java/com.sap.sailing.domain.test/src/com/sap/sailing/domain/test/ReceiveTrackingDataTest.java

@@ -18,11 +18,10 @@ import com.sap.sailing.domain.tracking.DynamicRaceDefinitionSet;
 import com.sap.sailing.domain.tracking.DynamicTrackedEvent;
 import com.sap.sailing.domain.tracking.DynamicTrackedRace;
 import com.sap.sailing.domain.tracking.GPSFix;
-import com.sap.sailing.domain.tracking.MarkPassing;
 import com.sap.sailing.domain.tracking.RaceChangeListener;
 import com.sap.sailing.domain.tracking.RaceListener;
 import com.sap.sailing.domain.tracking.TrackedRace;
-import com.sap.sailing.domain.tracking.Wind;
+import com.sap.sailing.domain.tracking.impl.AbstractRaceChangeListener;
 import com.sap.sailing.domain.tracking.impl.DynamicTrackedEventImpl;
 import com.sap.sailing.domain.tracking.impl.EmptyWindStore;
 import com.sap.sailing.domain.tracking.impl.GPSFixMovingImpl;
@@ -48,11 +47,11 @@ public class ReceiveTrackingDataTest extends AbstractTracTracLiveTest {
     @Before
     public void setupListener() {
         final DomainFactory domainFactory = DomainFactory.INSTANCE;
-        final RaceChangeListener<Competitor> positionListener = new RaceChangeListener<Competitor>() {
+        final RaceChangeListener positionListener = new AbstractRaceChangeListener() {
             private boolean first = true;
             
             @Override
-            public void gpsFixReceived(GPSFix fix, Competitor competitor) {
+            public void competitorPositionChanged(GPSFix fix, Competitor competitor) {
                 System.out.println("Received fix "+fix);
                 synchronized (semaphor) {
                     if (first) {
@@ -63,22 +62,6 @@ public class ReceiveTrackingDataTest extends AbstractTracTracLiveTest {
                     semaphor.notifyAll();
                 }
             }
-            @Override
-            public void markPassingReceived(MarkPassing oldMarkPassing, MarkPassing markPassing) {
-            }
-            @Override
-            public void windDataReceived(Wind wind) {
-            }
-            @Override
-            public void windDataRemoved(Wind wind) {
-            }
-            @Override
-            public void speedAveragingChanged(long oldMillisecondsOverWhichToAverage, long newMillisecondsOverWhichToAverage) {
-            }
-            @Override
-            public void windAveragingChanged(long oldMillisecondsOverWhichToAverage,
-                    long newMillisecondsOverWhichToAverage) {
-            }
         };
         List<TypeController> listeners = new ArrayList<TypeController>();
         Event event = domainFactory.getOrCreateEvent(getEvent());

java/com.sap.sailing.domain.test/src/com/sap/sailing/domain/test/mock/MockedTrackedRace.java

@@ -205,7 +205,7 @@ public class MockedTrackedRace implements DynamicTrackedRace {
     }
 
     @Override
-    public void addListener(RaceChangeListener<Competitor> listener) {
+    public void addListener(RaceChangeListener listener) {
         // TODO Auto-generated method stub
         
     }

java/com.sap.sailing.domain/src/com/sap/sailing/domain/base/Course.java

@@ -49,4 +49,7 @@ public interface Course extends Named {
      * had been used.
      */
     void update(List<ControlPoint> newControlPoints, DomainFactory baseDomainFactory) throws PatchFailedException;
+
+    Iterable<Leg> getLegsAdjacentTo(Buoy buoy);
+
 }

java/com.sap.sailing.domain/src/com/sap/sailing/domain/base/impl/CourseImpl.java

@@ -12,6 +12,7 @@ import java.util.Set;
 import java.util.logging.Level;
 import java.util.logging.Logger;
 
+import com.sap.sailing.domain.base.Buoy;
 import com.sap.sailing.domain.base.ControlPoint;
 import com.sap.sailing.domain.base.Course;
 import com.sap.sailing.domain.base.CourseListener;
@@ -156,6 +157,46 @@ public class CourseImpl extends NamedImpl implements Course {
         }
         return result;
     }
+    
+    private Set<ControlPoint> getControlPoints() {
+        Set<ControlPoint> result = new HashSet<ControlPoint>();
+        for (Waypoint waypoint : getWaypoints()) {
+            result.add(waypoint.getControlPoint());
+        }
+        return result;
+    }
+    
+    private ControlPoint getControlPointForBuoy(Buoy buoy) {
+        for (ControlPoint controlPoint : getControlPoints()) {
+            for (Buoy controlPointBuoy : controlPoint.getBuoys()) {
+                if (buoy == controlPointBuoy) {
+                    return controlPoint;
+                }
+            }
+        }
+        return null;
+    }
+    
+    @Override
+    public Iterable<Leg> getLegsAdjacentTo(Buoy buoy) {
+        Set<Leg> result = new HashSet<Leg>();
+        ControlPoint controlPointForBuoy = getControlPointForBuoy(buoy);
+        if (controlPointForBuoy != null) {
+            boolean first = true;
+            for (Leg leg : getLegs()) {
+                if (first) {
+                    if (leg.getFrom().getControlPoint() == controlPointForBuoy) {
+                        result.add(leg);
+                    }
+                    first = false;
+                }
+                if (leg.getTo().getControlPoint() == controlPointForBuoy) {
+                    result.add(leg);
+                }
+            }
+        }
+        return result;
+    }
 
     @Override
     public synchronized Waypoint getWaypointForControlPoint(ControlPoint controlPoint, int start) {

java/com.sap.sailing.domain/src/com/sap/sailing/domain/tracking/GPSFixTrack.java

@@ -22,7 +22,7 @@ public interface GPSFixTrack<ItemType, FixType extends GPSFix> extends Track<Fix
     /**
      * A listener is notified whenever a new fix is added to this track
      */
-    void addListener(RaceChangeListener<ItemType> listener);
+    void addListener(GPSTrackListener<ItemType> listener);
     
     ItemType getTrackedItem();
 

java/com.sap.sailing.domain/src/com/sap/sailing/domain/tracking/GPSTrackListener.java

@@ -0,0 +1,7 @@
+package com.sap.sailing.domain.tracking;
+
+public interface GPSTrackListener<ItemType> {
+    void gpsFixReceived(GPSFix fix, ItemType item);
+
+    void speedAveragingChanged(long oldMillisecondsOverWhichToAverage, long newMillisecondsOverWhichToAverage);
+}

java/com.sap.sailing.domain/src/com/sap/sailing/domain/tracking/RaceChangeListener.java

@@ -1,9 +1,14 @@
 package com.sap.sailing.domain.tracking;
 
+import com.sap.sailing.domain.base.Buoy;
+import com.sap.sailing.domain.base.Competitor;
 
-public interface RaceChangeListener<ItemType> extends WindListener {
-    void gpsFixReceived(GPSFix fix, ItemType competitor);
 
+public interface RaceChangeListener extends WindListener {
+    void competitorPositionChanged(GPSFix fix, Competitor competitor);
+    
+    void buoyPositionChanged(GPSFix fix, Buoy buoy);
+    
     /**
      * Invoked after the mark passings have been updated in the {@link TrackedRace}.
      * 

java/com.sap.sailing.domain/src/com/sap/sailing/domain/tracking/TrackedRace.java

@@ -258,6 +258,6 @@ public interface TrackedRace {
      */
     boolean raceIsKnownToStartUpwind();
     
-    void addListener(RaceChangeListener<Competitor> listener);
+    void addListener(RaceChangeListener listener);
     
 }

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

@@ -0,0 +1,40 @@
+package com.sap.sailing.domain.tracking.impl;
+
+import com.sap.sailing.domain.base.Buoy;
+import com.sap.sailing.domain.base.Competitor;
+import com.sap.sailing.domain.tracking.GPSFix;
+import com.sap.sailing.domain.tracking.MarkPassing;
+import com.sap.sailing.domain.tracking.RaceChangeListener;
+import com.sap.sailing.domain.tracking.Wind;
+
+public abstract class AbstractRaceChangeListener implements RaceChangeListener {
+
+    @Override
+    public void buoyPositionChanged(GPSFix fix, Buoy buoy) {
+    }
+
+    @Override
+    public void windDataReceived(Wind wind) {
+    }
+
+    @Override
+    public void windDataRemoved(Wind wind) {
+    }
+
+    @Override
+    public void windAveragingChanged(long oldMillisecondsOverWhichToAverage, long newMillisecondsOverWhichToAverage) {
+    }
+
+    @Override
+    public void competitorPositionChanged(GPSFix fix, Competitor item) {
+    }
+
+    @Override
+    public void markPassingReceived(MarkPassing oldMarkPassing, MarkPassing markPassing) {
+    }
+
+    @Override
+    public void speedAveragingChanged(long oldMillisecondsOverWhichToAverage, long newMillisecondsOverWhichToAverage) {
+    }
+
+}

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

@@ -3,7 +3,7 @@ package com.sap.sailing.domain.tracking.impl;
 import com.sap.sailing.domain.base.Speed;
 import com.sap.sailing.domain.tracking.DynamicGPSFixTrack;
 import com.sap.sailing.domain.tracking.GPSFix;
-import com.sap.sailing.domain.tracking.RaceChangeListener;
+import com.sap.sailing.domain.tracking.GPSTrackListener;
 
 public class DynamicTrackImpl<ItemType, FixType extends GPSFix> extends
         GPSFixTrackImpl<ItemType, FixType> implements DynamicGPSFixTrack<ItemType, FixType> {
@@ -21,9 +21,9 @@ public class DynamicTrackImpl<ItemType, FixType extends GPSFix> extends
             getInternalRawFixes().add(gpsFix);
             invalidateValidityCaches(gpsFix);
         }
-        Iterable<RaceChangeListener<ItemType>> listeners = getListeners();
+        Iterable<GPSTrackListener<ItemType>> listeners = getListeners();
         synchronized (listeners) {
-            for (RaceChangeListener<ItemType> listener : listeners) {
+            for (GPSTrackListener<ItemType> listener : listeners) {
                 listener.gpsFixReceived(gpsFix, getTrackedItem());
             }
         }
@@ -33,9 +33,9 @@ public class DynamicTrackImpl<ItemType, FixType extends GPSFix> extends
     public void setMillisecondsOverWhichToAverage(long millisecondsOverWhichToAverage) {
         long oldMillis = getMillisecondsOverWhichToAverage();
         super.setMillisecondsOverWhichToAverage(millisecondsOverWhichToAverage);
-        Iterable<RaceChangeListener<ItemType>> listeners = getListeners();
+        Iterable<GPSTrackListener<ItemType>> listeners = getListeners();
         synchronized (listeners) {
-            for (RaceChangeListener<ItemType> listener : listeners) {
+            for (GPSTrackListener<ItemType> listener : listeners) {
                 listener.speedAveragingChanged(oldMillis, millisecondsOverWhichToAverage);
             }
         }

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

@@ -24,19 +24,21 @@ import com.sap.sailing.domain.tracking.DynamicTrackedEvent;
 import com.sap.sailing.domain.tracking.DynamicTrackedRace;
 import com.sap.sailing.domain.tracking.GPSFix;
 import com.sap.sailing.domain.tracking.GPSFixMoving;
+import com.sap.sailing.domain.tracking.GPSTrackListener;
 import com.sap.sailing.domain.tracking.MarkPassing;
 import com.sap.sailing.domain.tracking.RaceChangeListener;
 import com.sap.sailing.domain.tracking.TrackedEvent;
 import com.sap.sailing.domain.tracking.TrackedLeg;
 import com.sap.sailing.domain.tracking.Wind;
+import com.sap.sailing.domain.tracking.WindListener;
 import com.sap.sailing.domain.tracking.WindStore;
 import com.sap.sailing.domain.tracking.WindTrack;
 
 public class DynamicTrackedRaceImpl extends TrackedRaceImpl implements
-        DynamicTrackedRace, RaceChangeListener<Competitor> {
+        DynamicTrackedRace, WindListener, GPSTrackListener<Competitor> {
     private static final Logger logger = Logger.getLogger(DynamicTrackedRaceImpl.class.getName());
     
-    private Set<RaceChangeListener<Competitor>> listeners;
+    private Set<RaceChangeListener> listeners;
     
     private boolean raceIsKnownToStartUpwind;
     
@@ -99,25 +101,49 @@ public class DynamicTrackedRaceImpl extends TrackedRaceImpl implements
     
     @Override
     public DynamicGPSFixTrack<Buoy, GPSFix> getOrCreateTrack(Buoy buoy) {
-        return (DynamicGPSFixTrack<Buoy, GPSFix>) super.getOrCreateTrack(buoy);
+        final DynamicGPSFixTrack<Buoy, GPSFix> finalResult = (DynamicGPSFixTrack<Buoy, GPSFix>) super.getOrCreateTrack(buoy);
+        finalResult.addListener(new GPSTrackListener<Buoy>() {
+            @Override
+            public void gpsFixReceived(GPSFix fix, Buoy buoy) {
+                notifyListeners(fix, buoy);
+            }
+
+            @Override
+            public void speedAveragingChanged(long oldMillisecondsOverWhichToAverage,
+                    long newMillisecondsOverWhichToAverage) {
+                // nobody can currently listen for the change of the buoy speed averaging because buoy speed is not a value used
+            }
+        });
+        return finalResult;
     }
     
-    private synchronized Set<RaceChangeListener<Competitor>> getListeners() {
+    private synchronized Set<RaceChangeListener> getListeners() {
         if (listeners == null) {
-            listeners = new HashSet<RaceChangeListener<Competitor>>();
+            listeners = new HashSet<RaceChangeListener>();
         }
         return listeners;
     }
 
     @Override
-    public synchronized void addListener(RaceChangeListener<Competitor> listener) {
+    public synchronized void addListener(RaceChangeListener listener) {
         getListeners().add(listener);
     }
 
-    private void notifyListeners(GPSFix fix, Competitor competitor) {
-        for (RaceChangeListener<Competitor> listener : getListeners()) {
+    private void notifyListeners(GPSFix fix, Buoy buoy) {
+        for (RaceChangeListener listener : getListeners()) {
             try {
-                listener.gpsFixReceived(fix, competitor);
+                listener.buoyPositionChanged(fix, buoy);
+            } catch (Throwable t) {
+                logger.log(Level.SEVERE, "RaceChangeListener "+listener+" threw exception "+t.getMessage());
+                logger.throwing(DynamicTrackedRaceImpl.class.getName(), "notifyListeners(GPSFix, Competitor)", t);
+            }
+        }
+    }
+
+    private void notifyListeners(GPSFix fix, Competitor competitor) {
+        for (RaceChangeListener listener : getListeners()) {
+            try {
+                listener.competitorPositionChanged(fix, competitor);
             } catch (Throwable t) {
                 logger.log(Level.SEVERE, "RaceChangeListener "+listener+" threw exception "+t.getMessage());
                 logger.throwing(DynamicTrackedRaceImpl.class.getName(), "notifyListeners(GPSFix, Competitor)", t);
@@ -126,7 +152,7 @@ public class DynamicTrackedRaceImpl extends TrackedRaceImpl implements
     }
 
     private void notifyListeners(Wind wind) {
-        for (RaceChangeListener<Competitor> listener : getListeners()) {
+        for (RaceChangeListener listener : getListeners()) {
             try {
                 listener.windDataReceived(wind);
             } catch (Throwable t) {
@@ -137,7 +163,7 @@ public class DynamicTrackedRaceImpl extends TrackedRaceImpl implements
     }
 
     private void notifyListenersSpeedAveragingChanged(long oldMillisecondsOverWhichToAverageSpeed, long newMillisecondsOverWhichToAverageSpeed) {
-        for (RaceChangeListener<Competitor> listener : getListeners()) {
+        for (RaceChangeListener listener : getListeners()) {
             try {
                 listener.speedAveragingChanged(oldMillisecondsOverWhichToAverageSpeed, newMillisecondsOverWhichToAverageSpeed);
             } catch (Throwable t) {
@@ -148,7 +174,7 @@ public class DynamicTrackedRaceImpl extends TrackedRaceImpl implements
     }
 
     private void notifyListenersWindAveragingChanged(long oldMillisecondsOverWhichToAverageWind, long newMillisecondsOverWhichToAverageWind) {
-        for (RaceChangeListener<Competitor> listener : getListeners()) {
+        for (RaceChangeListener listener : getListeners()) {
             try {
                 listener.windAveragingChanged(oldMillisecondsOverWhichToAverageWind, newMillisecondsOverWhichToAverageWind);
             } catch (Throwable t) {
@@ -159,7 +185,7 @@ public class DynamicTrackedRaceImpl extends TrackedRaceImpl implements
     }
 
     private void notifyListenersWindRemoved(Wind wind) {
-        for (RaceChangeListener<Competitor> listener : getListeners()) {
+        for (RaceChangeListener listener : getListeners()) {
             try {
                 listener.windDataRemoved(wind);
             } catch (Throwable t) {
@@ -170,7 +196,7 @@ public class DynamicTrackedRaceImpl extends TrackedRaceImpl implements
     }
 
     private void notifyListeners(MarkPassing oldMarkPassing, MarkPassing markPassing) {
-        for (RaceChangeListener<Competitor> listener : getListeners()) {
+        for (RaceChangeListener listener : getListeners()) {
             try {
                 listener.markPassingReceived(oldMarkPassing, markPassing);
             } catch (Throwable t) {
@@ -257,11 +283,6 @@ public class DynamicTrackedRaceImpl extends TrackedRaceImpl implements
         notifyListenersWindAveragingChanged(oldMillisecondsOverWhichToAverage, newMillisecondsOverWhichToAverage);        
     }
 
-    @Override
-    public void markPassingReceived(MarkPassing oldMarkPassing, MarkPassing markPassing) {
-        notifyListeners(oldMarkPassing, markPassing);
-    }
-
     @Override
     public void windDataReceived(Wind wind) {
         notifyListeners(wind);

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

@@ -21,7 +21,7 @@ import com.sap.sailing.domain.base.impl.NauticalMileDistance;
 import com.sap.sailing.domain.tracking.GPSFix;
 import com.sap.sailing.domain.tracking.GPSFixMoving;
 import com.sap.sailing.domain.tracking.GPSFixTrack;
-import com.sap.sailing.domain.tracking.RaceChangeListener;
+import com.sap.sailing.domain.tracking.GPSTrackListener;
 import com.sap.sailing.domain.tracking.WithValidityCache;
 
 public class GPSFixTrackImpl<ItemType, FixType extends GPSFix> extends TrackImpl<FixType> implements GPSFixTrack<ItemType, FixType> {
@@ -31,7 +31,7 @@ public class GPSFixTrackImpl<ItemType, FixType extends GPSFix> extends TrackImpl
     private final ItemType trackedItem;
     private long millisecondsOverWhichToAverage;
 
-    private final Set<RaceChangeListener<ItemType>> listeners;
+    private final Set<GPSTrackListener<ItemType>> listeners;
     
     public GPSFixTrackImpl(ItemType trackedItem, long millisecondsOverWhichToAverage) {
         this(trackedItem, millisecondsOverWhichToAverage, DEFAULT_MAX_SPEED_FOR_SMOOTHING);
@@ -42,11 +42,11 @@ public class GPSFixTrackImpl<ItemType, FixType extends GPSFix> extends TrackImpl
         this.trackedItem = trackedItem;
         this.millisecondsOverWhichToAverage = millisecondsOverWhichToAverage;
         this.maxSpeedForSmoothening = maxSpeedForSmoothening;
-        this.listeners = new HashSet<RaceChangeListener<ItemType>>();
+        this.listeners = new HashSet<GPSTrackListener<ItemType>>();
     }
 
     @Override
-    public void addListener(RaceChangeListener<ItemType> listener) {
+    public void addListener(GPSTrackListener<ItemType> listener) {
         synchronized (listeners) {
             listeners.add(listener);
         }
@@ -57,7 +57,7 @@ public class GPSFixTrackImpl<ItemType, FixType extends GPSFix> extends TrackImpl
      * {@link ConcurrentModificationException}s because listeners may be added on the fly, and this object will
      * synchronize on the listeners collection before adding on.
      */
-    protected Iterable<RaceChangeListener<ItemType>> getListeners() {
+    protected Iterable<GPSTrackListener<ItemType>> getListeners() {
         return listeners;
     }
 

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

@@ -4,6 +4,7 @@ import java.util.Arrays;
 import java.util.Iterator;
 import java.util.NavigableSet;
 
+import com.sap.sailing.domain.base.Buoy;
 import com.sap.sailing.domain.base.Competitor;
 import com.sap.sailing.domain.base.Position;
 import com.sap.sailing.domain.base.TimePoint;
@@ -45,7 +46,7 @@ import com.sap.sailing.util.impl.ArrayListNavigableSet;
  * @author Axel Uhl (d043530)
  * 
  */
-public class TrackBasedEstimationWindTrackImpl extends WindTrackImpl implements RaceChangeListener<Competitor> {
+public class TrackBasedEstimationWindTrackImpl extends WindTrackImpl implements RaceChangeListener {
     private final EstimatedWindFixesAsNavigableSet virtualInternalRawFixes;
 
     private final TrackedRace trackedRace;
@@ -197,11 +198,11 @@ public class TrackBasedEstimationWindTrackImpl extends WindTrackImpl implements
 
     @Override
     public void windAveragingChanged(long oldMillisecondsOverWhichToAverage, long newMillisecondsOverWhichToAverage) {
-        // we ignore wind updates for cache invalidations; however, TODO we'd like to invalidate in case a leg changes its type
+        clearCache();
     }
 
     @Override
-    public void gpsFixReceived(GPSFix fix, Competitor competitor) {
+    public void competitorPositionChanged(GPSFix fix, Competitor competitor) {
         long averagingInterval = trackedRace.getMillisecondsOverWhichToAverageSpeed();
         Wind startOfInvalidation = getDummyFix(new MillisecondsTimePoint(fix.getTimePoint().asMillis()-averagingInterval));
         TimePoint endOfInvalidation = new MillisecondsTimePoint(fix.getTimePoint().asMillis()+averagingInterval);
@@ -230,4 +231,9 @@ public class TrackBasedEstimationWindTrackImpl extends WindTrackImpl implements
         clearCache();
     }
 
+    @Override
+    public void buoyPositionChanged(GPSFix fix, Buoy buoy) {
+        // TODO invalidate cache around fix's time point
+    }
+
 }

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

@@ -26,7 +26,7 @@ import com.sap.sailing.domain.tracking.TrackedLegOfCompetitor;
 import com.sap.sailing.domain.tracking.TrackedRace;
 import com.sap.sailing.domain.tracking.Wind;
 
-public class TrackedLegImpl implements TrackedLeg, RaceChangeListener<Competitor> {
+public class TrackedLegImpl implements TrackedLeg, RaceChangeListener {
     private final static Logger logger = Logger.getLogger(TrackedLegImpl.class.getName());
     
     private final static double UPWIND_DOWNWIND_TOLERANCE_IN_DEG = 40; // TracTrac does 22.5, Marcus Baur suggest 40
@@ -131,7 +131,7 @@ public class TrackedLegImpl implements TrackedLeg, RaceChangeListener<Competitor
             throw new NoWindException("Need to know wind direction to determine whether leg "+getLeg()+
                     " is an upwind or downwind leg");
         }
-        // check for all combinations of start/end waypoint buoys:
+        // check for all combinations of start/end waypoint buoys and respond for the first that's within bounds
         for (Buoy startBuoy : getLeg().getFrom().getBuoys()) {
             Position startBuoyPos = getTrackedRace().getOrCreateTrack(startBuoy).getEstimatedPosition(at, false);
             for (Buoy endBuoy : getLeg().getTo().getBuoys()) {
@@ -178,7 +178,7 @@ public class TrackedLegImpl implements TrackedLeg, RaceChangeListener<Competitor
     }
 
     @Override
-    public void gpsFixReceived(GPSFix fix, Competitor competitor) {
+    public void competitorPositionChanged(GPSFix fix, Competitor competitor) {
         clearCaches();
     }
 
@@ -197,6 +197,11 @@ public class TrackedLegImpl implements TrackedLeg, RaceChangeListener<Competitor
         clearCaches();
     }
 
+    @Override
+    public void buoyPositionChanged(GPSFix fix, Buoy buoy) {
+        clearCaches();
+    }
+
     @Override
     public void windDataReceived(Wind wind) {
         clearCaches();

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

@@ -32,15 +32,15 @@ import com.sap.sailing.domain.common.NoWindError;
 import com.sap.sailing.domain.common.NoWindException;
 import com.sap.sailing.domain.common.Tack;
 import com.sap.sailing.domain.common.Util;
-import com.sap.sailing.domain.common.WindSource;
 import com.sap.sailing.domain.common.Util.Pair;
+import com.sap.sailing.domain.common.WindSource;
 import com.sap.sailing.domain.tracking.GPSFix;
 import com.sap.sailing.domain.tracking.GPSFixMoving;
 import com.sap.sailing.domain.tracking.GPSFixTrack;
+import com.sap.sailing.domain.tracking.GPSTrackListener;
 import com.sap.sailing.domain.tracking.Maneuver;
 import com.sap.sailing.domain.tracking.Maneuver.Type;
 import com.sap.sailing.domain.tracking.MarkPassing;
-import com.sap.sailing.domain.tracking.RaceChangeListener;
 import com.sap.sailing.domain.tracking.TrackedEvent;
 import com.sap.sailing.domain.tracking.TrackedLeg;
 import com.sap.sailing.domain.tracking.TrackedLegOfCompetitor;
@@ -360,7 +360,20 @@ public abstract class TrackedRaceImpl implements TrackedRace, CourseListener {
         synchronized (buoyTracks) {
             GPSFixTrack<Buoy, GPSFix> result = buoyTracks.get(buoy);
             if (result == null) {
-                result = new DynamicGPSFixTrackImpl<Buoy>(buoy, millisecondsOverWhichToAverageSpeed);
+                final GPSFixTrack<Buoy, GPSFix> finalResult = new DynamicGPSFixTrackImpl<Buoy>(buoy, millisecondsOverWhichToAverageSpeed);
+                result = finalResult;
+                result.addListener(new GPSTrackListener<Buoy>() {
+                    @Override
+                    public void gpsFixReceived(GPSFix fix, Buoy buoy) {
+                        // TODO notify listeners
+                    }
+
+                    @Override
+                    public void speedAveragingChanged(long oldMillisecondsOverWhichToAverage,
+                            long newMillisecondsOverWhichToAverage) {
+                        // TODO notify listeners
+                    }
+                });
                 buoyTracks.put(buoy, result);
             }
             return result;
@@ -418,6 +431,7 @@ public abstract class TrackedRaceImpl implements TrackedRace, CourseListener {
                 result = new WindImpl(firstLegStart, at, new KnotSpeedWithBearingImpl(1.0,
                         firstLegEnd.getBearingGreatCircle(firstLegStart)));
                 directionFromStartToNextMarkCache = result;
+                // FIXME don't we have to expect that after cache invalidation the listeners are still subscribed?
                 addDirectionFromStartToNextMarkCacheInvalidationListener();
             } else {
                 result = null;
@@ -428,26 +442,17 @@ public abstract class TrackedRaceImpl implements TrackedRace, CourseListener {
     
     private void addDirectionFromStartToNextMarkCacheInvalidationListener() {
         Leg firstLeg = getRace().getCourse().getLegs().iterator().next();
-        RaceChangeListener<Buoy> listener = new RaceChangeListener<Buoy>() {
-            @Override
-            public void windDataReceived(Wind wind) {}
-
-            @Override
-            public void windDataRemoved(Wind wind) {}
-
-            @Override
-            public void windAveragingChanged(long oldMillisecondsOverWhichToAverage, long newMillisecondsOverWhichToAverage) {}
-
+        GPSTrackListener<Buoy> listener = new GPSTrackListener<Buoy>() {
             @Override
             public void gpsFixReceived(GPSFix fix, Buoy competitor) {
                 directionFromStartToNextMarkCache = null;
             }
 
             @Override
-            public void markPassingReceived(MarkPassing oldMarkPassing, MarkPassing markPassing) {}
-
-            @Override
-            public void speedAveragingChanged(long oldMillisecondsOverWhichToAverage, long newMillisecondsOverWhichToAverage) {}
+            public void speedAveragingChanged(long oldMillisecondsOverWhichToAverage,
+                    long newMillisecondsOverWhichToAverage) {
+                directionFromStartToNextMarkCache = null;
+            }
         };
         for (Buoy buoy : firstLeg.getFrom().getBuoys()) {
             getOrCreateTrack(buoy).addListener(listener);