fixed bug in isEliminated, making formerly failing test case pass

Change-Id: I8fb9160e2289949413700aaa2dd9419974d4976f

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

@@ -65,7 +65,7 @@ import com.sap.sailing.domain.leaderboard.impl.HighPointFirstGets10Or8AndLastBre
 import com.sap.sailing.domain.leaderboard.impl.HighPointFirstGets12Or8AndLastBreaksTie2017;
 import com.sap.sailing.domain.leaderboard.impl.LeaderboardGroupImpl;
 import com.sap.sailing.domain.leaderboard.impl.LowPoint;
-import com.sap.sailing.domain.leaderboard.impl.RegattaLeaderboardCountingButNotRankingSuppressedImpl;
+import com.sap.sailing.domain.leaderboard.impl.DelegatingRegattaLeaderboardWithCompetitorElimination;
 import com.sap.sailing.domain.leaderboard.impl.RegattaLeaderboardImpl;
 import com.sap.sailing.domain.leaderboard.impl.ThresholdBasedResultDiscardingRuleImpl;
 import com.sap.sailing.domain.leaderboard.meta.LeaderboardGroupMetaLeaderboard;
@@ -90,9 +90,10 @@ public class LeaderboardScoringAndRankingTest extends LeaderboardScoringAndRanki
         return new RegattaLeaderboardImpl(regatta, discardingRules);
     }
     
-    protected Leaderboard createRegattaLeaderboardCountingButNotRankingSuppressed(Regatta regatta, String leaderboardName, int[] discardingThresholds) {
+    protected DelegatingRegattaLeaderboardWithCompetitorElimination createDelegatingRegattaLeaderboardWithCompetitorElimination(
+            Regatta regatta, String leaderboardName, int[] discardingThresholds) {
         final RegattaLeaderboard fullLeaderboard = createLeaderboard(regatta, discardingThresholds);
-        return new RegattaLeaderboardCountingButNotRankingSuppressedImpl(fullLeaderboard, leaderboardName);
+        return new DelegatingRegattaLeaderboardWithCompetitorElimination(fullLeaderboard, leaderboardName);
     }
 
     @Test
@@ -693,7 +694,7 @@ public class LeaderboardScoringAndRankingTest extends LeaderboardScoringAndRanki
         Regatta regatta = createRegatta(/* qualifying */0, new String[] { "Default" }, /* final */3, new String[] { "Default" },
                 /* medal */ false, /* medal */ 0, "testTotalTimeNotCountedForRacesStartedLaterThanTimePointReqeusted",
                 DomainFactory.INSTANCE.getOrCreateBoatClass("49er", /* typicallyStartsUpwind */true), DomainFactory.INSTANCE.createScoringScheme(ScoringSchemeType.LOW_POINT));
-        Leaderboard leaderboard = createRegattaLeaderboardCountingButNotRankingSuppressed(regatta, "Test not counting suppressed", /* discarding thresholds */ new int[0]);
+        DelegatingRegattaLeaderboardWithCompetitorElimination leaderboard = createDelegatingRegattaLeaderboardWithCompetitorElimination(regatta, "Test not counting suppressed", /* discarding thresholds */ new int[0]);
         @SuppressWarnings("unchecked")
         Map<Competitor, TimePoint>[] lastMarkPassingTimesForCompetitors = (Map<Competitor, TimePoint>[]) new HashMap<?, ?>[3];
         lastMarkPassingTimesForCompetitors[0] = new HashMap<>();
@@ -710,7 +711,7 @@ public class LeaderboardScoringAndRankingTest extends LeaderboardScoringAndRanki
         lastMarkPassingTimesForCompetitors[2].put(c[2], finish);
         createAndAttachTrackedRacesWithStartTimeAndLastMarkPassingTimes(series.get(1), "Default",
                 new Competitor[][] { f1 }, new TimePoint[] { earlier, now, later }, lastMarkPassingTimesForCompetitors);
-        leaderboard.setSuppressed(c[1], true);
+        leaderboard.setEliminated(c[1], true);
         assertEquals(1.0, leaderboard.getTotalPoints(c[0], leaderboard.getRaceColumns().iterator().next(), later), 0.000001);
         assertEquals(2.0, leaderboard.getTotalPoints(c[1], leaderboard.getRaceColumns().iterator().next(), later), 0.000001);
         assertEquals(3.0, leaderboard.getTotalPoints(c[2], leaderboard.getRaceColumns().iterator().next(), later), 0.000001);

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

@@ -308,7 +308,8 @@ public interface Leaderboard extends LeaderboardBase, HasRaceColumns {
     List<Competitor> getCompetitorsFromBestToWorst(TimePoint timePoint);
     
     /**
-     * Returns the total rank of the given competitor.
+     * Returns the total rank of the given competitor or {@code 0} if no rank can be determined for
+     * the {@code competitor} in this leaderboard.
      */
     int getTotalRankOfCompetitor(Competitor competitor, TimePoint timePoint) throws NoWindException;
 

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

@@ -57,6 +57,7 @@ import com.sap.sailing.domain.common.dto.RaceColumnDTO;
 import com.sap.sailing.domain.common.dto.RaceDTO;
 import com.sap.sailing.domain.common.tracking.GPSFixMoving;
 import com.sap.sailing.domain.leaderboard.Leaderboard;
+import com.sap.sailing.domain.leaderboard.ResultDiscardingRule;
 import com.sap.sailing.domain.leaderboard.ThresholdBasedResultDiscardingRule;
 import com.sap.sailing.domain.leaderboard.caching.LeaderboardDTOCache;
 import com.sap.sailing.domain.leaderboard.caching.LeaderboardDTOCalculationReuseCache;
@@ -230,6 +231,71 @@ public abstract class AbstractLeaderboardWithCache implements Leaderboard, RaceC
         }
     }
     
+    @Override
+    public void trackedRaceLinked(RaceColumn raceColumn, Fleet fleet, TrackedRace trackedRace) {
+        getRaceColumnListeners().notifyListenersAboutTrackedRaceLinked(raceColumn, fleet, trackedRace);
+    }
+
+    @Override
+    public void isMedalRaceChanged(RaceColumn raceColumn, boolean newIsMedalRace) {
+        getRaceColumnListeners().notifyListenersAboutIsMedalRaceChanged(raceColumn, newIsMedalRace);
+    }
+    
+    @Override
+    public void isFleetsCanRunInParallelChanged(RaceColumn raceColumn, boolean newIsFleetsCanRunInParallel) {
+        getRaceColumnListeners().notifyListenersAboutIsFleetsCanRunInParallelChanged(raceColumn, newIsFleetsCanRunInParallel);
+    }
+
+    @Override
+    public void isStartsWithZeroScoreChanged(RaceColumn raceColumn, boolean newIsStartsWithZeroScore) {
+        getRaceColumnListeners().notifyListenersAboutIsStartsWithZeroScoreChanged(raceColumn, newIsStartsWithZeroScore);
+    }
+
+    @Override
+    public void isFirstColumnIsNonDiscardableCarryForwardChanged(RaceColumn raceColumn, boolean firstColumnIsNonDiscardableCarryForward) {
+        getRaceColumnListeners().notifyListenersAboutIsFirstColumnIsNonDiscardableCarryForwardChanged(raceColumn, firstColumnIsNonDiscardableCarryForward);
+    }
+
+    @Override
+    public void hasSplitFleetContiguousScoringChanged(RaceColumn raceColumn, boolean hasSplitFleetContiguousScoring) {
+        getRaceColumnListeners().notifyListenersAboutHasSplitFleetContiguousScoringChanged(raceColumn, hasSplitFleetContiguousScoring);
+    }
+
+    @Override
+    public void raceColumnMoved(RaceColumn raceColumn, int newIndex) {
+        getRaceColumnListeners().notifyListenersAboutRaceColumnMoved(raceColumn, newIndex);
+    }
+
+    @Override
+    public void factorChanged(RaceColumn raceColumn, Double oldFactor, Double newFactor) {
+        getRaceColumnListeners().notifyListenersAboutFactorChanged(raceColumn, oldFactor, newFactor);
+    }
+
+    @Override
+    public void raceColumnAddedToContainer(RaceColumn raceColumn) {
+        getRaceColumnListeners().notifyListenersAboutRaceColumnAddedToContainer(raceColumn);
+    }
+
+    @Override
+    public void raceColumnRemovedFromContainer(RaceColumn raceColumn) {
+        getRaceColumnListeners().notifyListenersAboutRaceColumnRemovedFromContainer(raceColumn);
+    }
+
+    @Override
+    public void competitorDisplayNameChanged(Competitor competitor, String oldDisplayName, String displayName) {
+        getRaceColumnListeners().notifyListenersAboutCompetitorDisplayNameChanged(competitor, oldDisplayName, displayName);
+    }
+
+    @Override
+    public void resultDiscardingRuleChanged(ResultDiscardingRule oldDiscardingRule, ResultDiscardingRule newDiscardingRule) {
+        getRaceColumnListeners().notifyListenersAboutResultDiscardingRuleChanged(oldDiscardingRule, newDiscardingRule);
+    }
+
+    @Override
+    public boolean isTransient() {
+        return false;
+    }
+
     protected void notifyLeaderboardChangeListeners(Consumer<LeaderboardChangeListener> notifier) {
         for (final LeaderboardChangeListener listener : leaderboardChangeListeners) {
             try {

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

@@ -647,46 +647,6 @@ public abstract class AbstractSimpleLeaderboardImpl extends AbstractLeaderboardW
         return result;
     }
 
-    @Override
-    public void trackedRaceLinked(RaceColumn raceColumn, Fleet fleet, TrackedRace trackedRace) {
-        getRaceColumnListeners().notifyListenersAboutTrackedRaceLinked(raceColumn, fleet, trackedRace);
-    }
-
-    @Override
-    public void isMedalRaceChanged(RaceColumn raceColumn, boolean newIsMedalRace) {
-        getRaceColumnListeners().notifyListenersAboutIsMedalRaceChanged(raceColumn, newIsMedalRace);
-    }
-    
-    @Override
-    public void isFleetsCanRunInParallelChanged(RaceColumn raceColumn, boolean newIsFleetsCanRunInParallel) {
-        getRaceColumnListeners().notifyListenersAboutIsFleetsCanRunInParallelChanged(raceColumn, newIsFleetsCanRunInParallel);
-    }
-
-    @Override
-    public void isStartsWithZeroScoreChanged(RaceColumn raceColumn, boolean newIsStartsWithZeroScore) {
-        getRaceColumnListeners().notifyListenersAboutIsStartsWithZeroScoreChanged(raceColumn, newIsStartsWithZeroScore);
-    }
-
-    @Override
-    public void isFirstColumnIsNonDiscardableCarryForwardChanged(RaceColumn raceColumn, boolean firstColumnIsNonDiscardableCarryForward) {
-        getRaceColumnListeners().notifyListenersAboutIsFirstColumnIsNonDiscardableCarryForwardChanged(raceColumn, firstColumnIsNonDiscardableCarryForward);
-    }
-
-    @Override
-    public void hasSplitFleetContiguousScoringChanged(RaceColumn raceColumn, boolean hasSplitFleetContiguousScoring) {
-        getRaceColumnListeners().notifyListenersAboutHasSplitFleetContiguousScoringChanged(raceColumn, hasSplitFleetContiguousScoring);
-    }
-
-    @Override
-    public void raceColumnMoved(RaceColumn raceColumn, int newIndex) {
-        getRaceColumnListeners().notifyListenersAboutRaceColumnMoved(raceColumn, newIndex);
-    }
-
-    @Override
-    public void factorChanged(RaceColumn raceColumn, Double oldFactor, Double newFactor) {
-        getRaceColumnListeners().notifyListenersAboutFactorChanged(raceColumn, oldFactor, newFactor);
-    }
-
     /**
      * A leaderboard will only accept the addition of a race column if the column's name is unique across the leaderboard.
      */
@@ -702,31 +662,6 @@ public abstract class AbstractSimpleLeaderboardImpl extends AbstractLeaderboardW
         return result;
     }
 
-    @Override
-    public void raceColumnAddedToContainer(RaceColumn raceColumn) {
-        getRaceColumnListeners().notifyListenersAboutRaceColumnAddedToContainer(raceColumn);
-    }
-
-    @Override
-    public void raceColumnRemovedFromContainer(RaceColumn raceColumn) {
-        getRaceColumnListeners().notifyListenersAboutRaceColumnRemovedFromContainer(raceColumn);
-    }
-
-    @Override
-    public void competitorDisplayNameChanged(Competitor competitor, String oldDisplayName, String displayName) {
-        getRaceColumnListeners().notifyListenersAboutCompetitorDisplayNameChanged(competitor, oldDisplayName, displayName);
-    }
-
-    @Override
-    public void resultDiscardingRuleChanged(ResultDiscardingRule oldDiscardingRule, ResultDiscardingRule newDiscardingRule) {
-        getRaceColumnListeners().notifyListenersAboutResultDiscardingRuleChanged(oldDiscardingRule, newDiscardingRule);
-    }
-
-    @Override
-    public boolean isTransient() {
-        return false;
-    }
-
     /**
      * Finds out the time point when any of the {@link Leaderboard#getTrackedRaces() tracked races currently attached to
      * the <code>leaderboard</code>} and the {@link Leaderboard#getScoreCorrection() score corrections} have last been

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

@@ -1,30 +1,25 @@
 package com.sap.sailing.domain.leaderboard.impl;
 
 import java.util.ArrayList;
-import java.util.Collection;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.ExecutionException;
 
 import com.sap.sailing.domain.abstractlog.race.RaceLog;
 import com.sap.sailing.domain.base.BoatClass;
 import com.sap.sailing.domain.base.Competitor;
 import com.sap.sailing.domain.base.CourseArea;
-import com.sap.sailing.domain.base.DomainFactory;
 import com.sap.sailing.domain.base.Fleet;
 import com.sap.sailing.domain.base.LeaderboardChangeListener;
 import com.sap.sailing.domain.base.RaceColumn;
 import com.sap.sailing.domain.base.RaceColumnListener;
 import com.sap.sailing.domain.base.Regatta;
-import com.sap.sailing.domain.common.Distance;
-import com.sap.sailing.domain.common.LegType;
+import com.sap.sailing.domain.common.LeaderboardType;
 import com.sap.sailing.domain.common.MaxPointsReason;
 import com.sap.sailing.domain.common.NoWindException;
 import com.sap.sailing.domain.common.Speed;
-import com.sap.sailing.domain.common.dto.LeaderboardDTO;
 import com.sap.sailing.domain.common.tracking.GPSFixMoving;
 import com.sap.sailing.domain.leaderboard.NumberOfCompetitorsInLeaderboardFetcher;
 import com.sap.sailing.domain.leaderboard.RegattaLeaderboard;
@@ -34,13 +29,11 @@ import com.sap.sailing.domain.leaderboard.SettableScoreCorrection;
 import com.sap.sailing.domain.leaderboard.ThresholdBasedResultDiscardingRule;
 import com.sap.sailing.domain.regattalike.IsRegattaLike;
 import com.sap.sailing.domain.tracking.TrackedRace;
-import com.sap.sailing.domain.tracking.TrackedRegattaRegistry;
-import com.sap.sse.common.Duration;
 import com.sap.sse.common.ObscuringIterable;
 import com.sap.sse.common.TimePoint;
 import com.sap.sse.common.Util.Pair;
 
-public class RegattaLeaderboardCountingButNotRankingSuppressedImpl implements RegattaLeaderboard {
+public class DelegatingRegattaLeaderboardWithCompetitorElimination extends AbstractLeaderboardWithCache implements RegattaLeaderboard {
     private static final long serialVersionUID = 8331154893189722924L;
     private final String name;
     private final RegattaLeaderboard fullLeaderboard;
@@ -56,7 +49,7 @@ public class RegattaLeaderboardCountingButNotRankingSuppressedImpl implements Re
      */
     private final ConcurrentHashMap<Competitor, Boolean> eliminatedCompetitors;
 
-    public RegattaLeaderboardCountingButNotRankingSuppressedImpl(RegattaLeaderboard fullLeaderboard, String name) {
+    public DelegatingRegattaLeaderboardWithCompetitorElimination(RegattaLeaderboard fullLeaderboard, String name) {
         this.name = name;
         this.fullLeaderboard = fullLeaderboard;
         this.eliminatedCompetitors = new ConcurrentHashMap<>();
@@ -119,13 +112,6 @@ public class RegattaLeaderboardCountingButNotRankingSuppressedImpl implements Re
         fullLeaderboard.deregisterCompetitors(competitor);
     }
 
-    public LeaderboardDTO computeDTO(TimePoint timePoint, Collection<String> namesOfRaceColumnsForWhichToLoadLegDetails,
-            boolean addOverallDetails, boolean waitForLatestAnalyses, TrackedRegattaRegistry trackedRegattaRegistry,
-            DomainFactory baseDomainFactory, boolean fillTotalPointsUncorrected) throws NoWindException {
-        return fullLeaderboard.computeDTO(timePoint, namesOfRaceColumnsForWhichToLoadLegDetails, addOverallDetails,
-                waitForLatestAnalyses, trackedRegattaRegistry, baseDomainFactory, fillTotalPointsUncorrected);
-    }
-
     public Iterable<Competitor> getCompetitors() {
         return new ObscuringIterable<>(fullLeaderboard.getCompetitors(), eliminatedCompetitors.keySet());
     }
@@ -139,7 +125,7 @@ public class RegattaLeaderboardCountingButNotRankingSuppressedImpl implements Re
     }
     
     public boolean isEliminated(Competitor competitor) {
-        return eliminatedCompetitors.contains(competitor);
+        return eliminatedCompetitors.containsKey(competitor);
     }
 
     public Iterable<Competitor> getAllCompetitors() {
@@ -244,7 +230,7 @@ public class RegattaLeaderboardCountingButNotRankingSuppressedImpl implements Re
     public List<Competitor> getCompetitorsFromBestToWorst(TimePoint timePoint) {
         final List<Competitor> result = new ArrayList<>();
         for (final Competitor c : fullLeaderboard.getCompetitorsFromBestToWorst(timePoint)) {
-            if (!isSuppressed(c)) {
+            if (!isEliminated(c)) {
                 result.add(c);
             }
         }
@@ -358,19 +344,6 @@ public class RegattaLeaderboardCountingButNotRankingSuppressedImpl implements Re
         return fullLeaderboard.getAverageSpeedOverGround(competitor, timePoint);
     }
 
-    public Duration getTotalTimeSailedInLegType(Competitor competitor, LegType legType, TimePoint timePoint)
-            throws NoWindException {
-        return fullLeaderboard.getTotalTimeSailedInLegType(competitor, legType, timePoint);
-    }
-
-    public Duration getTotalTimeSailed(Competitor competitor, TimePoint timePoint) {
-        return fullLeaderboard.getTotalTimeSailed(competitor, timePoint);
-    }
-
-    public Distance getTotalDistanceTraveled(Competitor competitor, TimePoint timePoint) {
-        return fullLeaderboard.getTotalDistanceTraveled(competitor, timePoint);
-    }
-
     public Double getNetPoints(Competitor competitor, RaceColumn raceColumn, Iterable<RaceColumn> raceColumnsToConsider,
             TimePoint timePoint) throws NoWindException {
         return fullLeaderboard.getNetPoints(competitor, raceColumn, raceColumnsToConsider, timePoint);
@@ -389,18 +362,6 @@ public class RegattaLeaderboardCountingButNotRankingSuppressedImpl implements Re
         return fullLeaderboard.getDefaultCourseArea();
     }
 
-    public void destroy() {
-        fullLeaderboard.destroy();
-    }
-
-    public LeaderboardDTO getLeaderboardDTO(TimePoint timePoint,
-            Collection<String> namesOfRaceColumnsForWhichToLoadLegDetails, boolean addOverallDetails,
-            TrackedRegattaRegistry trackedRegattaRegistry, DomainFactory baseDomainFactory,
-            boolean fillTotalPointsUncorrected) throws NoWindException, InterruptedException, ExecutionException {
-        return fullLeaderboard.getLeaderboardDTO(timePoint, namesOfRaceColumnsForWhichToLoadLegDetails,
-                addOverallDetails, trackedRegattaRegistry, baseDomainFactory, fillTotalPointsUncorrected);
-    }
-
     public NumberOfCompetitorsInLeaderboardFetcher getNumberOfCompetitorsInLeaderboardFetcher() {
         return fullLeaderboard.getNumberOfCompetitorsInLeaderboardFetcher();
     }
@@ -412,4 +373,9 @@ public class RegattaLeaderboardCountingButNotRankingSuppressedImpl implements Re
     public BoatClass getBoatClass() {
         return fullLeaderboard.getBoatClass();
     }
+
+    @Override
+    protected LeaderboardType getLeaderboardType() {
+        return LeaderboardType.RegattaLeaderboard;
+    }
 }