harmonizing the way how competitors are determined, cached and updated for leaderboard and regatta

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

@@ -49,6 +49,7 @@ import com.sap.sailing.domain.racelog.tracking.GPSFixStore;
 import com.sap.sailing.domain.ranking.RankingMetric;
 import com.sap.sailing.domain.ranking.RankingMetric.RankingInfo;
 import com.sap.sailing.domain.ranking.RankingMetricConstructor;
+import com.sap.sailing.domain.regattalike.IsRegattaLike;
 import com.sap.sailing.domain.regattalike.RegattaLikeIdentifier;
 import com.sap.sailing.domain.regattalike.RegattaLikeListener;
 import com.sap.sailing.domain.tracking.CourseDesignChangedListener;
@@ -471,6 +472,21 @@ public class MockedTrackedRace implements DynamicTrackedRace {
                     public RaceColumn getRaceColumnByName(String raceColumnName) {
                         return null;
                     }
+
+                    @Override
+                    public IsRegattaLike getRegattaLike() {
+                        return null;
+                    }
+
+                    @Override
+                    public RaceLog getRacelog(String raceColumnName, String fleetName) {
+                        return null;
+                    }
+
+                    @Override
+                    public Iterable<? extends RaceColumn> getRaceColumns() {
+                        return null;
+                    }
                 };
             }
 

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

@@ -1,6 +1,7 @@
 package com.sap.sailing.domain.base;
 
 import com.sap.sailing.domain.abstractlog.race.RaceLog;
+import com.sap.sailing.domain.abstractlog.regatta.RegattaLog;
 import com.sap.sailing.domain.common.RaceIdentifier;
 import com.sap.sailing.domain.leaderboard.Leaderboard;
 import com.sap.sailing.domain.leaderboard.MetaLeaderboard;
@@ -227,4 +228,12 @@ public interface RaceColumn extends Named {
     boolean hasSplitFleets();
     
     RaceExecutionOrderProvider getRaceExecutionOrderProvider();
+    
+    /**
+     * Provides the combined set of competitors from all {@link #getTrackedRace(Fleet) tracked races attached to this column}
+     * plus the competitors registered through any {@link RaceLog} {@link #getRaceLog(Fleet) attached to this column}. Note that
+     * this does not include competitors registered through any {@link RegattaLog} on the structure owning (directly or transitively)
+     * this column.
+     */
+    Iterable<Competitor> getAllCompetitors();
 }

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

@@ -4,6 +4,7 @@ import com.sap.sailing.domain.base.configuration.RegattaConfiguration;
 import com.sap.sailing.domain.common.RankingMetrics;
 import com.sap.sailing.domain.common.RegattaAndRaceIdentifier;
 import com.sap.sailing.domain.common.RegattaIdentifier;
+import com.sap.sailing.domain.leaderboard.HasRaceColumnsAndRegattaLike;
 import com.sap.sailing.domain.leaderboard.ScoringScheme;
 import com.sap.sailing.domain.ranking.RankingMetricConstructor;
 import com.sap.sailing.domain.ranking.RankingMetricsFactory;
@@ -22,7 +23,7 @@ import com.sap.sse.common.WithID;
  * @author Axel Uhl (d043530)
  *
  */
-public interface Regatta extends Named, WithID, IsRegattaLike {
+public interface Regatta extends Named, WithID, IsRegattaLike, HasRaceColumnsAndRegattaLike {
     ScoringScheme getScoringScheme();
 
     /**

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

@@ -3,11 +3,14 @@ package com.sap.sailing.domain.base.impl;
 import java.io.IOException;
 import java.io.ObjectInputStream;
 import java.util.HashMap;
+import java.util.HashSet;
 import java.util.Map;
 import java.util.Map.Entry;
+import java.util.Set;
 import java.util.logging.Logger;
 
 import com.sap.sailing.domain.abstractlog.race.RaceLog;
+import com.sap.sailing.domain.abstractlog.shared.analyzing.RegisteredCompetitorsAnalyzer;
 import com.sap.sailing.domain.base.Competitor;
 import com.sap.sailing.domain.base.Fleet;
 import com.sap.sailing.domain.base.RaceColumn;
@@ -206,4 +209,25 @@ public abstract class AbstractRaceColumn extends SimpleAbstractRaceColumn implem
     public void setMasterDataExportOngoingThreadFlag(boolean flagValue) {
         trackedRaces.setMasterDataExportOngoingThreadFlag(flagValue);
     }
+
+    
+    @Override
+    public Iterable<Competitor> getAllCompetitors() {
+        Set<Competitor> result = new HashSet<>();
+        for (Fleet fleet : getFleets()) {
+            TrackedRace trackedRace = getTrackedRace(fleet);
+            if (trackedRace != null) {
+                Util.addAll(trackedRace.getRace().getCompetitors(), result);
+            } else {
+                // if no tracked race is found, use competitors from race log; this assumes that if a tracked
+                // race exists, its competitors set takes precedence over what's in the race log. Usually,
+                // the tracked race will have the same competitors as those in the race log, or more because
+                // those from the regatta log are added to the tracked race as well.
+                Set<Competitor> viaRaceLog = new RegisteredCompetitorsAnalyzer<>(getRaceLog(fleet)).analyze();
+                result.addAll(viaRaceLog);
+            }
+        }
+        return result;
+    }
+
 }

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

@@ -16,9 +16,9 @@ import java.util.concurrent.ConcurrentHashMap;
 import java.util.logging.Level;
 import java.util.logging.Logger;
 
+import com.sap.sailing.domain.abstractlog.race.RaceLog;
 import com.sap.sailing.domain.abstractlog.race.RaceLogEvent;
 import com.sap.sailing.domain.abstractlog.regatta.RegattaLog;
-import com.sap.sailing.domain.abstractlog.shared.analyzing.RegisteredCompetitorsAnalyzer;
 import com.sap.sailing.domain.base.BoatClass;
 import com.sap.sailing.domain.base.Competitor;
 import com.sap.sailing.domain.base.CourseArea;
@@ -40,6 +40,7 @@ import com.sap.sailing.domain.common.RegattaName;
 import com.sap.sailing.domain.common.RegattaNameAndRaceName;
 import com.sap.sailing.domain.leaderboard.ResultDiscardingRule;
 import com.sap.sailing.domain.leaderboard.ScoringScheme;
+import com.sap.sailing.domain.leaderboard.impl.CompetitorProviderFromRaceColumnsAndRegattaLike;
 import com.sap.sailing.domain.racelog.RaceLogIdentifier;
 import com.sap.sailing.domain.racelog.RaceLogStore;
 import com.sap.sailing.domain.racelog.impl.EmptyRaceLogStore;
@@ -111,6 +112,8 @@ public class RegattaImpl extends NamedImpl implements Regatta, RaceColumnListene
      * Defaults to <code>true</code>. See {@link Regatta#useStartTimeInference()}.
      */
     private boolean useStartTimeInference;
+    
+    private transient CompetitorProviderFromRaceColumnsAndRegattaLike competitorsProvider;
   
     /**
      * Constructs a regatta with an empty {@link RaceLogStore}.
@@ -171,7 +174,6 @@ public class RegattaImpl extends NamedImpl implements Regatta, RaceColumnListene
      * @param series
      *            all {@link Series} in this iterable will have their {@link Series#setRegatta(Regatta) regatta set} to
      *            this new regatta.
-     * @param rankingMetricConstructor TODO
      */
     public <S extends Series> RegattaImpl(RaceLogStore raceLogStore, RegattaLogStore regattaLogStore,
             String name, BoatClass boatClass, TimePoint startDate, TimePoint endDate, Iterable<S> series, boolean persistent, ScoringScheme scoringScheme,
@@ -363,24 +365,15 @@ public class RegattaImpl extends NamedImpl implements Regatta, RaceColumnListene
     @Override
     public Iterable<Competitor> getAllCompetitors() {
         Set<Competitor> result = new HashSet<Competitor>();
+        if (competitorsProvider == null) {
+            competitorsProvider = new CompetitorProviderFromRaceColumnsAndRegattaLike(this);
+        }
+        Util.addAll(competitorsProvider.getAllCompetitors(), result);
         for (RaceDefinition race : getAllRaces()) {
             for (Competitor c : race.getCompetitors()) {
                 result.add(c);
             }
         }
-        for (Series series : getSeries()) {
-            for (RaceColumn rc : series.getRaceColumns()) {
-                for (Fleet fleet : rc.getFleets()) {
-                    TrackedRace trackedRace = rc.getTrackedRace(fleet);
-                    if (trackedRace != null) {
-                        Util.addAll(trackedRace.getRace().getCompetitors(), result);
-                    }
-                }
-            }
-        }
-        //consider {@link RegattaLog}
-        Set<Competitor> viaLog = new RegisteredCompetitorsAnalyzer<>(regattaLikeHelper.getRegattaLog()).analyze();
-        result.addAll(viaLog);
         return result;
     }
 
@@ -700,4 +693,37 @@ public class RegattaImpl extends NamedImpl implements Regatta, RaceColumnListene
     public RaceColumn getRaceColumnByName(String raceColumnName) {
         return regattaLikeHelper.getRaceColumnByName(raceColumnName);
     }
+
+    @Override
+    public IsRegattaLike getRegattaLike() {
+        return this;
+    }
+
+    @Override
+    public RaceLog getRacelog(String raceColumnName, String fleetName) {
+        final RaceLog result;
+        final RaceColumn raceColumn = getRaceColumnByName(raceColumnName);
+        if (raceColumn == null) {
+            result = null;
+        } else {
+            final Fleet fleet = raceColumn.getFleetByName(fleetName);
+            if (fleet == null) {
+                result = null;
+            } else {
+                result = raceColumn.getRaceLog(fleet);
+            }
+        }
+        return result;
+    }
+
+    @Override
+    public Iterable<? extends RaceColumn> getRaceColumns() {
+        final List<RaceColumnInSeries> result = new ArrayList<>();
+        for (final Series series : getSeries()) {
+            for (final RaceColumnInSeries rc : series.getRaceColumns()) {
+                result.add(rc);
+            }
+        }
+        return result;
+    }
 }

java/com.sap.sailing.domain/src/com/sap/sailing/domain/leaderboard/HasRaceColumns.java

@@ -0,0 +1,12 @@
+package com.sap.sailing.domain.leaderboard;
+
+import com.sap.sailing.domain.base.RaceColumn;
+import com.sap.sailing.domain.base.RaceColumnListener;
+
+public interface HasRaceColumns {
+    Iterable<? extends RaceColumn> getRaceColumns();
+    
+    void addRaceColumnListener(RaceColumnListener listener);
+    
+    void removeRaceColumnListener(RaceColumnListener listener);
+}

java/com.sap.sailing.domain/src/com/sap/sailing/domain/leaderboard/HasRaceColumnsAndRegattaLike.java

@@ -0,0 +1,7 @@
+package com.sap.sailing.domain.leaderboard;
+
+import com.sap.sailing.domain.regattalike.HasRegattaLike;
+
+public interface HasRaceColumnsAndRegattaLike extends HasRegattaLike, HasRaceColumns {
+    
+}

java/com.sap.sailing.domain/src/com/sap/sailing/domain/leaderboard/Leaderboard.java

@@ -44,7 +44,7 @@ import com.sap.sse.common.Util;
  * @author Axel Uhl (d043530)
  * 
  */
-public interface Leaderboard extends LeaderboardBase {
+public interface Leaderboard extends LeaderboardBase, HasRaceColumns {
     /**
      * If the leaderboard is a "matrix" with the cells being defined by a competitor / race "coordinate,"
      * then this interface defines the structure of the "cells."

java/com.sap.sailing.domain/src/com/sap/sailing/domain/leaderboard/LeaderboardCacheManager.java

@@ -8,7 +8,6 @@ import java.util.Set;
 import java.util.WeakHashMap;
 import java.util.concurrent.ConcurrentHashMap;
 
-import com.sap.sailing.domain.abstractlog.race.RaceLogEvent;
 import com.sap.sailing.domain.base.Competitor;
 import com.sap.sailing.domain.base.CompetitorChangeListener;
 import com.sap.sailing.domain.base.Fleet;
@@ -16,9 +15,9 @@ import com.sap.sailing.domain.base.Nationality;
 import com.sap.sailing.domain.base.RaceColumn;
 import com.sap.sailing.domain.base.RaceColumnListener;
 import com.sap.sailing.domain.base.WithNationality;
+import com.sap.sailing.domain.base.impl.RaceColumnListenerWithDefaultAction;
 import com.sap.sailing.domain.common.MaxPointsReason;
 import com.sap.sailing.domain.leaderboard.caching.LeaderboardCache;
-import com.sap.sailing.domain.racelog.RaceLogIdentifier;
 import com.sap.sailing.domain.tracking.RaceChangeListener;
 import com.sap.sailing.domain.tracking.TrackedRace;
 import com.sap.sailing.domain.tracking.impl.AbstractRaceChangeListener;
@@ -262,9 +261,14 @@ public class LeaderboardCacheManager {
                 leaderboard.getScoreCorrection().addScoreCorrectionListener(scoreCorrectionListener);
                 scoreCorrectionListeners.put(leaderboard, scoreCorrectionListener);
                 competitorChangeListeners.put(leaderboard, competitorChangeListener);
-                final RaceColumnListener raceColumnListener = new RaceColumnListener() {
+                final RaceColumnListener raceColumnListener = new RaceColumnListenerWithDefaultAction() {
                     private static final long serialVersionUID = 8165124797028386317L;
 
+                    @Override
+                    public void defaultAction() {
+                        removeFromCache(leaderboard);
+                    }
+
                     @Override
                     public void trackedRaceLinked(RaceColumn raceColumn, Fleet fleet, TrackedRace trackedRace) {
                         removeFromCache(leaderboard);
@@ -278,70 +282,6 @@ public class LeaderboardCacheManager {
                     public boolean isTransient() {
                         return true;
                     }
-
-                    @Override
-                    public void trackedRaceUnlinked(RaceColumn raceColumn, Fleet fleet, TrackedRace trackedRace) {
-                        removeFromCache(leaderboard); // removes all listeners from invalidationListenersPerLeaderboard and from their TrackedRaces
-                    }
-
-                    @Override
-                    public void isMedalRaceChanged(RaceColumn raceColumn, boolean newIsMedalRace) {
-                        removeFromCache(leaderboard);
-                    }
-
-                    @Override
-                    public void isStartsWithZeroScoreChanged(RaceColumn raceColumn, boolean newIsStartsWithZeroScore) {
-                        removeFromCache(leaderboard);
-                    }
-
-                    @Override
-                    public void hasSplitFleetContiguousScoringChanged(RaceColumn raceColumn, boolean hasSplitFleetContiguousScoring) {
-                        removeFromCache(leaderboard);
-                    }
-
-                    @Override
-                    public void isFirstColumnIsNonDiscardableCarryForwardChanged(RaceColumn raceColumn,
-                            boolean firstColumnIsNonDiscardableCarryForward) {
-                        removeFromCache(leaderboard);
-                    }
-
-                    @Override
-                    public void raceColumnAddedToContainer(RaceColumn raceColumn) {
-                        removeFromCache(leaderboard);
-                    }
-
-                    @Override
-                    public void raceColumnRemovedFromContainer(RaceColumn raceColumn) {
-                        removeFromCache(leaderboard);
-                    }
-
-                    @Override
-                    public void raceColumnMoved(RaceColumn raceColumn, int newIndex) {
-                        removeFromCache(leaderboard);
-                    }
-
-                    @Override
-                    public void factorChanged(RaceColumn raceColumn, Double oldFactor, Double newFactor) {
-                        removeFromCache(leaderboard);
-                    }
-
-                    @Override
-                    public void resultDiscardingRuleChanged(ResultDiscardingRule oldDiscardingRule,
-                            ResultDiscardingRule newDiscardingRule) {
-                        removeFromCache(leaderboard);
-                    }
-
-                    @Override
-                    public void competitorDisplayNameChanged(Competitor competitor, String oldDisplayName,
-                            String displayName) {
-                        removeFromCache(leaderboard);
-                    }
-
-                    @Override
-                    public void raceLogEventAdded(RaceColumn raceColumn, RaceLogIdentifier raceLogIdentifier,
-                            RaceLogEvent event) {
-                        removeFromCache(leaderboard);
-                    }
                 };
                 leaderboard.addRaceColumnListener(raceColumnListener);
                 synchronized (raceColumnListeners) {

java/com.sap.sailing.domain/src/com/sap/sailing/domain/leaderboard/impl/AbstractLeaderboardImpl.java

@@ -12,9 +12,9 @@ import com.sap.sailing.domain.base.Fleet;
 import com.sap.sailing.domain.base.RaceColumn;
 import com.sap.sailing.domain.base.RaceColumnListener;
 import com.sap.sailing.domain.common.MaxPointsReason;
+import com.sap.sailing.domain.leaderboard.HasRaceColumnsAndRegattaLike;
 import com.sap.sailing.domain.leaderboard.ScoreCorrection;
 import com.sap.sailing.domain.leaderboard.ThresholdBasedResultDiscardingRule;
-import com.sap.sailing.domain.regattalike.HasRegattaLike;
 import com.sap.sailing.domain.tracking.TrackedRace;
 import com.sap.sse.common.TimePoint;
 
@@ -28,14 +28,14 @@ import com.sap.sse.common.TimePoint;
  * @author Axel Uhl (D043530)
  *
  */
-public abstract class AbstractLeaderboardImpl extends AbstractSimpleLeaderboardImpl implements HasRegattaLike{
+public abstract class AbstractLeaderboardImpl extends AbstractSimpleLeaderboardImpl implements HasRaceColumnsAndRegattaLike {
     private static final long serialVersionUID = -328091952760083438L;
-
+    
     /**
      * Cache for the combined competitors of this leaderboard; taken from the {@link TrackedRace#getRace() races of the
      * tracked races} associated with this leaderboard. Updated when the set of tracked races changes.
      */
-    private transient Iterable<Competitor> allCompetitorsCache;
+    private transient CompetitorProviderFromRaceColumnsAndRegattaLike competitorsProvider;
 
     /**
      * @param scoreComparator the comparator to use to compare basic scores, such as net points
@@ -77,18 +77,10 @@ public abstract class AbstractLeaderboardImpl extends AbstractSimpleLeaderboardI
      */
     @Override
     public Iterable<Competitor> getAllCompetitors() {
-        if (allCompetitorsCache == null) {
-            Set<Competitor> result = new HashSet<Competitor>();
-            synchronized (this) {
-                for (TrackedRace r : getTrackedRaces()) {
-                    for (Competitor c : r.getRace().getCompetitors()) {
-                        result.add(c);
-                    }
-                }
-            }
-            allCompetitorsCache = result;
+        if (competitorsProvider == null) {
+            competitorsProvider = new CompetitorProviderFromRaceColumnsAndRegattaLike(this);
         }
-        return allCompetitorsCache;
+        return competitorsProvider.getAllCompetitors();
     }
     
     @Override
@@ -144,18 +136,6 @@ public abstract class AbstractLeaderboardImpl extends AbstractSimpleLeaderboardI
         return correctedRank;
     }
 
-    @Override
-    public void trackedRaceLinked(RaceColumn raceColumn, Fleet fleet, TrackedRace trackedRace) {
-        allCompetitorsCache = null;
-        super.trackedRaceLinked(raceColumn, fleet, trackedRace);
-    }
-
-    @Override
-    public void trackedRaceUnlinked(RaceColumn raceColumn, Fleet fleet, TrackedRace trackedRace) {
-        allCompetitorsCache = null;
-        super.trackedRaceUnlinked(raceColumn, fleet, trackedRace);
-    }
-    
     // Note: no need to redefine isMedalRaceChanged because that doesn't affect the competitorsCache
 
     @Override

java/com.sap.sailing.domain/src/com/sap/sailing/domain/leaderboard/impl/CompetitorProviderFromRaceColumnsAndRegattaLike.java

@@ -0,0 +1,149 @@
+package com.sap.sailing.domain.leaderboard.impl;
+
+import java.util.HashSet;
+import java.util.Set;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import com.sap.sailing.domain.abstractlog.race.RaceLog;
+import com.sap.sailing.domain.abstractlog.race.RaceLogEventVisitor;
+import com.sap.sailing.domain.abstractlog.race.RaceLogRevokeEvent;
+import com.sap.sailing.domain.abstractlog.race.impl.BaseRaceLogEventVisitor;
+import com.sap.sailing.domain.abstractlog.race.tracking.RaceLogRegisterCompetitorEvent;
+import com.sap.sailing.domain.abstractlog.regatta.RegattaLog;
+import com.sap.sailing.domain.abstractlog.regatta.RegattaLogEventVisitor;
+import com.sap.sailing.domain.abstractlog.regatta.events.RegattaLogRegisterCompetitorEvent;
+import com.sap.sailing.domain.abstractlog.regatta.events.RegattaLogRevokeEvent;
+import com.sap.sailing.domain.abstractlog.regatta.impl.BaseRegattaLogEventVisitor;
+import com.sap.sailing.domain.abstractlog.shared.analyzing.RegisteredCompetitorsAnalyzer;
+import com.sap.sailing.domain.base.Competitor;
+import com.sap.sailing.domain.base.Fleet;
+import com.sap.sailing.domain.base.RaceColumn;
+import com.sap.sailing.domain.base.RaceColumnListener;
+import com.sap.sailing.domain.base.impl.RaceColumnListenerWithDefaultAction;
+import com.sap.sailing.domain.leaderboard.HasRaceColumnsAndRegattaLike;
+import com.sap.sailing.domain.tracking.TrackedRace;
+import com.sap.sse.common.Util;
+
+/**
+ * A caching provider of a competitor set, based on the tracked races and {@link RaceLog}s of the {@link RaceColumn}s of
+ * a {@link HasRaceColumnsAndRegattaLike} and the {@link RegattaLog} of the same object. After an answer has been provided,
+ * it is cached. The cache is invalidated when one of the following events occurs:
+ * <ul>
+ * <li>a competitor is registered with or unregistered from a race log of any of the race columns or the regatta log</li>
+ * <li>a race column is added or removed</li>
+ * <li>a tracked race is linked to or unlinked from any of the race columns</li>
+ * </ul>
+ * 
+ * @author Axel Uhl (d043530)
+ *
+ */
+public class CompetitorProviderFromRaceColumnsAndRegattaLike {
+    private static final Logger logger = Logger.getLogger(CompetitorProviderFromRaceColumnsAndRegattaLike.class.getName());
+    
+    private final HasRaceColumnsAndRegattaLike provider;
+
+    private final RegattaLogEventVisitor regattaLogCompetitorsCacheInvalidationListener;
+
+    private final RaceLogEventVisitor raceLogCompetitorsCacheInvalidationListener;
+    
+    private final RaceColumnListener raceColumnListener;
+
+    private transient Iterable<Competitor> allCompetitorsCache;
+
+    public CompetitorProviderFromRaceColumnsAndRegattaLike(HasRaceColumnsAndRegattaLike provider) {
+        super();
+        this.provider = provider;
+        regattaLogCompetitorsCacheInvalidationListener = new BaseRegattaLogEventVisitor() {
+            @Override
+            public void visit(RegattaLogRegisterCompetitorEvent event) {
+                invalidateAllCompetitorsCache();
+            }
+
+            @Override
+            public void visit(RegattaLogRevokeEvent event) {
+                try {
+                    if (RegattaLogRegisterCompetitorEvent.class.isAssignableFrom(Class.forName(event.getRevokedEventType()))) {
+                        
+                    }
+                } catch (ClassNotFoundException e) {
+                    logger.log(Level.WARNING, "Problem occurred trying to resolve revoked event class "+event.getRevokedEventType(), e);
+                }
+            }
+        };
+        raceLogCompetitorsCacheInvalidationListener = new BaseRaceLogEventVisitor() {
+            @Override
+            public void visit(RaceLogRegisterCompetitorEvent event) {
+                invalidateAllCompetitorsCache();
+            }
+
+            @Override
+            public void visit(RaceLogRevokeEvent event) {
+                try {
+                    if (RaceLogRegisterCompetitorEvent.class.isAssignableFrom(Class.forName(event.getRevokedEventType()))) {
+                        
+                    }
+                } catch (ClassNotFoundException e) {
+                    logger.log(Level.WARNING, "Problem occurred trying to resolve revoked event class "+event.getRevokedEventType(), e);
+                }
+            }
+        };
+        raceColumnListener = new RaceColumnListenerWithDefaultAction() {
+            private static final long serialVersionUID = -8678230058730043052L;
+
+            @Override
+            public void defaultAction() {}
+
+            @Override
+            public void trackedRaceLinked(RaceColumn raceColumn, Fleet fleet, TrackedRace trackedRace) {
+                invalidateAllCompetitorsCache();
+            }
+
+            @Override
+            public void trackedRaceUnlinked(RaceColumn raceColumn, Fleet fleet, TrackedRace trackedRace) {
+                invalidateAllCompetitorsCache();
+            }
+
+            @Override
+            public void raceColumnAddedToContainer(RaceColumn raceColumn) {
+                invalidateAllCompetitorsCache();
+            }
+
+            @Override
+            public void raceColumnRemovedFromContainer(RaceColumn raceColumn) {
+                invalidateAllCompetitorsCache();
+            }
+        };
+    }
+    
+    public Iterable<Competitor> getAllCompetitors() {
+        if (allCompetitorsCache == null) {
+            final Set<Competitor> result = new HashSet<>();
+            for (RaceColumn rc : provider.getRaceColumns()) {
+                Util.addAll(rc.getAllCompetitors(), result);
+                for (final Fleet fleet : rc.getFleets()) {
+                    rc.getRaceLog(fleet).addListener(raceLogCompetitorsCacheInvalidationListener);
+                }
+            }
+            provider.addRaceColumnListener(raceColumnListener);
+            // consider {@link RegattaLog}
+            Set<Competitor> viaLog = new RegisteredCompetitorsAnalyzer<>(provider.getRegattaLike().getRegattaLog()).analyze();
+            result.addAll(viaLog);
+            provider.getRegattaLike().getRegattaLog().addListener(regattaLogCompetitorsCacheInvalidationListener);
+            allCompetitorsCache = result;
+        }
+        return allCompetitorsCache;
+    }
+
+    private void invalidateAllCompetitorsCache() {
+        allCompetitorsCache = null;
+        provider.getRegattaLike().getRegattaLog().removeListener(regattaLogCompetitorsCacheInvalidationListener);
+        for (final RaceColumn rc : provider.getRaceColumns()) {
+            for (final Fleet fleet : rc.getFleets()) {
+                rc.getRaceLog(fleet).removeListener(raceLogCompetitorsCacheInvalidationListener);
+            }
+        }
+        provider.removeRaceColumnListener(raceColumnListener);
+    }
+
+}

java/com.sap.sailing.domain/src/com/sap/sailing/domain/leaderboard/impl/FlexibleLeaderboardImpl.java

@@ -8,14 +8,11 @@ import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.HashMap;
-import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
-import java.util.Set;
 import java.util.logging.Logger;
 
 import com.sap.sailing.domain.abstractlog.regatta.RegattaLog;
-import com.sap.sailing.domain.abstractlog.shared.analyzing.RegisteredCompetitorsAnalyzer;
 import com.sap.sailing.domain.base.Competitor;
 import com.sap.sailing.domain.base.CourseArea;
 import com.sap.sailing.domain.base.Fleet;
@@ -319,18 +316,6 @@ public class FlexibleLeaderboardImpl extends AbstractLeaderboardImpl implements
         return regattaLikeHelper.getTimeOnDistanceAllowancePerNauticalMile(competitor);
     }
 
-    @Override
-    public Iterable<Competitor> getAllCompetitors() {
-        Set<Competitor> result = new HashSet<>();
-        for (Competitor c : super.getAllCompetitors()) {
-            result.add(c);
-        }
-        //consider {@link RegattaLog}
-        Set<Competitor> viaLog = new RegisteredCompetitorsAnalyzer<>(regattaLikeHelper.getRegattaLog()).analyze();
-        result.addAll(viaLog);
-        return result;
-    }
-    
     private class RaceExecutionOrderCache extends AbstractRaceExecutionOrderProvider {
         private static final long serialVersionUID = 652833386555762661L;
 

java/com.sap.sailing.domain/src/com/sap/sailing/domain/leaderboard/meta/MetaLeaderboardColumn.java

@@ -203,4 +203,9 @@ public class MetaLeaderboardColumn extends SimpleAbstractRaceColumn implements R
     public RaceExecutionOrderProvider getRaceExecutionOrderProvider() {
         return null;
     }
+
+    @Override
+    public Iterable<Competitor> getAllCompetitors() {
+        return leaderboard.getAllCompetitors();
+    }
 }

java/com.sap.sailing.domain/src/com/sap/sailing/domain/regattalike/LeaderboardThatHasRegattaLike.java

@@ -1,6 +1,7 @@
 package com.sap.sailing.domain.regattalike;
 
+import com.sap.sailing.domain.leaderboard.HasRaceColumnsAndRegattaLike;
 import com.sap.sailing.domain.leaderboard.Leaderboard;
 
-public interface LeaderboardThatHasRegattaLike extends Leaderboard, HasRegattaLike {
+public interface LeaderboardThatHasRegattaLike extends Leaderboard, HasRaceColumnsAndRegattaLike {
 }