Merge branch 'design2015' into design2015-mobile

Conflicts:
	java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/home/client/place/event/partials/racelist/AbstractRaceList.java

java/com.sap.sailing.domain.persistence/src/com/sap/sailing/domain/persistence/impl/DomainObjectFactoryImpl.java

@@ -35,7 +35,7 @@ import com.mongodb.util.JSON;
 import com.sap.sailing.domain.abstractlog.AbstractLogEventAuthor;
 import com.sap.sailing.domain.abstractlog.impl.LogEventAuthorImpl;
 import com.sap.sailing.domain.abstractlog.race.CompetitorResults;
-import com.sap.sailing.domain.abstractlog.race.FixedMarkPassingEvent;
+import com.sap.sailing.domain.abstractlog.race.RaceLogFixedMarkPassingEvent;
 import com.sap.sailing.domain.abstractlog.race.RaceLog;
 import com.sap.sailing.domain.abstractlog.race.RaceLogCourseAreaChangedEvent;
 import com.sap.sailing.domain.abstractlog.race.RaceLogCourseDesignChangedEvent;
@@ -55,7 +55,7 @@ import com.sap.sailing.domain.abstractlog.race.RaceLogStartProcedureChangedEvent
 import com.sap.sailing.domain.abstractlog.race.RaceLogStartTimeEvent;
 import com.sap.sailing.domain.abstractlog.race.RaceLogWindFixEvent;
 import com.sap.sailing.domain.abstractlog.race.SimpleRaceLogIdentifier;
-import com.sap.sailing.domain.abstractlog.race.SuppressedMarkPassingsEvent;
+import com.sap.sailing.domain.abstractlog.race.RaceLogSuppressedMarkPassingsEvent;
 import com.sap.sailing.domain.abstractlog.race.impl.CompetitorResultsImpl;
 import com.sap.sailing.domain.abstractlog.race.impl.RaceLogImpl;
 import com.sap.sailing.domain.abstractlog.race.impl.SimpleRaceLogIdentifierImpl;
@@ -1396,9 +1396,9 @@ public class DomainObjectFactoryImpl implements DomainObjectFactory {
             return loadRaceLogCloseOpenEndedDeviceMappingEvent(createdAt, author, logicalTimePoint, id, passId, competitors, dbObject);
         } else if (eventClass.equals(RaceLogAdditionalScoringInformationEvent.class.getSimpleName())) {
             return loadRaceLogAdditionalScoringInformationEvent(createdAt, author, logicalTimePoint, id, passId, competitors, dbObject);
-        } else if (eventClass.equals(FixedMarkPassingEvent.class.getSimpleName())){
+        } else if (eventClass.equals(RaceLogFixedMarkPassingEvent.class.getSimpleName())){
             return loadRaceLogFixedMarkPassingEvent(createdAt, author, logicalTimePoint, id, passId, competitors, dbObject);
-        } else if (eventClass.equals(SuppressedMarkPassingsEvent.class.getSimpleName())){
+        } else if (eventClass.equals(RaceLogSuppressedMarkPassingsEvent.class.getSimpleName())){
             return loadRaceLogSuppressedMarkPassingsEvent(createdAt, author, logicalTimePoint, id, passId, competitors, dbObject);
         }
 

java/com.sap.sailing.domain.persistence/src/com/sap/sailing/domain/persistence/impl/MongoObjectFactoryImpl.java

@@ -19,7 +19,8 @@ import com.mongodb.DBObject;
 import com.mongodb.WriteConcern;
 import com.mongodb.util.JSON;
 import com.sap.sailing.domain.abstractlog.AbstractLogEventAuthor;
-import com.sap.sailing.domain.abstractlog.race.FixedMarkPassingEvent;
+import com.sap.sailing.domain.abstractlog.race.RaceLogEndOfTrackingEvent;
+import com.sap.sailing.domain.abstractlog.race.RaceLogFixedMarkPassingEvent;
 import com.sap.sailing.domain.abstractlog.race.RaceLogCourseAreaChangedEvent;
 import com.sap.sailing.domain.abstractlog.race.RaceLogCourseDesignChangedEvent;
 import com.sap.sailing.domain.abstractlog.race.RaceLogDependentStartTimeEvent;
@@ -33,10 +34,11 @@ import com.sap.sailing.domain.abstractlog.race.RaceLogPathfinderEvent;
 import com.sap.sailing.domain.abstractlog.race.RaceLogProtestStartTimeEvent;
 import com.sap.sailing.domain.abstractlog.race.RaceLogRaceStatusEvent;
 import com.sap.sailing.domain.abstractlog.race.RaceLogRevokeEvent;
+import com.sap.sailing.domain.abstractlog.race.RaceLogStartOfTrackingEvent;
 import com.sap.sailing.domain.abstractlog.race.RaceLogStartProcedureChangedEvent;
 import com.sap.sailing.domain.abstractlog.race.RaceLogStartTimeEvent;
 import com.sap.sailing.domain.abstractlog.race.RaceLogWindFixEvent;
-import com.sap.sailing.domain.abstractlog.race.SuppressedMarkPassingsEvent;
+import com.sap.sailing.domain.abstractlog.race.RaceLogSuppressedMarkPassingsEvent;
 import com.sap.sailing.domain.abstractlog.race.scoring.RaceLogAdditionalScoringInformationEvent;
 import com.sap.sailing.domain.abstractlog.race.tracking.RaceLogCloseOpenEndedDeviceMappingEvent;
 import com.sap.sailing.domain.abstractlog.race.tracking.RaceLogDefineMarkEvent;
@@ -884,6 +886,20 @@ public class MongoObjectFactoryImpl implements MongoObjectFactory {
         return result;
     }
     
+    public DBObject storeRaceLogEntry(RaceLogIdentifier raceLogIdentifier, RaceLogEndOfTrackingEvent event) {
+        BasicDBObject result = new BasicDBObject();
+        storeRaceLogIdentifier(raceLogIdentifier, result);
+        result.put(FieldNames.RACE_LOG_EVENT.name(), storeRaceLogEndOfTrackingEvent(event));
+        return result;
+    }
+
+    public DBObject storeRaceLogEntry(RaceLogIdentifier raceLogIdentifier, RaceLogStartOfTrackingEvent event) {
+        BasicDBObject result = new BasicDBObject();
+        storeRaceLogIdentifier(raceLogIdentifier, result);
+        result.put(FieldNames.RACE_LOG_EVENT.name(), storeRaceLogStartOfTrackingEvent(event));
+        return result;
+    }
+
     public DBObject storeRaceLogEntry(RaceLogIdentifier raceLogIdentifier, RaceLogAdditionalScoringInformationEvent event) {
         BasicDBObject result = new BasicDBObject();
         storeRaceLogIdentifier(raceLogIdentifier, result);
@@ -899,14 +915,14 @@ public class MongoObjectFactoryImpl implements MongoObjectFactory {
         return result;
     }
 
-    public DBObject storeRaceLogEntry(RaceLogIdentifier raceLogIdentifier, FixedMarkPassingEvent event) {
+    public DBObject storeRaceLogEntry(RaceLogIdentifier raceLogIdentifier, RaceLogFixedMarkPassingEvent event) {
         BasicDBObject result = new BasicDBObject();
         storeRaceLogIdentifier(raceLogIdentifier, result);
         result.put(FieldNames.RACE_LOG_EVENT.name(), storeRaceLogFixedMarkPassingEvent(event));
         return result;
     }
 
-    public DBObject storeRaceLogEntry(RaceLogIdentifier raceLogIdentifier, SuppressedMarkPassingsEvent event) {
+    public DBObject storeRaceLogEntry(RaceLogIdentifier raceLogIdentifier, RaceLogSuppressedMarkPassingsEvent event) {
         BasicDBObject result = new BasicDBObject();
         storeRaceLogIdentifier(raceLogIdentifier, result);
         result.put(FieldNames.RACE_LOG_EVENT.name(), storeRaceLogSuppressedMarkPassingsEvent(event));
@@ -929,6 +945,20 @@ public class MongoObjectFactoryImpl implements MongoObjectFactory {
         return result;
     }
 
+    private Object storeRaceLogEndOfTrackingEvent(RaceLogEndOfTrackingEvent event) {
+        DBObject result = new BasicDBObject();
+        storeRaceLogEventProperties(event, result);
+        result.put(FieldNames.RACE_LOG_EVENT_CLASS.name(), RaceLogEndOfTrackingEvent.class.getSimpleName());
+        return result;
+    }
+
+    private Object storeRaceLogStartOfTrackingEvent(RaceLogStartOfTrackingEvent event) {
+        DBObject result = new BasicDBObject();
+        storeRaceLogEventProperties(event, result);
+        result.put(FieldNames.RACE_LOG_EVENT_CLASS.name(), RaceLogStartOfTrackingEvent.class.getSimpleName());
+        return result;
+    }
+
     private Object storeRaceLogStartProcedureChangedEvent(RaceLogStartProcedureChangedEvent event) {
         DBObject result = new BasicDBObject();
         storeRaceLogEventProperties(event, result);
@@ -1030,19 +1060,19 @@ public class MongoObjectFactoryImpl implements MongoObjectFactory {
         return result;
     }
 
-    private Object storeRaceLogFixedMarkPassingEvent(FixedMarkPassingEvent event) {
+    private Object storeRaceLogFixedMarkPassingEvent(RaceLogFixedMarkPassingEvent event) {
         DBObject result = new BasicDBObject();
         storeRaceLogEventProperties(event, result);
-        result.put(FieldNames.RACE_LOG_EVENT_CLASS.name(), FixedMarkPassingEvent.class.getSimpleName());
+        result.put(FieldNames.RACE_LOG_EVENT_CLASS.name(), RaceLogFixedMarkPassingEvent.class.getSimpleName());
         result.put(FieldNames.INDEX_OF_PASSED_WAYPOINT.name(), event.getZeroBasedIndexOfPassedWaypoint());
         result.put(FieldNames.TIMEPOINT_OF_FIXED_MARKPASSING.name(), event.getTimePointOfFixedPassing().asMillis());
         return result;
     }
 
-    private Object storeRaceLogSuppressedMarkPassingsEvent(SuppressedMarkPassingsEvent event) {
+    private Object storeRaceLogSuppressedMarkPassingsEvent(RaceLogSuppressedMarkPassingsEvent event) {
         DBObject result = new BasicDBObject();
         storeRaceLogEventProperties(event, result);
-        result.put(FieldNames.RACE_LOG_EVENT_CLASS.name(), SuppressedMarkPassingsEvent.class.getSimpleName());
+        result.put(FieldNames.RACE_LOG_EVENT_CLASS.name(), RaceLogSuppressedMarkPassingsEvent.class.getSimpleName());
         result.put(FieldNames.INDEX_OF_FIRST_SUPPRESSED_WAYPOINT.name(), event.getZeroBasedIndexOfFirstSuppressedWaypoint());
         return result;
     }

java/com.sap.sailing.domain.persistence/src/com/sap/sailing/domain/persistence/impl/MongoRaceLogStoreVisitor.java

@@ -3,7 +3,8 @@ package com.sap.sailing.domain.persistence.impl;
 import java.util.logging.Logger;
 
 import com.mongodb.DBObject;
-import com.sap.sailing.domain.abstractlog.race.FixedMarkPassingEvent;
+import com.sap.sailing.domain.abstractlog.race.RaceLogEndOfTrackingEvent;
+import com.sap.sailing.domain.abstractlog.race.RaceLogFixedMarkPassingEvent;
 import com.sap.sailing.domain.abstractlog.race.RaceLogCourseAreaChangedEvent;
 import com.sap.sailing.domain.abstractlog.race.RaceLogCourseDesignChangedEvent;
 import com.sap.sailing.domain.abstractlog.race.RaceLogDependentStartTimeEvent;
@@ -17,10 +18,11 @@ import com.sap.sailing.domain.abstractlog.race.RaceLogPathfinderEvent;
 import com.sap.sailing.domain.abstractlog.race.RaceLogProtestStartTimeEvent;
 import com.sap.sailing.domain.abstractlog.race.RaceLogRaceStatusEvent;
 import com.sap.sailing.domain.abstractlog.race.RaceLogRevokeEvent;
+import com.sap.sailing.domain.abstractlog.race.RaceLogStartOfTrackingEvent;
 import com.sap.sailing.domain.abstractlog.race.RaceLogStartProcedureChangedEvent;
 import com.sap.sailing.domain.abstractlog.race.RaceLogStartTimeEvent;
 import com.sap.sailing.domain.abstractlog.race.RaceLogWindFixEvent;
-import com.sap.sailing.domain.abstractlog.race.SuppressedMarkPassingsEvent;
+import com.sap.sailing.domain.abstractlog.race.RaceLogSuppressedMarkPassingsEvent;
 import com.sap.sailing.domain.abstractlog.race.scoring.RaceLogAdditionalScoringInformationEvent;
 import com.sap.sailing.domain.abstractlog.race.tracking.RaceLogCloseOpenEndedDeviceMappingEvent;
 import com.sap.sailing.domain.abstractlog.race.tracking.RaceLogDefineMarkEvent;
@@ -178,13 +180,13 @@ public class MongoRaceLogStoreVisitor implements RaceLogEventVisitor {
     }
     
         @Override
-    public void visit(FixedMarkPassingEvent event) {
+    public void visit(RaceLogFixedMarkPassingEvent event) {
         DBObject object = mongoObjectFactory.storeRaceLogEntry(raceLogIdentifier, event);
         mongoObjectFactory.storeRaceLogEventEvent(object);
     }
 
     @Override
-    public void visit(SuppressedMarkPassingsEvent event) {
+    public void visit(RaceLogSuppressedMarkPassingsEvent event) {
         DBObject object = mongoObjectFactory.storeRaceLogEntry(raceLogIdentifier, event);
         mongoObjectFactory.storeRaceLogEventEvent(object);
     }
@@ -194,4 +196,18 @@ public class MongoRaceLogStoreVisitor implements RaceLogEventVisitor {
         DBObject object = mongoObjectFactory.storeRaceLogEntry(raceLogIdentifier, event);
         mongoObjectFactory.storeRaceLogEventEvent(object);
     }
+
+    @Override
+    public void visit(RaceLogStartOfTrackingEvent event) {
+        DBObject object = mongoObjectFactory.storeRaceLogEntry(raceLogIdentifier, event);
+        mongoObjectFactory.storeRaceLogEventEvent(object);
+        
+    }
+
+    @Override
+    public void visit(RaceLogEndOfTrackingEvent event) {
+        DBObject object = mongoObjectFactory.storeRaceLogEntry(raceLogIdentifier, event);
+        mongoObjectFactory.storeRaceLogEventEvent(object);
+        
+    }
 }

java/com.sap.sailing.domain.racelogtrackingadapter/src/com/sap/sailing/domain/racelogtracking/impl/RaceLogRaceTracker.java

@@ -18,7 +18,9 @@ import com.sap.sailing.domain.abstractlog.MultiLogAnalyzer.MapWithValueCollectio
 import com.sap.sailing.domain.abstractlog.MultiLogAnalyzer.SetReducer;
 import com.sap.sailing.domain.abstractlog.race.RaceLog;
 import com.sap.sailing.domain.abstractlog.race.RaceLogCourseDesignChangedEvent;
+import com.sap.sailing.domain.abstractlog.race.RaceLogEndOfTrackingEvent;
 import com.sap.sailing.domain.abstractlog.race.RaceLogEventVisitor;
+import com.sap.sailing.domain.abstractlog.race.RaceLogStartOfTrackingEvent;
 import com.sap.sailing.domain.abstractlog.race.analyzing.impl.LastPublishedCourseDesignFinder;
 import com.sap.sailing.domain.abstractlog.race.analyzing.impl.RaceLogResolver;
 import com.sap.sailing.domain.abstractlog.race.impl.BaseRaceLogEventVisitor;
@@ -143,6 +145,14 @@ public class RaceLogRaceTracker implements RaceTracker, GPSFixReceivedListener {
                     public void visit(RaceLogCourseDesignChangedEvent event) {
                         RaceLogRaceTracker.this.onCourseDesignChangedEvent(event);
                     }
+                    @Override
+                    public void visit(RaceLogStartOfTrackingEvent event) {
+                        RaceLogRaceTracker.this.onStartOfTrackingEvent(event);
+                    }
+                    @Override
+                    public void visit(RaceLogEndOfTrackingEvent event) {
+                        RaceLogRaceTracker.this.onEndOfTrackingEvent(event);
+                    }
                 };
                 visitors.put(log, visitor);
                 ((RaceLog) log).addListener(visitor);
@@ -389,6 +399,14 @@ public class RaceLogRaceTracker implements RaceTracker, GPSFixReceivedListener {
             startTracking(event);
         }
     }
+    
+    private void onStartOfTrackingEvent(RaceLogStartOfTrackingEvent event) {
+        trackedRace.setStartOfTrackingReceived(event.getLogicalTimePoint());
+    }
+    
+    private void onEndOfTrackingEvent(RaceLogEndOfTrackingEvent event) {
+        trackedRace.setEndOfTrackingReceived(event.getLogicalTimePoint());
+    }
 
     private void onCourseDesignChangedEvent(RaceLogCourseDesignChangedEvent event) {
         if (trackedRace != null) {

java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/abstractlog/race/RaceLogEndOfTrackingEvent.java

@@ -0,0 +1,6 @@
+package com.sap.sailing.domain.abstractlog.race;
+
+
+public interface RaceLogEndOfTrackingEvent extends RaceLogEvent {
+
+}

java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/abstractlog/race/RaceLogEventFactory.java

@@ -122,13 +122,13 @@ public interface RaceLogEventFactory {
     RaceLogCloseOpenEndedDeviceMappingEvent createCloseOpenEndedDeviceMappingEvent(TimePoint logicalTimePoint, AbstractLogEventAuthor author, int passId,
             Serializable deviceMappingEventId, TimePoint closingTimePoint);
     
-    RaceLogEvent createFixedMarkPassingEvent(TimePoint logicalTimePoint, AbstractLogEventAuthor author, Serializable id,
+    RaceLogFixedMarkPassingEvent createFixedMarkPassingEvent(TimePoint logicalTimePoint, AbstractLogEventAuthor author, Serializable id,
             List<Competitor> competitors, Integer passId, TimePoint ofFixedPassing, Integer zeroBasedIndexOfWaypoint);
 
     RaceLogAdditionalScoringInformationEvent createAdditionalScoringInformationEvent(TimePoint timePoint, Serializable id, AbstractLogEventAuthor author, int currentPassId,
             AdditionalScoringInformationType informationType);
 
-    RaceLogEvent createSuppressedMarkPassingsEvent(TimePoint logicalTimePoint, AbstractLogEventAuthor author, Serializable id,
+    RaceLogSuppressedMarkPassingsEvent createSuppressedMarkPassingsEvent(TimePoint logicalTimePoint, AbstractLogEventAuthor author, Serializable id,
             List<Competitor> competitors, Integer passId, Integer zeroBasedIndexOfFirstSuppressedWaypoint);
 
     RaceLogDependentStartTimeEvent createDependentStartTimeEvent(TimePoint logicalTimePoint,
@@ -137,4 +137,12 @@ public interface RaceLogEventFactory {
 
     RaceLogDependentStartTimeEvent createDependentStartTimeEvent(TimePoint logicalTimePoint,
             AbstractLogEventAuthor author, int passId, SimpleRaceLogIdentifier dependentOnRace, Duration startTimeDifference);
+
+    RaceLogStartOfTrackingEvent createStartOfTrackingEvent(TimePoint startOfTracking, AbstractLogEventAuthor author,
+            Serializable id, List<Competitor> competitors, Integer passId);
+
+    RaceLogEndOfTrackingEvent createEndOfTrackingEvent(TimePoint endOfTracking, AbstractLogEventAuthor author,
+            Serializable id, List<Competitor> competitors, Integer passId);
+
+
 }

java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/abstractlog/race/RaceLogEventVisitor.java

@@ -55,9 +55,13 @@ public interface RaceLogEventVisitor {
 
     public void visit(RaceLogAdditionalScoringInformationEvent additionalScoringInformation);
     
-    public void visit(FixedMarkPassingEvent event);
+    public void visit(RaceLogFixedMarkPassingEvent event);
     
-    public void visit(SuppressedMarkPassingsEvent event);
+    public void visit(RaceLogSuppressedMarkPassingsEvent event);
     
     public void visit(RaceLogDependentStartTimeEvent event);
+    
+    public void visit(RaceLogStartOfTrackingEvent event);
+    
+    public void visit(RaceLogEndOfTrackingEvent event);
 }

java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/abstractlog/race/RaceLogFixedMarkPassingEvent.java

@@ -3,7 +3,7 @@ package com.sap.sailing.domain.abstractlog.race;
 import com.sap.sailing.domain.abstractlog.Revokable;
 import com.sap.sse.common.TimePoint;
 
-public interface FixedMarkPassingEvent extends RaceLogEvent, Revokable {
+public interface RaceLogFixedMarkPassingEvent extends RaceLogEvent, Revokable {
     
     public TimePoint getTimePointOfFixedPassing();
 

java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/abstractlog/race/RaceLogStartOfTrackingEvent.java

@@ -0,0 +1,5 @@
+package com.sap.sailing.domain.abstractlog.race;
+
+public interface RaceLogStartOfTrackingEvent extends RaceLogEvent {
+
+}

java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/abstractlog/race/RaceLogSuppressedMarkPassingsEvent.java

@@ -2,7 +2,7 @@ package com.sap.sailing.domain.abstractlog.race;
 
 import com.sap.sailing.domain.abstractlog.Revokable;
 
-public interface SuppressedMarkPassingsEvent extends RaceLogEvent, Revokable {
+public interface RaceLogSuppressedMarkPassingsEvent extends RaceLogEvent, Revokable {
     
     public Integer getZeroBasedIndexOfFirstSuppressedWaypoint();
 

java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/abstractlog/race/analyzing/impl/MarkPassingDataFinder.java

@@ -3,10 +3,10 @@ package com.sap.sailing.domain.abstractlog.race.analyzing.impl;
 import java.util.HashSet;
 import java.util.Set;
 
-import com.sap.sailing.domain.abstractlog.race.FixedMarkPassingEvent;
+import com.sap.sailing.domain.abstractlog.race.RaceLogFixedMarkPassingEvent;
 import com.sap.sailing.domain.abstractlog.race.RaceLog;
 import com.sap.sailing.domain.abstractlog.race.RaceLogEvent;
-import com.sap.sailing.domain.abstractlog.race.SuppressedMarkPassingsEvent;
+import com.sap.sailing.domain.abstractlog.race.RaceLogSuppressedMarkPassingsEvent;
 import com.sap.sailing.domain.base.Competitor;
 import com.sap.sse.common.TimePoint;
 import com.sap.sse.common.Util.Triple;
@@ -21,12 +21,12 @@ public class MarkPassingDataFinder extends RaceLogAnalyzer<Set<Triple<Competitor
     protected Set<Triple<Competitor, Integer, TimePoint>> performAnalysis() {
         Set<Triple<Competitor, Integer, TimePoint>> result = new HashSet<Triple<Competitor, Integer, TimePoint>>();
         for (RaceLogEvent event : getLog().getUnrevokedEvents()) {
-            if (event instanceof FixedMarkPassingEvent) {
-                FixedMarkPassingEvent castedEvent = (FixedMarkPassingEvent) event;
+            if (event instanceof RaceLogFixedMarkPassingEvent) {
+                RaceLogFixedMarkPassingEvent castedEvent = (RaceLogFixedMarkPassingEvent) event;
                 result.add(new Triple<Competitor, Integer, TimePoint>(castedEvent.getInvolvedBoats().get(0), castedEvent
                         .getZeroBasedIndexOfPassedWaypoint(), castedEvent.getTimePointOfFixedPassing()));
-            } else if (event instanceof SuppressedMarkPassingsEvent){
-                SuppressedMarkPassingsEvent castedEvent = (SuppressedMarkPassingsEvent) event;
+            } else if (event instanceof RaceLogSuppressedMarkPassingsEvent){
+                RaceLogSuppressedMarkPassingsEvent castedEvent = (RaceLogSuppressedMarkPassingsEvent) event;
                 result.add(new Triple<Competitor, Integer, TimePoint>(castedEvent.getInvolvedBoats().get(0), castedEvent.getZeroBasedIndexOfFirstSuppressedWaypoint(), null));
             }
         }

java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/abstractlog/race/impl/AbstractRaceLogChangedVisitor.java

@@ -1,13 +1,14 @@
 package com.sap.sailing.domain.abstractlog.race.impl;
 
-import com.sap.sailing.domain.abstractlog.race.FixedMarkPassingEvent;
 import com.sap.sailing.domain.abstractlog.race.RaceLogCourseAreaChangedEvent;
 import com.sap.sailing.domain.abstractlog.race.RaceLogCourseDesignChangedEvent;
 import com.sap.sailing.domain.abstractlog.race.RaceLogDependentStartTimeEvent;
+import com.sap.sailing.domain.abstractlog.race.RaceLogEndOfTrackingEvent;
 import com.sap.sailing.domain.abstractlog.race.RaceLogEvent;
 import com.sap.sailing.domain.abstractlog.race.RaceLogEventVisitor;
 import com.sap.sailing.domain.abstractlog.race.RaceLogFinishPositioningConfirmedEvent;
 import com.sap.sailing.domain.abstractlog.race.RaceLogFinishPositioningListChangedEvent;
+import com.sap.sailing.domain.abstractlog.race.RaceLogFixedMarkPassingEvent;
 import com.sap.sailing.domain.abstractlog.race.RaceLogFlagEvent;
 import com.sap.sailing.domain.abstractlog.race.RaceLogGateLineOpeningTimeEvent;
 import com.sap.sailing.domain.abstractlog.race.RaceLogPassChangeEvent;
@@ -15,10 +16,11 @@ import com.sap.sailing.domain.abstractlog.race.RaceLogPathfinderEvent;
 import com.sap.sailing.domain.abstractlog.race.RaceLogProtestStartTimeEvent;
 import com.sap.sailing.domain.abstractlog.race.RaceLogRaceStatusEvent;
 import com.sap.sailing.domain.abstractlog.race.RaceLogRevokeEvent;
+import com.sap.sailing.domain.abstractlog.race.RaceLogStartOfTrackingEvent;
 import com.sap.sailing.domain.abstractlog.race.RaceLogStartProcedureChangedEvent;
 import com.sap.sailing.domain.abstractlog.race.RaceLogStartTimeEvent;
+import com.sap.sailing.domain.abstractlog.race.RaceLogSuppressedMarkPassingsEvent;
 import com.sap.sailing.domain.abstractlog.race.RaceLogWindFixEvent;
-import com.sap.sailing.domain.abstractlog.race.SuppressedMarkPassingsEvent;
 import com.sap.sailing.domain.abstractlog.race.scoring.RaceLogAdditionalScoringInformationEvent;
 import com.sap.sailing.domain.abstractlog.race.tracking.RaceLogCloseOpenEndedDeviceMappingEvent;
 import com.sap.sailing.domain.abstractlog.race.tracking.RaceLogDefineMarkEvent;
@@ -136,12 +138,12 @@ public abstract class AbstractRaceLogChangedVisitor implements RaceLogEventVisit
     }
     
     @Override
-    public void visit(FixedMarkPassingEvent fixedMarkPassingEvent) {
+    public void visit(RaceLogFixedMarkPassingEvent fixedMarkPassingEvent) {
         notifyListenerAboutEventAdded(fixedMarkPassingEvent);
     }
     
     @Override
-    public void visit(SuppressedMarkPassingsEvent event) {
+    public void visit(RaceLogSuppressedMarkPassingsEvent event) {
         notifyListenerAboutEventAdded(event);        
     }
     
@@ -149,4 +151,14 @@ public abstract class AbstractRaceLogChangedVisitor implements RaceLogEventVisit
     public void visit(RaceLogDependentStartTimeEvent event) {
         notifyListenerAboutEventAdded(event);        
     }
+    
+    @Override
+    public void visit(RaceLogStartOfTrackingEvent event) {
+        notifyListenerAboutEventAdded(event);
+    }
+    
+    @Override
+    public void visit(RaceLogEndOfTrackingEvent event) {
+        notifyListenerAboutEventAdded(event);
+    }
 }

java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/abstractlog/race/impl/BaseRaceLogEventVisitor.java

@@ -1,6 +1,7 @@
 package com.sap.sailing.domain.abstractlog.race.impl;
 
-import com.sap.sailing.domain.abstractlog.race.FixedMarkPassingEvent;
+import com.sap.sailing.domain.abstractlog.race.RaceLogEndOfTrackingEvent;
+import com.sap.sailing.domain.abstractlog.race.RaceLogFixedMarkPassingEvent;
 import com.sap.sailing.domain.abstractlog.race.RaceLogCourseAreaChangedEvent;
 import com.sap.sailing.domain.abstractlog.race.RaceLogCourseDesignChangedEvent;
 import com.sap.sailing.domain.abstractlog.race.RaceLogDependentStartTimeEvent;
@@ -14,10 +15,11 @@ import com.sap.sailing.domain.abstractlog.race.RaceLogPathfinderEvent;
 import com.sap.sailing.domain.abstractlog.race.RaceLogProtestStartTimeEvent;
 import com.sap.sailing.domain.abstractlog.race.RaceLogRaceStatusEvent;
 import com.sap.sailing.domain.abstractlog.race.RaceLogRevokeEvent;
+import com.sap.sailing.domain.abstractlog.race.RaceLogStartOfTrackingEvent;
 import com.sap.sailing.domain.abstractlog.race.RaceLogStartProcedureChangedEvent;
 import com.sap.sailing.domain.abstractlog.race.RaceLogStartTimeEvent;
 import com.sap.sailing.domain.abstractlog.race.RaceLogWindFixEvent;
-import com.sap.sailing.domain.abstractlog.race.SuppressedMarkPassingsEvent;
+import com.sap.sailing.domain.abstractlog.race.RaceLogSuppressedMarkPassingsEvent;
 import com.sap.sailing.domain.abstractlog.race.scoring.RaceLogAdditionalScoringInformationEvent;
 import com.sap.sailing.domain.abstractlog.race.tracking.RaceLogCloseOpenEndedDeviceMappingEvent;
 import com.sap.sailing.domain.abstractlog.race.tracking.RaceLogDefineMarkEvent;
@@ -143,12 +145,12 @@ public abstract class BaseRaceLogEventVisitor implements RaceLogEventVisitor {
     }
     
     @Override
-    public void visit(FixedMarkPassingEvent event){
+    public void visit(RaceLogFixedMarkPassingEvent event){
         
     }
 
     @Override
-    public void visit(SuppressedMarkPassingsEvent event) {
+    public void visit(RaceLogSuppressedMarkPassingsEvent event) {
         
     }
     
@@ -156,4 +158,14 @@ public abstract class BaseRaceLogEventVisitor implements RaceLogEventVisitor {
     public void visit(RaceLogDependentStartTimeEvent event) {
         
     }
+    
+    @Override
+    public void visit(RaceLogEndOfTrackingEvent event) {
+        
+    }
+    
+    @Override
+    public void visit(RaceLogStartOfTrackingEvent event) {
+        
+    }
 }

java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/abstractlog/race/impl/RaceLogEndOfTrackingEventImpl.java

@@ -0,0 +1,26 @@
+package com.sap.sailing.domain.abstractlog.race.impl;
+
+import java.io.Serializable;
+import java.util.List;
+
+import com.sap.sailing.domain.abstractlog.AbstractLogEventAuthor;
+import com.sap.sailing.domain.abstractlog.race.RaceLogEndOfTrackingEvent;
+import com.sap.sailing.domain.abstractlog.race.RaceLogEventVisitor;
+import com.sap.sailing.domain.base.Competitor;
+import com.sap.sse.common.TimePoint;
+
+public class RaceLogEndOfTrackingEventImpl extends RaceLogEventImpl implements RaceLogEndOfTrackingEvent {
+
+    public RaceLogEndOfTrackingEventImpl(TimePoint createdAt, AbstractLogEventAuthor author,
+            TimePoint endOfTracking, Serializable pId, List<Competitor> pInvolvedBoats, int pPassId) {
+        super(createdAt, author, endOfTracking, pId, pInvolvedBoats, pPassId);
+
+    }
+
+    @Override
+    public void accept(RaceLogEventVisitor visitor) {
+        visitor.visit(this);
+
+    }
+
+}

java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/abstractlog/race/impl/RaceLogEventFactoryImpl.java

@@ -11,9 +11,11 @@ import com.sap.sailing.domain.abstractlog.race.CompetitorResults;
 import com.sap.sailing.domain.abstractlog.race.RaceLogCourseAreaChangedEvent;
 import com.sap.sailing.domain.abstractlog.race.RaceLogCourseDesignChangedEvent;
 import com.sap.sailing.domain.abstractlog.race.RaceLogDependentStartTimeEvent;
+import com.sap.sailing.domain.abstractlog.race.RaceLogEndOfTrackingEvent;
 import com.sap.sailing.domain.abstractlog.race.RaceLogEvent;
 import com.sap.sailing.domain.abstractlog.race.RaceLogEventFactory;
 import com.sap.sailing.domain.abstractlog.race.RaceLogFinishPositioningConfirmedEvent;
+import com.sap.sailing.domain.abstractlog.race.RaceLogFixedMarkPassingEvent;
 import com.sap.sailing.domain.abstractlog.race.RaceLogFlagEvent;
 import com.sap.sailing.domain.abstractlog.race.RaceLogGateLineOpeningTimeEvent;
 import com.sap.sailing.domain.abstractlog.race.RaceLogPassChangeEvent;
@@ -21,8 +23,10 @@ import com.sap.sailing.domain.abstractlog.race.RaceLogPathfinderEvent;
 import com.sap.sailing.domain.abstractlog.race.RaceLogProtestStartTimeEvent;
 import com.sap.sailing.domain.abstractlog.race.RaceLogRaceStatusEvent;
 import com.sap.sailing.domain.abstractlog.race.RaceLogRevokeEvent;
+import com.sap.sailing.domain.abstractlog.race.RaceLogStartOfTrackingEvent;
 import com.sap.sailing.domain.abstractlog.race.RaceLogStartProcedureChangedEvent;
 import com.sap.sailing.domain.abstractlog.race.RaceLogStartTimeEvent;
+import com.sap.sailing.domain.abstractlog.race.RaceLogSuppressedMarkPassingsEvent;
 import com.sap.sailing.domain.abstractlog.race.RaceLogWindFixEvent;
 import com.sap.sailing.domain.abstractlog.race.SimpleRaceLogIdentifier;
 import com.sap.sailing.domain.abstractlog.race.scoring.AdditionalScoringInformationType;
@@ -298,16 +302,28 @@ public class RaceLogEventFactoryImpl implements RaceLogEventFactory {
     }
 
     @Override
-    public RaceLogEvent createFixedMarkPassingEvent(TimePoint logicalTimePoint, AbstractLogEventAuthor author,
+    public RaceLogFixedMarkPassingEvent createFixedMarkPassingEvent(TimePoint logicalTimePoint, AbstractLogEventAuthor author,
             Serializable id, List<Competitor> competitors, Integer passId, TimePoint ofFixedPassing, Integer zeroBasedIndexOfWaypoint) {
-        return new FixedMarkPassingEventImpl(MillisecondsTimePoint.now(), author, logicalTimePoint, id, competitors, passId, ofFixedPassing,
+        return new RaceLogFixedMarkPassingEventImpl(MillisecondsTimePoint.now(), author, logicalTimePoint, id, competitors, passId, ofFixedPassing,
                 zeroBasedIndexOfWaypoint);
     }
 
     @Override
-    public RaceLogEvent createSuppressedMarkPassingsEvent(TimePoint logicalTimePoint, AbstractLogEventAuthor author, Serializable id,
+    public RaceLogSuppressedMarkPassingsEvent createSuppressedMarkPassingsEvent(TimePoint logicalTimePoint, AbstractLogEventAuthor author, Serializable id,
             List<Competitor> competitors, Integer passId, Integer zeroBasedIndexOfFirstSuppressedWaypoint) {
-        return new SuppressedMarkPassingsEventImpl(MillisecondsTimePoint.now(), author, logicalTimePoint, id, competitors, passId,
+        return new RaceLogSuppressedMarkPassingsEventImpl(MillisecondsTimePoint.now(), author, logicalTimePoint, id, competitors, passId,
                 zeroBasedIndexOfFirstSuppressedWaypoint);
     }
+    
+    @Override
+    public RaceLogStartOfTrackingEvent createStartOfTrackingEvent(TimePoint startOfTracking, AbstractLogEventAuthor author, Serializable id,
+            List<Competitor> competitors, Integer passId) {
+        return new RaceLogStartOfTrackingEventImpl(MillisecondsTimePoint.now(), author, startOfTracking, id, competitors, passId);
+    }
+    
+    @Override
+    public RaceLogEndOfTrackingEvent createEndOfTrackingEvent(TimePoint endOfTracking, AbstractLogEventAuthor author, Serializable id,
+            List<Competitor> competitors, Integer passId) {
+        return new RaceLogEndOfTrackingEventImpl(MillisecondsTimePoint.now(), author, endOfTracking, id, competitors, passId);
+    }
 }

java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/abstractlog/race/impl/RaceLogFixedMarkPassingEventImpl.java

@@ -4,19 +4,19 @@ import java.io.Serializable;
 import java.util.List;
 
 import com.sap.sailing.domain.abstractlog.AbstractLogEventAuthor;
-import com.sap.sailing.domain.abstractlog.race.FixedMarkPassingEvent;
+import com.sap.sailing.domain.abstractlog.race.RaceLogFixedMarkPassingEvent;
 import com.sap.sailing.domain.abstractlog.race.RaceLogEventVisitor;
 import com.sap.sailing.domain.base.Competitor;
 import com.sap.sse.common.TimePoint;
 
 
-public class FixedMarkPassingEventImpl extends RaceLogEventImpl implements FixedMarkPassingEvent {
+public class RaceLogFixedMarkPassingEventImpl extends RaceLogEventImpl implements RaceLogFixedMarkPassingEvent {
 
     private final Integer zeroBasedIndexOfWaypointOfPassing;
     
     private final TimePoint timePointOfPassing;
 
-    public FixedMarkPassingEventImpl(TimePoint createdAt, AbstractLogEventAuthor author, TimePoint logicalTimePoint,
+    public RaceLogFixedMarkPassingEventImpl(TimePoint createdAt, AbstractLogEventAuthor author, TimePoint logicalTimePoint,
             Serializable pId, List<Competitor> pInvolvedBoats, int pPassId, TimePoint timePoint, Integer zeroBasedIndexOfWaypointOfPassing) {
         super(createdAt, author, logicalTimePoint, pId, pInvolvedBoats, pPassId);
         this.timePointOfPassing = timePoint;

java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/abstractlog/race/impl/RaceLogStartOfTrackingEventImpl.java

@@ -0,0 +1,25 @@
+package com.sap.sailing.domain.abstractlog.race.impl;
+
+import java.io.Serializable;
+import java.util.List;
+
+import com.sap.sailing.domain.abstractlog.AbstractLogEventAuthor;
+import com.sap.sailing.domain.abstractlog.race.RaceLogEventVisitor;
+import com.sap.sailing.domain.abstractlog.race.RaceLogStartOfTrackingEvent;
+import com.sap.sailing.domain.base.Competitor;
+import com.sap.sse.common.TimePoint;
+
+public class RaceLogStartOfTrackingEventImpl extends RaceLogEventImpl implements RaceLogStartOfTrackingEvent {
+
+    public RaceLogStartOfTrackingEventImpl(TimePoint createdAt, AbstractLogEventAuthor author,
+            TimePoint startOfTracking, Serializable pId, List<Competitor> pInvolvedBoats, int pPassId) {
+        super(createdAt, author, startOfTracking, pId, pInvolvedBoats, pPassId);
+        // TODO Auto-generated constructor stub
+    }
+
+    @Override
+    public void accept(RaceLogEventVisitor visitor) {
+        visitor.visit(this);
+    }
+
+}

java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/abstractlog/race/impl/RaceLogSuppressedMarkPassingsEventImpl.java

@@ -5,17 +5,17 @@ import java.util.List;
 
 import com.sap.sailing.domain.abstractlog.AbstractLogEventAuthor;
 import com.sap.sailing.domain.abstractlog.race.RaceLogEventVisitor;
-import com.sap.sailing.domain.abstractlog.race.SuppressedMarkPassingsEvent;
+import com.sap.sailing.domain.abstractlog.race.RaceLogSuppressedMarkPassingsEvent;
 import com.sap.sailing.domain.base.Competitor;
 import com.sap.sse.common.TimePoint;
 
-public class SuppressedMarkPassingsEventImpl extends RaceLogEventImpl implements SuppressedMarkPassingsEvent {
+public class RaceLogSuppressedMarkPassingsEventImpl extends RaceLogEventImpl implements RaceLogSuppressedMarkPassingsEvent {
 
     private static final long serialVersionUID = 3665678555023150888L;
 
     private final Integer indexOfFirstSuppressedWaypoint;
 
-    public SuppressedMarkPassingsEventImpl(TimePoint createdAt, AbstractLogEventAuthor author, TimePoint logicalTimePoint, Serializable pId,
+    public RaceLogSuppressedMarkPassingsEventImpl(TimePoint createdAt, AbstractLogEventAuthor author, TimePoint logicalTimePoint, Serializable pId,
             List<Competitor> pInvolvedBoats, int pPassId, Integer indexOfFirstSuppressedWaypoint) {
         super(createdAt, author, logicalTimePoint, pId, pInvolvedBoats, pPassId);
         this.indexOfFirstSuppressedWaypoint = indexOfFirstSuppressedWaypoint;

java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/base/Leg.java

@@ -2,8 +2,23 @@ package com.sap.sailing.domain.base;
 
 import java.io.Serializable;
 
-public interface Leg extends Serializable {
+/**
+ * When two legs are compared, their natural order is by the index of their {@link #getFrom() start waypoint} in the
+ * {@link Course} to which they belong. A leg closer to the beginning of the course ranks "less" than one that is closer
+ * to the end of the course.
+ * 
+ * @author Axel Uhl (D043530)
+ *
+ */
+public interface Leg extends Serializable, Comparable<Leg> {
     Waypoint getFrom();
 
     Waypoint getTo();
+    
+    /**
+     * The index of this leg's {@link #getFrom() start waypoint} in the sequence of the
+     * {@link Course}'s {@link Course#getWaypoints waypoints}. The first waypoint in
+     * the course has index 0.
+     */
+    int getZeroBasedIndexOfStartWaypoint();
 }

java/com.sap.sailing.domain.test/src/com/sap/sailing/domain/ranking/TestFarthestAheadWithSkippedMarkPassing.java

@@ -0,0 +1,204 @@
+package com.sap.sailing.domain.ranking;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertSame;
+import static org.mockito.Mockito.mock;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+import java.util.function.Function;
+
+import org.junit.Test;
+
+import com.sap.sailing.domain.abstractlog.race.analyzing.impl.RaceLogResolver;
+import com.sap.sailing.domain.base.Competitor;
+import com.sap.sailing.domain.base.ControlPoint;
+import com.sap.sailing.domain.base.Course;
+import com.sap.sailing.domain.base.DomainFactory;
+import com.sap.sailing.domain.base.Mark;
+import com.sap.sailing.domain.base.RaceDefinition;
+import com.sap.sailing.domain.base.Regatta;
+import com.sap.sailing.domain.base.Sideline;
+import com.sap.sailing.domain.base.Waypoint;
+import com.sap.sailing.domain.base.impl.BoatClassImpl;
+import com.sap.sailing.domain.base.impl.ControlPointWithTwoMarksImpl;
+import com.sap.sailing.domain.base.impl.CourseImpl;
+import com.sap.sailing.domain.base.impl.MarkImpl;
+import com.sap.sailing.domain.base.impl.RaceDefinitionImpl;
+import com.sap.sailing.domain.base.impl.RegattaImpl;
+import com.sap.sailing.domain.base.impl.WaypointImpl;
+import com.sap.sailing.domain.common.RankingMetrics;
+import com.sap.sailing.domain.common.ScoringSchemeType;
+import com.sap.sailing.domain.common.WindSourceType;
+import com.sap.sailing.domain.common.impl.DegreeBearingImpl;
+import com.sap.sailing.domain.common.impl.DegreePosition;
+import com.sap.sailing.domain.common.impl.KnotSpeedWithBearingImpl;
+import com.sap.sailing.domain.common.impl.WindImpl;
+import com.sap.sailing.domain.common.impl.WindSourceImpl;
+import com.sap.sailing.domain.common.tracking.impl.GPSFixImpl;
+import com.sap.sailing.domain.common.tracking.impl.GPSFixMovingImpl;
+import com.sap.sailing.domain.racelog.impl.EmptyRaceLogStore;
+import com.sap.sailing.domain.racelog.tracking.EmptyGPSFixStore;
+import com.sap.sailing.domain.ranking.RankingMetric.RankingInfo;
+import com.sap.sailing.domain.regattalog.impl.EmptyRegattaLogStore;
+import com.sap.sailing.domain.test.TrackBasedTest;
+import com.sap.sailing.domain.tracking.DynamicTrackedRace;
+import com.sap.sailing.domain.tracking.MarkPassing;
+import com.sap.sailing.domain.tracking.TrackedRegatta;
+import com.sap.sailing.domain.tracking.impl.DynamicTrackedRaceImpl;
+import com.sap.sailing.domain.tracking.impl.DynamicTrackedRegattaImpl;
+import com.sap.sailing.domain.tracking.impl.EmptyWindStore;
+import com.sap.sailing.domain.tracking.impl.MarkPassingImpl;
+import com.sap.sse.common.Duration;
+import com.sap.sse.common.TimePoint;
+import com.sap.sse.common.impl.MillisecondsTimePoint;
+
+/**
+ * A test for the case described in bug 2976: when a competitor has skipped a mark passing but then got one for a
+ * later waypoint, that competitor may still be the one "farthest ahead." Still, we seem to have observed a case where
+ * under these circumstances the competitor was not considered "farthest ahead" and instead another with a contiguous
+ * mark passing list was preferred.<p>
+ * 
+ * This test case establishes such a situation: two competitors, one with contiguous mark passings for the first two
+ * waypoints but not having sailed as far as the other in the second leg; the other competitor skipped the first mark
+ * passing, has one for the second waypoint and leads by windward distance in the second leg.<p>
+ * 
+ * Since the problem occurred with the {@link OneDesignRankingMetric}, we'll use that one for the set-up here.
+ * 
+ * @author Axel Uhl (D043530)
+ *
+ */
+public class TestFarthestAheadWithSkippedMarkPassing {
+    private RankingMetric rankingMetric;
+    private DynamicTrackedRace trackedRace;
+    private Competitor c1, c2;
+    private Waypoint start;
+    private Waypoint windward;
+    private Waypoint finish;
+    
+    private void setUp(TimeOnTimeFactorMapping timeOnTimeFactors, Function<Competitor, Double> timeOnDistanceFactors) {
+        c1 = TrackBasedTest.createCompetitor("SlowBoat");
+        c2 = TrackBasedTest.createCompetitor("FastBoat");
+        trackedRace = createTrackedRace(Arrays.asList(c1, c2));
+        rankingMetric = trackedRace.getRankingMetric();
+        assertEquals(120, trackedRace.getCourseLength().getNauticalMiles(), 0.02);
+        assertSame(RankingMetrics.ONE_DESIGN, trackedRace.getTrackedRegatta().getRegatta().getRankingMetricType());
+    }
+    
+    private DynamicTrackedRace createTrackedRace(Iterable<Competitor> competitors) {
+        final TimePoint timePointForFixes = MillisecondsTimePoint.now();
+        BoatClassImpl boatClass = new BoatClassImpl("Some Handicap Boat Class", /* typicallyStartsUpwind */ true);
+        Regatta regatta = new RegattaImpl(EmptyRaceLogStore.INSTANCE, EmptyRegattaLogStore.INSTANCE,
+                RegattaImpl.getDefaultName("Test Regatta", boatClass.getName()), boatClass, /*startDate*/ null, /*endDate*/ null, /* trackedRegattaRegistry */ null,
+                DomainFactory.INSTANCE.createScoringScheme(ScoringSchemeType.LOW_POINT), "123", /* courseArea */ null, OneDesignRankingMetric::new);
+        TrackedRegatta trackedRegatta = new DynamicTrackedRegattaImpl(regatta);
+        List<Waypoint> waypoints = new ArrayList<Waypoint>();
+        // create a two-lap upwind/downwind course:
+        MarkImpl left = new MarkImpl("Left lee gate buoy");
+        MarkImpl right = new MarkImpl("Right lee gate buoy");
+        ControlPoint leeGate = new ControlPointWithTwoMarksImpl(left, right, "Lee Gate");
+        Mark windwardMark = new MarkImpl("Windward mark");
+        start = new WaypointImpl(leeGate);
+        waypoints.add(start);
+        windward = new WaypointImpl(windwardMark);
+        waypoints.add(windward);
+        finish = new WaypointImpl(leeGate);
+        waypoints.add(finish);
+        Course course = new CourseImpl("Test Course", waypoints);
+        RaceDefinition race = new RaceDefinitionImpl("Test Race", course, boatClass, competitors);
+        DynamicTrackedRaceImpl trackedRace = new DynamicTrackedRaceImpl(trackedRegatta, race, Collections.<Sideline> emptyList(), EmptyWindStore.INSTANCE,
+                        EmptyGPSFixStore.INSTANCE, /* delayToLiveInMillis */ 0,
+                /* millisecondsOverWhichToAverageWind */ 30000, /* millisecondsOverWhichToAverageSpeed */ 30000,
+                /* delay for wind estimation cache invalidation */ 0, /*useMarkPassingCalculator*/ false,
+                tr->new OneDesignRankingMetric(tr), mock(RaceLogResolver.class));
+        // in this simplified artificial course, the top mark is exactly north of the right leeward gate
+        DegreePosition topPosition = new DegreePosition(1, 0);
+        trackedRace.getOrCreateTrack(left).addGPSFix(new GPSFixImpl(new DegreePosition(0, -0.000001), timePointForFixes));
+        trackedRace.getOrCreateTrack(right).addGPSFix(new GPSFixImpl(new DegreePosition(0, 0.000001), timePointForFixes));
+        trackedRace.getOrCreateTrack(windwardMark).addGPSFix(new GPSFixImpl(topPosition, timePointForFixes));
+        trackedRace.recordWind(new WindImpl(topPosition, timePointForFixes, new KnotSpeedWithBearingImpl(
+                /* speedInKnots */14.7, new DegreeBearingImpl(180))), new WindSourceImpl(WindSourceType.WEB));
+        return trackedRace;
+    }
+
+
+    /**
+     * A competitor having only the start mark passing shall be ranked farthest ahead if the only other competitor
+     * has no start mark passing.
+     */
+    @Test
+    public void testWithOneMarkPassingOnly() {
+        setUp(c -> c==c1 ? 2.0 : 1.0, c -> 0.0);
+        final TimePoint startOfRace = MillisecondsTimePoint.now();
+        final TimePoint middleOfFirstLeg = startOfRace.plus(Duration.ONE_HOUR.times(3));
+        trackedRace.updateMarkPassings(
+                c1,
+                Arrays.<MarkPassing> asList(new MarkPassingImpl(startOfRace, start, c1)));
+        trackedRace.getTrack(c1).add(
+                new GPSFixMovingImpl(new DegreePosition(0.0, 0), startOfRace, new KnotSpeedWithBearingImpl(12,
+                        new DegreeBearingImpl(45))));
+        trackedRace.getTrack(c2).add(
+                new GPSFixMovingImpl(new DegreePosition(0.0, 0), startOfRace, new KnotSpeedWithBearingImpl(12,
+                        new DegreeBearingImpl(315))));
+        trackedRace.getTrack(c1).add(
+                new GPSFixMovingImpl(new DegreePosition(0.5, 0), middleOfFirstLeg, new KnotSpeedWithBearingImpl(12,
+                        new DegreeBearingImpl(45))));
+        trackedRace.getTrack(c2).add(
+                new GPSFixMovingImpl(new DegreePosition(0.5, 0), middleOfFirstLeg, new KnotSpeedWithBearingImpl(12,
+                        new DegreeBearingImpl(315))));
+        // Both boats have climbed half of the first upwind beat; c1 is rated the faster boat (2.0), c2 has time-on-time factor 1.0.
+        // Therefore, c2 is expected to lead after applying the corrections.
+        final RankingInfo rankingInfo = rankingMetric.getRankingInfo(middleOfFirstLeg);
+        final Competitor farthestAhead = rankingInfo.getCompetitorFarthestAhead();
+        assertSame(c1, farthestAhead);
+        Comparator<Competitor> comparator = rankingMetric.getRaceRankingComparator(middleOfFirstLeg);
+        assertEquals(-1, comparator.compare(c1, c2)); // c1 is "less" than c2; better competitors rank less
+    }
+
+    /**
+     * C2 skipped the start mark passing but got a valid passing for the next waypoint. In the second leg, C2 leads
+     * by windward distance and should therefore be listed as the competitor farthest ahead by the ranking metric.
+     */
+    @Test
+    public void testWithTwoMarkPassingsForC1AndSkippedStartForC2() {
+        setUp(c -> c==c1 ? 2.0 : 1.0, c -> 0.0);
+        final TimePoint startOfRace = MillisecondsTimePoint.now();
+        final TimePoint endOfFirstLeg = startOfRace.plus(Duration.ONE_HOUR.times(3));
+        final TimePoint middleOfSecondLeg = endOfFirstLeg.plus(Duration.ONE_MINUTE.times(10));
+        trackedRace.updateMarkPassings(
+                c1,
+                Arrays.<MarkPassing> asList(new MarkPassingImpl(startOfRace, start, c1), new MarkPassingImpl(endOfFirstLeg, windward, c1)));
+        trackedRace.updateMarkPassings(
+                c2,
+                Arrays.<MarkPassing> asList(/* skipping start waypoint */ new MarkPassingImpl(endOfFirstLeg, windward, c2)));
+        // they both start at the start line
+        trackedRace.getTrack(c1).add(
+                new GPSFixMovingImpl(new DegreePosition(0.0, 0), startOfRace, new KnotSpeedWithBearingImpl(12,
+                        new DegreeBearingImpl(45))));
+        trackedRace.getTrack(c2).add(
+                new GPSFixMovingImpl(new DegreePosition(0.0, 0), startOfRace, new KnotSpeedWithBearingImpl(12,
+                        new DegreeBearingImpl(315))));
+        // both round the windward mark at the same time
+        trackedRace.getTrack(c1).add(
+                new GPSFixMovingImpl(new DegreePosition(1.0, 0), endOfFirstLeg, new KnotSpeedWithBearingImpl(12,
+                        new DegreeBearingImpl(45))));
+        trackedRace.getTrack(c2).add(
+                new GPSFixMovingImpl(new DegreePosition(1.0, 0), endOfFirstLeg, new KnotSpeedWithBearingImpl(12,
+                        new DegreeBearingImpl(315))));
+        // c2 is further down the wind already at the middle of the second leg:
+        trackedRace.getTrack(c1).add(
+                new GPSFixMovingImpl(new DegreePosition(0.5, 0), middleOfSecondLeg, new KnotSpeedWithBearingImpl(12,
+                        new DegreeBearingImpl(180))));
+        trackedRace.getTrack(c2).add(
+                new GPSFixMovingImpl(new DegreePosition(0.2, 0), middleOfSecondLeg, new KnotSpeedWithBearingImpl(12,
+                        new DegreeBearingImpl(180))));
+        // Assert that c2 is the boat farthest ahead
+        final RankingInfo rankingInfo = rankingMetric.getRankingInfo(middleOfSecondLeg);
+        assertSame(c2, rankingInfo.getCompetitorFarthestAhead());
+        Comparator<Competitor> comparator = rankingMetric.getRaceRankingComparator(middleOfSecondLeg);
+        assertEquals(1, comparator.compare(c1, c2)); // c1 is "less" than c2; better competitors rank less
+    }
+}

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

@@ -28,4 +28,14 @@ public class LegImpl implements Leg {
     public String toString() {
         return getFrom() + " -> " + getTo();
     }
+
+    @Override
+    public int getZeroBasedIndexOfStartWaypoint() {
+        return indexOfStartWaypoint;
+    }
+
+    @Override
+    public int compareTo(Leg o) {
+        return getZeroBasedIndexOfStartWaypoint() - o.getZeroBasedIndexOfStartWaypoint();
+    }
 }

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

@@ -2,7 +2,8 @@ package com.sap.sailing.domain.base.impl;
 
 import java.io.Serializable;
 
-import com.sap.sailing.domain.abstractlog.race.FixedMarkPassingEvent;
+import com.sap.sailing.domain.abstractlog.race.RaceLogEndOfTrackingEvent;
+import com.sap.sailing.domain.abstractlog.race.RaceLogFixedMarkPassingEvent;
 import com.sap.sailing.domain.abstractlog.race.RaceLogCourseAreaChangedEvent;
 import com.sap.sailing.domain.abstractlog.race.RaceLogCourseDesignChangedEvent;
 import com.sap.sailing.domain.abstractlog.race.RaceLogDependentStartTimeEvent;
@@ -17,10 +18,11 @@ import com.sap.sailing.domain.abstractlog.race.RaceLogPathfinderEvent;
 import com.sap.sailing.domain.abstractlog.race.RaceLogProtestStartTimeEvent;
 import com.sap.sailing.domain.abstractlog.race.RaceLogRaceStatusEvent;
 import com.sap.sailing.domain.abstractlog.race.RaceLogRevokeEvent;
+import com.sap.sailing.domain.abstractlog.race.RaceLogStartOfTrackingEvent;
 import com.sap.sailing.domain.abstractlog.race.RaceLogStartProcedureChangedEvent;
 import com.sap.sailing.domain.abstractlog.race.RaceLogStartTimeEvent;
 import com.sap.sailing.domain.abstractlog.race.RaceLogWindFixEvent;
-import com.sap.sailing.domain.abstractlog.race.SuppressedMarkPassingsEvent;
+import com.sap.sailing.domain.abstractlog.race.RaceLogSuppressedMarkPassingsEvent;
 import com.sap.sailing.domain.abstractlog.race.scoring.RaceLogAdditionalScoringInformationEvent;
 import com.sap.sailing.domain.abstractlog.race.tracking.RaceLogCloseOpenEndedDeviceMappingEvent;
 import com.sap.sailing.domain.abstractlog.race.tracking.RaceLogDefineMarkEvent;
@@ -156,12 +158,12 @@ public class RaceColumnRaceLogReplicator implements RaceLogEventVisitor, Seriali
     }
 
     @Override
-    public void visit(FixedMarkPassingEvent event) {
+    public void visit(RaceLogFixedMarkPassingEvent event) {
         notifyOnAdd(event);
     }
 
     @Override
-    public void visit(SuppressedMarkPassingsEvent event) {
+    public void visit(RaceLogSuppressedMarkPassingsEvent event) {
         notifyOnAdd(event);
     }
 
@@ -174,4 +176,14 @@ public class RaceColumnRaceLogReplicator implements RaceLogEventVisitor, Seriali
     public void visit(RaceLogDependentStartTimeEvent event) {
         notifyOnAdd(event);
     }
+
+    @Override
+    public void visit(RaceLogStartOfTrackingEvent event) {
+        notifyOnAdd(event);        
+    }
+
+    @Override
+    public void visit(RaceLogEndOfTrackingEvent event) {
+        notifyOnAdd(event);        
+    }
 }

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

@@ -1140,10 +1140,10 @@ public abstract class AbstractSimpleLeaderboardImpl implements Leaderboard, Race
             } else {
                 suppressedCompetitors.remove(competitor);
             }
-            getScoreCorrection().notifyListenersAboutIsSuppressedChange(competitor, suppressed);
         } finally {
             LockUtil.unlockAfterWrite(suppressedCompetitorsLock);
         }
+        getScoreCorrection().notifyListenersAboutIsSuppressedChange(competitor, suppressed);
     }
 
     @Override

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

@@ -2,11 +2,14 @@ package com.sap.sailing.domain.tracking.impl;
 
 import java.util.Collections;
 import java.util.Comparator;
+import java.util.List;
 import java.util.NavigableSet;
 import java.util.SortedSet;
+import java.util.logging.Logger;
 
 import com.sap.sailing.domain.base.Competitor;
 import com.sap.sailing.domain.base.Course;
+import com.sap.sailing.domain.base.Leg;
 import com.sap.sailing.domain.tracking.MarkPassing;
 import com.sap.sailing.domain.tracking.TrackedLegOfCompetitor;
 import com.sap.sailing.domain.tracking.TrackedRace;
@@ -35,6 +38,7 @@ import com.sap.sse.common.TimePoint;
  * 
  */
 public abstract class AbstractRaceRankComparator<C extends Comparable<C>> implements Comparator<Competitor> {
+    private static final Logger logger = Logger.getLogger(AbstractRaceRankComparator.class.getName());
     private final TrackedRace trackedRace;
     private final TimePoint timePoint;
     private final DummyMarkPassingWithTimePointOnly markPassingWithTimePoint;
@@ -59,6 +63,7 @@ public abstract class AbstractRaceRankComparator<C extends Comparable<C>> implem
         if (o1 == o2) {
             result = 0;
         } else {
+            final Course course = trackedRace.getRace().getCourse();
             NavigableSet<MarkPassing> o1MarkPassings = trackedRace.getMarkPassings(o1);
             NavigableSet<MarkPassing> o1MarkPassingsBeforeTimePoint;
             MarkPassing o1LastMarkPassingBeforeTimePoint = null;
@@ -66,6 +71,7 @@ public abstract class AbstractRaceRankComparator<C extends Comparable<C>> implem
             TrackedLegOfCompetitor o1Leg;
             trackedRace.lockForRead(o1MarkPassings);
             try {
+                // FIXME for the XMLExportTest.testExportingESSNice2014 the "inclusive" parameter doesn't seem to work properly; problem is caused by the MarkPassingByTimeComparator falling back to competitor ID if times are equal
                 o1MarkPassingsBeforeTimePoint = o1MarkPassings.headSet(
                         markPassingWithTimePoint, /* inclusive */true);
                 o1MarkPassingsBeforeTimePointSize = o1MarkPassingsBeforeTimePoint.size();
@@ -92,32 +98,43 @@ public abstract class AbstractRaceRankComparator<C extends Comparable<C>> implem
             } finally {
                 trackedRace.unlockAfterRead(o2MarkPassings);
             }
-            result = o2MarkPassingsBeforeTimePointSize - o1MarkPassingsBeforeTimePointSize; // inverted: more legs means
-                                                                                            // smaller rank
+            final List<Leg> legs = course.getLegs();
+            result = o1LastMarkPassingBeforeTimePoint == null
+                  ? o2LastMarkPassingBeforeTimePoint == null ? 0  // both haven't started yet
+                                                             : 1  // only o2 has started; o1 is worse ("greater") than o2
+                  : o2LastMarkPassingBeforeTimePoint == null ? -1 // only o1 has started; o1 is better ("less") than o2
+                  /* both have started; any difference */    : course.getIndexOfWaypoint(o2LastMarkPassingBeforeTimePoint.getWaypoint()) -
+                  /* in last waypoint passed?          */      course.getIndexOfWaypoint(o1LastMarkPassingBeforeTimePoint.getWaypoint());
             if (result == 0 && o1MarkPassingsBeforeTimePointSize > 0) {
+                assert o2LastMarkPassingBeforeTimePoint != null;
                 // Competitors are on same leg and both have already started the first leg.
                 // TrackedLegOfCompetitor comparison also correctly uses finish times for a leg
                 // in case we have the final leg, so both competitors finished the race.
                 if (o1Leg == null) {
                     // both must already have finished race; sort by race finish time: earlier time means smaller
                     // (better) rank
+                    assert o2Leg == null;
                     result = o1LastMarkPassingBeforeTimePoint.getTimePoint().compareTo(
                             o2LastMarkPassingBeforeTimePoint.getTimePoint());
                 } else {
-                    if (o2Leg == null) {
-                        result = 1; // o1Leg != null, so o1 has started leg already, o2 hasn't
+                    assert o2Leg != null; // otherwise, o1Leg!=null && o2Leg==null, but then o1 would have a finish mark passing and o2 not
+                    if (o1Leg.getLeg() != o2Leg.getLeg()) {
+                        logger.finest("Warning: competitors "+o1+" and "+o2+" in different legs ("+
+                              o1Leg.getLeg()+" and "+o2Leg.getLeg()+", respectively) although based on their last mark passings before "+
+                                timePoint+" ("+o1LastMarkPassingBeforeTimePoint+" and "+o2LastMarkPassingBeforeTimePoint+", respectively) "+
+                                "they should be in the same leg");
+                        // strange: both have the same number of mark passings but are in different legs; something is
+                        // broken, but we can only try our best:
+                        logger.finest("Warning: competitors "+o1+" and "+o2+" in different legs ("+
+                                o1Leg.getLeg()+" and "+o2Leg.getLeg()+", respectively) although based on their last mark passings before "+
+                                  timePoint+" ("+o1LastMarkPassingBeforeTimePoint+" and "+o2LastMarkPassingBeforeTimePoint+", respectively) "+
+                                  "they should be in the same leg");
+                        result = legs.indexOf(o1Leg.getLeg()) - legs.indexOf(o2Leg.getLeg());
                     } else {
-                        if (o1Leg.getLeg() != o2Leg.getLeg()) {
-                            // strange: both have the same number of mark passings but are in different legs; something is
-                            // broken, but we can only try our best:
-                            result = trackedRace.getRace().getCourse().getLegs().indexOf(o1Leg.getLeg()) -
-                                    trackedRace.getRace().getCourse().getLegs().indexOf(o2Leg.getLeg());
-                        } else {
-                            // competitors are in same leg; compare their windward distance to go
-                            final C wwdtgO1 = getComparisonValueForSameLeg(o1);
-                            final C wwdtgO2 = getComparisonValueForSameLeg(o2);
-                            result = wwdtgO1==null?wwdtgO2==null?0:-1:wwdtgO2==null?1:(lessIsBetter?1:-1)*wwdtgO1.compareTo(wwdtgO2);
-                        }
+                        // competitors are in same leg; compare their windward distance to go
+                        final C wwdtgO1 = getComparisonValueForSameLeg(o1);
+                        final C wwdtgO2 = getComparisonValueForSameLeg(o2);
+                        result = wwdtgO1==null?wwdtgO2==null?0:-1:wwdtgO2==null?1:(lessIsBetter?1:-1)*wwdtgO1.compareTo(wwdtgO2);
                     }
                 }
             }

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

@@ -4,7 +4,7 @@ import java.util.HashSet;
 import java.util.Set;
 import java.util.logging.Logger;
 
-import com.sap.sailing.domain.abstractlog.race.FixedMarkPassingEvent;
+import com.sap.sailing.domain.abstractlog.race.RaceLogFixedMarkPassingEvent;
 import com.sap.sailing.domain.abstractlog.race.RaceLog;
 import com.sap.sailing.domain.abstractlog.race.RaceLogCourseDesignChangedEvent;
 import com.sap.sailing.domain.abstractlog.race.RaceLogDependentStartTimeEvent;
@@ -14,7 +14,7 @@ import com.sap.sailing.domain.abstractlog.race.RaceLogPassChangeEvent;
 import com.sap.sailing.domain.abstractlog.race.RaceLogRevokeEvent;
 import com.sap.sailing.domain.abstractlog.race.RaceLogStartTimeEvent;
 import com.sap.sailing.domain.abstractlog.race.RaceLogWindFixEvent;
-import com.sap.sailing.domain.abstractlog.race.SuppressedMarkPassingsEvent;
+import com.sap.sailing.domain.abstractlog.race.RaceLogSuppressedMarkPassingsEvent;
 import com.sap.sailing.domain.abstractlog.race.analyzing.impl.AbortingFlagFinder;
 import com.sap.sailing.domain.abstractlog.race.analyzing.impl.LastPublishedCourseDesignFinder;
 import com.sap.sailing.domain.abstractlog.race.analyzing.impl.MarkPassingDataFinder;
@@ -216,7 +216,7 @@ public class DynamicTrackedRaceLogListener extends BaseRaceLogEventVisitor {
     }
 
     @Override
-    public void visit(FixedMarkPassingEvent event) {
+    public void visit(RaceLogFixedMarkPassingEvent event) {
         if (markPassingUpdateListener != null) {
             markPassingUpdateListener.addFixedPassing(event.getInvolvedBoats().get(0), event.getZeroBasedIndexOfPassedWaypoint(),
                     event.getTimePointOfFixedPassing());
@@ -224,7 +224,7 @@ public class DynamicTrackedRaceLogListener extends BaseRaceLogEventVisitor {
     }
 
     @Override
-    public void visit(SuppressedMarkPassingsEvent event) {
+    public void visit(RaceLogSuppressedMarkPassingsEvent event) {
         if (markPassingUpdateListener != null) {
             markPassingUpdateListener.addSuppressedPassing(event.getInvolvedBoats().get(0),
                     event.getZeroBasedIndexOfFirstSuppressedWaypoint());
@@ -247,12 +247,12 @@ public class DynamicTrackedRaceLogListener extends BaseRaceLogEventVisitor {
                 }
 
             }
-            if (revokedEvent instanceof SuppressedMarkPassingsEvent) {
+            if (revokedEvent instanceof RaceLogSuppressedMarkPassingsEvent) {
                 markPassingUpdateListener.removeSuppressedPassing(revokedEvent.getInvolvedBoats().get(0));
             }
-            if (revokedEvent instanceof FixedMarkPassingEvent) {
+            if (revokedEvent instanceof RaceLogFixedMarkPassingEvent) {
                 markPassingUpdateListener.removeFixedPassing(revokedEvent.getInvolvedBoats().get(0),
-                        ((FixedMarkPassingEvent) revokedEvent).getZeroBasedIndexOfPassedWaypoint());
+                        ((RaceLogFixedMarkPassingEvent) revokedEvent).getZeroBasedIndexOfPassedWaypoint());
             }
         }
     }

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

@@ -6,35 +6,24 @@ import java.util.Comparator;
 import com.sap.sailing.domain.tracking.MarkPassing;
 
 /**
- * Compares two {@link MarkPassing} objects, using their {@link MarkPassing#getTimePoint() time point} as the primary
- * ordering criterion in ascending order. If two mark passings have equal time points, the competitor IDs' string
- * representations are compared as the secondary ordering criterion to ensure that two competitors passing a mark at the
- * same time are still identified as not being equal.
+ * Compares two {@link MarkPassing} objects, using their {@link MarkPassing#getTimePoint() time point} as the only
+ * ordering criterion in ascending order. If two mark passings have equal time points, they are considered equal,
+ * regardless the competitor. Don't use this comparator for collections in which mark passings for multiple competitors
+ * may be managed and shall be treated as different. Use {@link MarkPassingsByTimeAndCompetitorIdComparator} instead.
  * 
  * @author Axel Uhl (D043530)
  * 
  */
 public class MarkPassingByTimeComparator implements Comparator<MarkPassing>, Serializable {
     private static final long serialVersionUID = 5758820139503482888L;
-    public static MarkPassingByTimeComparator INSTANCE = new MarkPassingByTimeComparator();
+    public static final MarkPassingByTimeComparator INSTANCE = new MarkPassingByTimeComparator();
     
     @Override
     public int compare(MarkPassing o1, MarkPassing o2) {
-        int result = o1 == null ? o2 == null ? 0 : -1 : o2 == null ? 1 : o1.getTimePoint() == null ? (o2.getTimePoint() == null ? 0 : -1) : o2.getTimePoint() == null ? 1 : o1.getTimePoint().compareTo(o2.getTimePoint());
-        if (result == 0 && o1 != null) {
-            assert o2 != null;
-            Object c1ID = o1.getCompetitor().getId();
-            Object c2ID = o2.getCompetitor().getId();
-            // shortcut comparison and don't use expensive toString() in case IDs are comparable by nature 
-            if (c1ID instanceof Comparable<?> && c1ID.getClass() == c2ID.getClass()) {
-                @SuppressWarnings("unchecked")
-                final Comparable<Object> c1OID = (Comparable<Object>) c1ID;
-                result = c1OID.compareTo(o2.getCompetitor().getId());
-            } else {
-                result = o1.getCompetitor().getId().toString().compareTo(o2.getCompetitor().getId().toString());
-            }
-        }
-        return result;
+        return o1 == null ?
+                o2 == null ? 0 : -1
+              : o2 == null ? 1 : o1.getTimePoint() == null ?
+                      (o2.getTimePoint() == null ? 0 : -1)
+                    :  o2.getTimePoint() == null ? 1 : o1.getTimePoint().compareTo(o2.getTimePoint());
     }
-
 }

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

@@ -0,0 +1,36 @@
+package com.sap.sailing.domain.tracking.impl;
+
+import com.sap.sailing.domain.tracking.MarkPassing;
+
+/**
+ * Compares two {@link MarkPassing} objects, using their {@link MarkPassing#getTimePoint() time point} as the primary
+ * ordering criterion in ascending order. If two mark passings have equal time points, the competitor IDs' string
+ * representations are compared as the secondary ordering criterion to ensure that two competitors passing a mark at the
+ * same time are still identified as not being equal.
+ * 
+ * @author Axel Uhl (D043530)
+ * 
+ */
+public class MarkPassingsByTimeAndCompetitorIdComparator extends MarkPassingByTimeComparator {
+    private static final long serialVersionUID = 5977491869367296660L;
+    public static final MarkPassingsByTimeAndCompetitorIdComparator INSTANCE = new MarkPassingsByTimeAndCompetitorIdComparator();
+
+    @Override
+    public int compare(MarkPassing o1, MarkPassing o2) {
+        int result = super.compare(o1, o2);
+        if (result == 0 && o1 != null) {
+            assert o2 != null;
+            Object c1ID = o1.getCompetitor().getId();
+            Object c2ID = o2.getCompetitor().getId();
+            // shortcut comparison and don't use expensive toString() in case IDs are comparable by nature 
+            if (c1ID instanceof Comparable<?> && c1ID.getClass() == c2ID.getClass()) {
+                @SuppressWarnings("unchecked")
+                final Comparable<Object> c1OID = (Comparable<Object>) c1ID;
+                result = c1OID.compareTo(o2.getCompetitor().getId());
+            } else {
+                result = o1.getCompetitor().getId().toString().compareTo(o2.getCompetitor().getId().toString());
+            }
+        }
+        return result;
+    }
+}

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

@@ -452,7 +452,7 @@ public abstract class TrackedRaceImpl extends TrackedRaceWithWindEssentials impl
         markPassingsForWaypoint = new ConcurrentHashMap<Waypoint, NavigableSet<MarkPassing>>();
         for (Waypoint waypoint : race.getCourse().getWaypoints()) {
             markPassingsForWaypoint.put(waypoint, new ConcurrentSkipListSet<MarkPassing>(
-                    MarkPassingByTimeComparator.INSTANCE));
+                    MarkPassingsByTimeAndCompetitorIdComparator.INSTANCE));
         }
         markPassingsTimes = new ArrayList<com.sap.sse.common.Util.Pair<Waypoint, com.sap.sse.common.Util.Pair<TimePoint, TimePoint>>>();
         loadingFromWindStoreState = LoadingFromStoresState.NOT_STARTED;
@@ -697,7 +697,7 @@ public abstract class TrackedRaceImpl extends TrackedRaceWithWindEssentials impl
 
     protected NavigableSet<MarkPassing> createMarkPassingsCollectionForWaypoint(Waypoint waypoint) {
         final ConcurrentSkipListSet<MarkPassing> result = new ConcurrentSkipListSet<MarkPassing>(
-                MarkPassingByTimeComparator.INSTANCE);
+                MarkPassingsByTimeAndCompetitorIdComparator.INSTANCE);
         LockUtil.lockForRead(getSerializationLock());
         try {
             markPassingsForWaypoint.put(waypoint, result);

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/home/client/place/event/partials/racelist/AbstractRaceList.java

@@ -1,6 +1,5 @@
 package com.sap.sailing.gwt.home.client.place.event.partials.racelist;
 
-import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Date;
 
@@ -236,7 +235,7 @@ public abstract class AbstractRaceList<T extends RaceMetadataDTO> extends Compos
         this.cellTableContainer.setWidget(this.cellTable);
         this.initTableStyle();
         this.initTableColumns();
-        this.cellTable.setList(new ArrayList<>(data));
+        this.cellTable.setList(data);
         if (sortColumn != null && this.cellTable.getColumnIndex(sortColumn) >= 0) {
             this.cellTable.sortColumn(sortColumn);
         }

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/client/FlagImageResolver.java

@@ -1,302 +1,305 @@
-package com.sap.sailing.gwt.ui.client;
-
-import java.util.HashMap;
-import java.util.Map;
-
-import com.google.gwt.core.client.GWT;
-import com.google.gwt.resources.client.ImageResource;
-
-public class FlagImageResolver {
-
-    private static final String NONE = "none";
-
-    private static Map<String, ImageResource> flagImagesMap;
-	
-    private static FlagImageResources flagImageResources = GWT.create(FlagImageResources.class);
-
-    public static String[] flagImageNames = { "ad", "ae", "af", "ag", "ai", "al", "am", "an",
-		"ao", "ar", "as", "at", "au", "aw", "ax", "az", "ba", "bb", "bd",
-		"be", "bf", "bg", "bh", "bi", "bj", "bm", "bn", "bo", "br", "bs",
-		"bt", "bv", "bw", "by", "bz", "ca", "catalonia", "cc", "cd", "cf",
-		"cg", "ch", "ci", "ck", "cl", "cm", "cn", "co", "cr", "cs", "cu",
-		"cv", "cx", "cy", "cz", "de", "dj", "dk", "dm", "do", "dz", "ec",
-		"ee", "eg", "eh", "england", "er", "es", "et", "europeanunion",
-		"fam", "fi", "fj", "fk", "fm", "fo", "fr", "ga", "gb", "gd", "ge",
-		"gf", "gh", "gi", "gl", "gm", "gn", "gp", "gq", "gr", "gs", "gt",
-		"gu", "gw", "gy", "hk", "hm", "hn", "hr", "ht", "hu", "id", "ie",
-		"il", "in", "io", "iq", "ir", "is", "it", "jm", "jo", "jp", "ke",
-		"kg", "kh", "ki", "km", "kn", "kp", "kr", "kw", "ky", "kz", "la",
-		"lb", "lc", "li", "lk", "lr", "ls", "lt", "lu", "lv", "ly", "ma",
-		"mc", "md", "me", "mg", "mh", "mk", "ml", "mm", "mn", "mo", "mp",
-		"mq", "mr", "ms", "mt", "mu", "mv", "mw", "mx", "my", "mz", "na",
-		"nc", "ne", "nf", "ng", "ni", "nl", "no", NONE, "np", "nr", "nu", "nz",
-		"om", "pa", "pe", "pf", "pg", "ph", "pk", "pl", "pm", "pn", "pr",
-		"ps", "pt", "pw", "py", "qa", "re", "ro", "rs", "ru", "rw", "sa",
-		"sb", "sc", "scotland", "sd", "se", "sg", "sh", "si", "sj", "sk",
-		"sl", "sm", "sn", "so", "sr", "st", "sv", "sy", "sz", "tc", "td",
-		"tf", "tg", "th", "tj", "tk", "tl", "tm", "tn", "to", "tr", "tt",
-		"tv", "tw", "tz", "ua", "ug", "um", "us", "uy", "uz", "va", "vc",
-		"ve", "vg", "vi", "vn", "vu", "wales", "wf", "ws", "ye", "yt",
-		"za", "zm", "zw" };
-
-    static {
-		flagImagesMap = new HashMap<String, ImageResource>();
-		flagImagesMap.put("ad", flagImageResources.flagAD());
-		flagImagesMap.put("ae", flagImageResources.flagAE());
-		flagImagesMap.put("af", flagImageResources.flagAF());
-		flagImagesMap.put("ag", flagImageResources.flagAG());
-		flagImagesMap.put("ai", flagImageResources.flagAI());
-		flagImagesMap.put("al", flagImageResources.flagAL());
-		flagImagesMap.put("am", flagImageResources.flagAM());
-		flagImagesMap.put("an", flagImageResources.flagAN());
-		flagImagesMap.put("ao", flagImageResources.flagAO());
-		flagImagesMap.put("ar", flagImageResources.flagAR());
-		flagImagesMap.put("as", flagImageResources.flagAS());
-		flagImagesMap.put("at", flagImageResources.flagAT());
-		flagImagesMap.put("au", flagImageResources.flagAU());
-		flagImagesMap.put("aw", flagImageResources.flagAW());
-		flagImagesMap.put("ax", flagImageResources.flagAX());
-		flagImagesMap.put("az", flagImageResources.flagAZ());
-		flagImagesMap.put("ba", flagImageResources.flagBA());
-		flagImagesMap.put("bb", flagImageResources.flagBB());
-		flagImagesMap.put("bd", flagImageResources.flagBD());
-		flagImagesMap.put("be", flagImageResources.flagBE());
-		flagImagesMap.put("bf", flagImageResources.flagBF());
-		flagImagesMap.put("bg", flagImageResources.flagBG());
-		flagImagesMap.put("bh", flagImageResources.flagBH());
-		flagImagesMap.put("bi", flagImageResources.flagBI());
-		flagImagesMap.put("bj", flagImageResources.flagBJ());
-		flagImagesMap.put("bm", flagImageResources.flagBM());
-		flagImagesMap.put("bn", flagImageResources.flagBN());
-		flagImagesMap.put("bo", flagImageResources.flagBO());
-		flagImagesMap.put("br", flagImageResources.flagBR());
-		flagImagesMap.put("bs", flagImageResources.flagBS());
-		flagImagesMap.put("bt", flagImageResources.flagBT());
-		flagImagesMap.put("bv", flagImageResources.flagBV());
-		flagImagesMap.put("bw", flagImageResources.flagBW());
-		flagImagesMap.put("by", flagImageResources.flagBY());
-		flagImagesMap.put("bz", flagImageResources.flagBZ());
-		flagImagesMap.put("ca", flagImageResources.flagCA());
-		flagImagesMap.put("catalonia", flagImageResources.flagCATALONIA());
-		flagImagesMap.put("cc", flagImageResources.flagCC());
-		flagImagesMap.put("cd", flagImageResources.flagCD());
-		flagImagesMap.put("cf", flagImageResources.flagCF());
-		flagImagesMap.put("cg", flagImageResources.flagCG());
-		flagImagesMap.put("ch", flagImageResources.flagCH());
-		flagImagesMap.put("ci", flagImageResources.flagCI());
-		flagImagesMap.put("ck", flagImageResources.flagCK());
-		flagImagesMap.put("cl", flagImageResources.flagCL());
-		flagImagesMap.put("cm", flagImageResources.flagCM());
-		flagImagesMap.put("cn", flagImageResources.flagCN());
-		flagImagesMap.put("co", flagImageResources.flagCO());
-		flagImagesMap.put("cr", flagImageResources.flagCR());
-		flagImagesMap.put("cs", flagImageResources.flagCS());
-		flagImagesMap.put("cu", flagImageResources.flagCU());
-		flagImagesMap.put("cv", flagImageResources.flagCV());
-		flagImagesMap.put("cx", flagImageResources.flagCX());
-		flagImagesMap.put("cy", flagImageResources.flagCY());
-		flagImagesMap.put("cz", flagImageResources.flagCZ());
-		flagImagesMap.put("de", flagImageResources.flagDE());
-		flagImagesMap.put("dj", flagImageResources.flagDJ());
-		flagImagesMap.put("dk", flagImageResources.flagDK());
-		flagImagesMap.put("dm", flagImageResources.flagDM());
-		flagImagesMap.put("do", flagImageResources.flagDO());
-		flagImagesMap.put("dz", flagImageResources.flagDZ());
-		flagImagesMap.put("ec", flagImageResources.flagEC());
-		flagImagesMap.put("ee", flagImageResources.flagEE());
-		flagImagesMap.put("eg", flagImageResources.flagEG());
-		flagImagesMap.put("eh", flagImageResources.flagEH());
-		flagImagesMap.put("england", flagImageResources.flagENGLAND());
-		flagImagesMap.put("er", flagImageResources.flagER());
-		flagImagesMap.put("es", flagImageResources.flagES());
-		flagImagesMap.put("et", flagImageResources.flagET());
-		flagImagesMap.put("europeanunion", flagImageResources.flagEUROPEANUNION());
-		flagImagesMap.put("fam", flagImageResources.flagFAM());
-		flagImagesMap.put("fi", flagImageResources.flagFI());
-		flagImagesMap.put("fj", flagImageResources.flagFJ());
-		flagImagesMap.put("fk", flagImageResources.flagFK());
-		flagImagesMap.put("fm", flagImageResources.flagFM());
-		flagImagesMap.put("fo", flagImageResources.flagFO());
-		flagImagesMap.put("fr", flagImageResources.flagFR());
-		flagImagesMap.put("ga", flagImageResources.flagGA());
-		flagImagesMap.put("gb", flagImageResources.flagGB());
-		flagImagesMap.put("gd", flagImageResources.flagGD());
-		flagImagesMap.put("ge", flagImageResources.flagGE());
-		flagImagesMap.put("gf", flagImageResources.flagGF());
-		flagImagesMap.put("gh", flagImageResources.flagGH());
-		flagImagesMap.put("gi", flagImageResources.flagGI());
-		flagImagesMap.put("gl", flagImageResources.flagGL());
-		flagImagesMap.put("gm", flagImageResources.flagGM());
-		flagImagesMap.put("gn", flagImageResources.flagGN());
-		flagImagesMap.put("gp", flagImageResources.flagGP());
-		flagImagesMap.put("gq", flagImageResources.flagGQ());
-		flagImagesMap.put("gr", flagImageResources.flagGR());
-		flagImagesMap.put("gs", flagImageResources.flagGS());
-		flagImagesMap.put("gt", flagImageResources.flagGT());
-		flagImagesMap.put("gu", flagImageResources.flagGU());
-		flagImagesMap.put("gw", flagImageResources.flagGW());
-		flagImagesMap.put("gy", flagImageResources.flagGY());
-		flagImagesMap.put("hk", flagImageResources.flagHK());
-		flagImagesMap.put("hm", flagImageResources.flagHM());
-		flagImagesMap.put("hn", flagImageResources.flagHN());
-		flagImagesMap.put("hr", flagImageResources.flagHR());
-		flagImagesMap.put("ht", flagImageResources.flagHT());
-		flagImagesMap.put("hu", flagImageResources.flagHU());
-		flagImagesMap.put("id", flagImageResources.flagID());
-		flagImagesMap.put("ie", flagImageResources.flagIE());
-		flagImagesMap.put("il", flagImageResources.flagIL());
-		flagImagesMap.put("in", flagImageResources.flagIN());
-		flagImagesMap.put("io", flagImageResources.flagIO());
-		flagImagesMap.put("iq", flagImageResources.flagIQ());
-		flagImagesMap.put("ir", flagImageResources.flagIR());
-		flagImagesMap.put("is", flagImageResources.flagIS());
-		flagImagesMap.put("it", flagImageResources.flagIT());
-		flagImagesMap.put("jm", flagImageResources.flagJM());
-		flagImagesMap.put("jo", flagImageResources.flagJO());
-		flagImagesMap.put("jp", flagImageResources.flagJP());
-		flagImagesMap.put("ke", flagImageResources.flagKE());
-		flagImagesMap.put("kg", flagImageResources.flagKG());
-		flagImagesMap.put("kh", flagImageResources.flagKH());
-		flagImagesMap.put("ki", flagImageResources.flagKI());
-		flagImagesMap.put("km", flagImageResources.flagKM());
-		flagImagesMap.put("kn", flagImageResources.flagKN());
-		flagImagesMap.put("kp", flagImageResources.flagKP());
-		flagImagesMap.put("kr", flagImageResources.flagKR());
-		flagImagesMap.put("kw", flagImageResources.flagKW());
-		flagImagesMap.put("ky", flagImageResources.flagKY());
-		flagImagesMap.put("kz", flagImageResources.flagKZ());
-		flagImagesMap.put("la", flagImageResources.flagLA());
-		flagImagesMap.put("lb", flagImageResources.flagLB());
-		flagImagesMap.put("lc", flagImageResources.flagLC());
-		flagImagesMap.put("li", flagImageResources.flagLI());
-		flagImagesMap.put("lk", flagImageResources.flagLK());
-		flagImagesMap.put("lr", flagImageResources.flagLR());
-		flagImagesMap.put("ls", flagImageResources.flagLS());
-		flagImagesMap.put("lt", flagImageResources.flagLT());
-		flagImagesMap.put("lu", flagImageResources.flagLU());
-		flagImagesMap.put("lv", flagImageResources.flagLV());
-		flagImagesMap.put("ly", flagImageResources.flagLY());
-		flagImagesMap.put("ma", flagImageResources.flagMA());
-		flagImagesMap.put("mc", flagImageResources.flagMC());
-		flagImagesMap.put("md", flagImageResources.flagMD());
-		flagImagesMap.put("me", flagImageResources.flagME());
-		flagImagesMap.put("mg", flagImageResources.flagMG());
-		flagImagesMap.put("mh", flagImageResources.flagMH());
-		flagImagesMap.put("mk", flagImageResources.flagMK());
-		flagImagesMap.put("ml", flagImageResources.flagML());
-		flagImagesMap.put("mm", flagImageResources.flagMM());
-		flagImagesMap.put("mn", flagImageResources.flagMN());
-		flagImagesMap.put("mo", flagImageResources.flagMO());
-		flagImagesMap.put("mp", flagImageResources.flagMP());
-		flagImagesMap.put("mq", flagImageResources.flagMQ());
-		flagImagesMap.put("mr", flagImageResources.flagMR());
-		flagImagesMap.put("ms", flagImageResources.flagMS());
-		flagImagesMap.put("mt", flagImageResources.flagMT());
-		flagImagesMap.put("mu", flagImageResources.flagMU());
-		flagImagesMap.put("mv", flagImageResources.flagMV());
-		flagImagesMap.put("mw", flagImageResources.flagMW());
-		flagImagesMap.put("mx", flagImageResources.flagMX());
-		flagImagesMap.put("my", flagImageResources.flagMY());
-		flagImagesMap.put("mz", flagImageResources.flagMZ());
-		flagImagesMap.put("na", flagImageResources.flagNA());
-		flagImagesMap.put("nc", flagImageResources.flagNC());
-		flagImagesMap.put("ne", flagImageResources.flagNE());
-		flagImagesMap.put("nf", flagImageResources.flagNF());
-		flagImagesMap.put("ng", flagImageResources.flagNG());
-		flagImagesMap.put("ni", flagImageResources.flagNI());
-		flagImagesMap.put("nl", flagImageResources.flagNL());
-		flagImagesMap.put("no", flagImageResources.flagNO());
-                flagImagesMap.put(NONE, flagImageResources.flagNONE());
-		flagImagesMap.put("np", flagImageResources.flagNP());
-		flagImagesMap.put("nr", flagImageResources.flagNR());
-		flagImagesMap.put("nu", flagImageResources.flagNU());
-		flagImagesMap.put("nz", flagImageResources.flagNZ());
-		flagImagesMap.put("om", flagImageResources.flagOM());
-		flagImagesMap.put("pa", flagImageResources.flagPA());
-		flagImagesMap.put("pe", flagImageResources.flagPE());
-		flagImagesMap.put("pf", flagImageResources.flagPF());
-		flagImagesMap.put("pg", flagImageResources.flagPG());
-		flagImagesMap.put("ph", flagImageResources.flagPH());
-		flagImagesMap.put("pk", flagImageResources.flagPK());
-		flagImagesMap.put("pl", flagImageResources.flagPL());
-		flagImagesMap.put("pm", flagImageResources.flagPM());
-		flagImagesMap.put("pn", flagImageResources.flagPN());
-		flagImagesMap.put("pr", flagImageResources.flagPR());
-		flagImagesMap.put("ps", flagImageResources.flagPS());
-		flagImagesMap.put("pt", flagImageResources.flagPT());
-		flagImagesMap.put("pw", flagImageResources.flagPW());
-		flagImagesMap.put("py", flagImageResources.flagPY());
-		flagImagesMap.put("qa", flagImageResources.flagQA());
-		flagImagesMap.put("re", flagImageResources.flagRE());
-		flagImagesMap.put("ro", flagImageResources.flagRO());
-		flagImagesMap.put("rs", flagImageResources.flagRS());
-		flagImagesMap.put("ru", flagImageResources.flagRU());
-		flagImagesMap.put("rw", flagImageResources.flagRW());
-		flagImagesMap.put("sa", flagImageResources.flagSA());
-		flagImagesMap.put("sb", flagImageResources.flagSB());
-		flagImagesMap.put("sc", flagImageResources.flagSC());
-		flagImagesMap.put("scotland", flagImageResources.flagSCOTLAND());
-		flagImagesMap.put("sd", flagImageResources.flagSD());
-		flagImagesMap.put("se", flagImageResources.flagSE());
-		flagImagesMap.put("sg", flagImageResources.flagSG());
-		flagImagesMap.put("sh", flagImageResources.flagSH());
-		flagImagesMap.put("si", flagImageResources.flagSI());
-		flagImagesMap.put("sj", flagImageResources.flagSJ());
-		flagImagesMap.put("sk", flagImageResources.flagSK());
-		flagImagesMap.put("sl", flagImageResources.flagSL());
-		flagImagesMap.put("sm", flagImageResources.flagSM());
-		flagImagesMap.put("sn", flagImageResources.flagSN());
-		flagImagesMap.put("so", flagImageResources.flagSO());
-		flagImagesMap.put("sr", flagImageResources.flagSR());
-		flagImagesMap.put("st", flagImageResources.flagST());
-		flagImagesMap.put("sv", flagImageResources.flagSV());
-		flagImagesMap.put("sy", flagImageResources.flagSY());
-		flagImagesMap.put("sz", flagImageResources.flagSZ());
-		flagImagesMap.put("tc", flagImageResources.flagTC());
-		flagImagesMap.put("td", flagImageResources.flagTD());
-		flagImagesMap.put("tf", flagImageResources.flagTF());
-		flagImagesMap.put("tg", flagImageResources.flagTG());
-		flagImagesMap.put("th", flagImageResources.flagTH());
-		flagImagesMap.put("tj", flagImageResources.flagTJ());
-		flagImagesMap.put("tk", flagImageResources.flagTK());
-		flagImagesMap.put("tl", flagImageResources.flagTL());
-		flagImagesMap.put("tm", flagImageResources.flagTM());
-		flagImagesMap.put("tn", flagImageResources.flagTN());
-		flagImagesMap.put("to", flagImageResources.flagTO());
-		flagImagesMap.put("tr", flagImageResources.flagTR());
-		flagImagesMap.put("tt", flagImageResources.flagTT());
-		flagImagesMap.put("tv", flagImageResources.flagTV());
-		flagImagesMap.put("tw", flagImageResources.flagTW());
-		flagImagesMap.put("tz", flagImageResources.flagTZ());
-		flagImagesMap.put("ua", flagImageResources.flagUA());
-		flagImagesMap.put("ug", flagImageResources.flagUG());
-		flagImagesMap.put("um", flagImageResources.flagUM());
-		flagImagesMap.put("us", flagImageResources.flagUS());
-		flagImagesMap.put("uy", flagImageResources.flagUY());
-		flagImagesMap.put("uz", flagImageResources.flagUZ());
-		flagImagesMap.put("va", flagImageResources.flagVA());
-		flagImagesMap.put("vc", flagImageResources.flagVC());
-		flagImagesMap.put("ve", flagImageResources.flagVE());
-		flagImagesMap.put("vg", flagImageResources.flagVG());
-		flagImagesMap.put("vi", flagImageResources.flagVI());
-		flagImagesMap.put("vn", flagImageResources.flagVN());
-		flagImagesMap.put("vu", flagImageResources.flagVU());
-		flagImagesMap.put("wales", flagImageResources.flagWALES());
-		flagImagesMap.put("wf", flagImageResources.flagWF());
-		flagImagesMap.put("ws", flagImageResources.flagWS());
-		flagImagesMap.put("ye", flagImageResources.flagYE());
-		flagImagesMap.put("yt", flagImageResources.flagYT());
-		flagImagesMap.put("za", flagImageResources.flagZA());
-		flagImagesMap.put("zm", flagImageResources.flagZM());
-		flagImagesMap.put("zw", flagImageResources.flagZW());
-	}
-	
-	public static ImageResource getFlagImageResource(String twoLetterIsoCountryCode) {
-		return flagImagesMap.get(twoLetterIsoCountryCode.toLowerCase());
-	}
-
-    public static ImageResource getEmptyFlagImageResource() {
-        return flagImagesMap.get(NONE);
-    }
-
-}
+package com.sap.sailing.gwt.ui.client;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import com.google.gwt.core.client.GWT;
+import com.google.gwt.resources.client.ImageResource;
+import com.google.gwt.safehtml.shared.SafeUri;
+import com.google.gwt.safehtml.shared.UriUtils;
+
+public class FlagImageResolver {
+
+    private static final String NONE = "none";
+
+    private static Map<String, ImageResource> flagImagesMap;
+	
+    private static FlagImageResources flagImageResources = GWT.create(FlagImageResources.class);
+
+    public static String[] flagImageNames = { "ad", "ae", "af", "ag", "ai", "al", "am", "an", "ao", "ar", "as", "at",
+            "au", "aw", "ax", "az", "ba", "bb", "bd", "be", "bf", "bg", "bh", "bi", "bj", "bm", "bn", "bo", "br", "bs",
+            "bt", "bv", "bw", "by", "bz", "ca", "catalonia", "cc", "cd", "cf", "cg", "ch", "ci", "ck", "cl", "cm",
+            "cn", "co", "cr", "cs", "cu", "cv", "cx", "cy", "cz", "de", "dj", "dk", "dm", "do", "dz", "ec", "ee", "eg",
+            "eh", "england", "er", "es", "et", "europeanunion", "fam", "fi", "fj", "fk", "fm", "fo", "fr", "ga", "gb",
+            "gd", "ge", "gf", "gh", "gi", "gl", "gm", "gn", "gp", "gq", "gr", "gs", "gt", "gu", "gw", "gy", "hk", "hm",
+            "hn", "hr", "ht", "hu", "id", "ie", "il", "in", "io", "iq", "ir", "is", "it", "jm", "jo", "jp", "ke", "kg",
+            "kh", "ki", "km", "kn", "kp", "kr", "kw", "ky", "kz", "la", "lb", "lc", "li", "lk", "lr", "ls", "lt", "lu",
+            "lv", "ly", "ma", "mc", "md", "me", "mg", "mh", "mk", "ml", "mm", "mn", "mo", "mp", "mq", "mr", "ms", "mt",
+            "mu", "mv", "mw", "mx", "my", "mz", "na", "nc", "ne", "nf", "ng", "ni", "nl", "no", NONE, "np", "nr", "nu",
+            "nz", "om", "pa", "pe", "pf", "pg", "ph", "pk", "pl", "pm", "pn", "pr", "ps", "pt", "pw", "py", "qa", "re",
+            "ro", "rs", "ru", "rw", "sa", "sb", "sc", "scotland", "sd", "se", "sg", "sh", "si", "sj", "sk", "sl", "sm",
+            "sn", "so", "sr", "st", "sv", "sy", "sz", "tc", "td", "tf", "tg", "th", "tj", "tk", "tl", "tm", "tn", "to",
+            "tr", "tt", "tv", "tw", "tz", "ua", "ug", "um", "us", "uy", "uz", "va", "vc", "ve", "vg", "vi", "vn", "vu",
+            "wales", "wf", "ws", "ye", "yt", "za", "zm", "zw" };
+
+    static {
+        flagImagesMap = new HashMap<String, ImageResource>();
+        flagImagesMap.put("ad", flagImageResources.flagAD());
+        flagImagesMap.put("ae", flagImageResources.flagAE());
+        flagImagesMap.put("af", flagImageResources.flagAF());
+        flagImagesMap.put("ag", flagImageResources.flagAG());
+        flagImagesMap.put("ai", flagImageResources.flagAI());
+        flagImagesMap.put("al", flagImageResources.flagAL());
+        flagImagesMap.put("am", flagImageResources.flagAM());
+        flagImagesMap.put("an", flagImageResources.flagAN());
+        flagImagesMap.put("ao", flagImageResources.flagAO());
+        flagImagesMap.put("ar", flagImageResources.flagAR());
+        flagImagesMap.put("as", flagImageResources.flagAS());
+        flagImagesMap.put("at", flagImageResources.flagAT());
+        flagImagesMap.put("au", flagImageResources.flagAU());
+        flagImagesMap.put("aw", flagImageResources.flagAW());
+        flagImagesMap.put("ax", flagImageResources.flagAX());
+        flagImagesMap.put("az", flagImageResources.flagAZ());
+        flagImagesMap.put("ba", flagImageResources.flagBA());
+        flagImagesMap.put("bb", flagImageResources.flagBB());
+        flagImagesMap.put("bd", flagImageResources.flagBD());
+        flagImagesMap.put("be", flagImageResources.flagBE());
+        flagImagesMap.put("bf", flagImageResources.flagBF());
+        flagImagesMap.put("bg", flagImageResources.flagBG());
+        flagImagesMap.put("bh", flagImageResources.flagBH());
+        flagImagesMap.put("bi", flagImageResources.flagBI());
+        flagImagesMap.put("bj", flagImageResources.flagBJ());
+        flagImagesMap.put("bm", flagImageResources.flagBM());
+        flagImagesMap.put("bn", flagImageResources.flagBN());
+        flagImagesMap.put("bo", flagImageResources.flagBO());
+        flagImagesMap.put("br", flagImageResources.flagBR());
+        flagImagesMap.put("bs", flagImageResources.flagBS());
+        flagImagesMap.put("bt", flagImageResources.flagBT());
+        flagImagesMap.put("bv", flagImageResources.flagBV());
+        flagImagesMap.put("bw", flagImageResources.flagBW());
+        flagImagesMap.put("by", flagImageResources.flagBY());
+        flagImagesMap.put("bz", flagImageResources.flagBZ());
+        flagImagesMap.put("ca", flagImageResources.flagCA());
+        flagImagesMap.put("catalonia", flagImageResources.flagCATALONIA());
+        flagImagesMap.put("cc", flagImageResources.flagCC());
+        flagImagesMap.put("cd", flagImageResources.flagCD());
+        flagImagesMap.put("cf", flagImageResources.flagCF());
+        flagImagesMap.put("cg", flagImageResources.flagCG());
+        flagImagesMap.put("ch", flagImageResources.flagCH());
+        flagImagesMap.put("ci", flagImageResources.flagCI());
+        flagImagesMap.put("ck", flagImageResources.flagCK());
+        flagImagesMap.put("cl", flagImageResources.flagCL());
+        flagImagesMap.put("cm", flagImageResources.flagCM());
+        flagImagesMap.put("cn", flagImageResources.flagCN());
+        flagImagesMap.put("co", flagImageResources.flagCO());
+        flagImagesMap.put("cr", flagImageResources.flagCR());
+        flagImagesMap.put("cs", flagImageResources.flagCS());
+        flagImagesMap.put("cu", flagImageResources.flagCU());
+        flagImagesMap.put("cv", flagImageResources.flagCV());
+        flagImagesMap.put("cx", flagImageResources.flagCX());
+        flagImagesMap.put("cy", flagImageResources.flagCY());
+        flagImagesMap.put("cz", flagImageResources.flagCZ());
+        flagImagesMap.put("de", flagImageResources.flagDE());
+        flagImagesMap.put("dj", flagImageResources.flagDJ());
+        flagImagesMap.put("dk", flagImageResources.flagDK());
+        flagImagesMap.put("dm", flagImageResources.flagDM());
+        flagImagesMap.put("do", flagImageResources.flagDO());
+        flagImagesMap.put("dz", flagImageResources.flagDZ());
+        flagImagesMap.put("ec", flagImageResources.flagEC());
+        flagImagesMap.put("ee", flagImageResources.flagEE());
+        flagImagesMap.put("eg", flagImageResources.flagEG());
+        flagImagesMap.put("eh", flagImageResources.flagEH());
+        flagImagesMap.put("england", flagImageResources.flagENGLAND());
+        flagImagesMap.put("er", flagImageResources.flagER());
+        flagImagesMap.put("es", flagImageResources.flagES());
+        flagImagesMap.put("et", flagImageResources.flagET());
+        flagImagesMap.put("europeanunion", flagImageResources.flagEUROPEANUNION());
+        flagImagesMap.put("fam", flagImageResources.flagFAM());
+        flagImagesMap.put("fi", flagImageResources.flagFI());
+        flagImagesMap.put("fj", flagImageResources.flagFJ());
+        flagImagesMap.put("fk", flagImageResources.flagFK());
+        flagImagesMap.put("fm", flagImageResources.flagFM());
+        flagImagesMap.put("fo", flagImageResources.flagFO());
+        flagImagesMap.put("fr", flagImageResources.flagFR());
+        flagImagesMap.put("ga", flagImageResources.flagGA());
+        flagImagesMap.put("gb", flagImageResources.flagGB());
+        flagImagesMap.put("gd", flagImageResources.flagGD());
+        flagImagesMap.put("ge", flagImageResources.flagGE());
+        flagImagesMap.put("gf", flagImageResources.flagGF());
+        flagImagesMap.put("gh", flagImageResources.flagGH());
+        flagImagesMap.put("gi", flagImageResources.flagGI());
+        flagImagesMap.put("gl", flagImageResources.flagGL());
+        flagImagesMap.put("gm", flagImageResources.flagGM());
+        flagImagesMap.put("gn", flagImageResources.flagGN());
+        flagImagesMap.put("gp", flagImageResources.flagGP());
+        flagImagesMap.put("gq", flagImageResources.flagGQ());
+        flagImagesMap.put("gr", flagImageResources.flagGR());
+        flagImagesMap.put("gs", flagImageResources.flagGS());
+        flagImagesMap.put("gt", flagImageResources.flagGT());
+        flagImagesMap.put("gu", flagImageResources.flagGU());
+        flagImagesMap.put("gw", flagImageResources.flagGW());
+        flagImagesMap.put("gy", flagImageResources.flagGY());
+        flagImagesMap.put("hk", flagImageResources.flagHK());
+        flagImagesMap.put("hm", flagImageResources.flagHM());
+        flagImagesMap.put("hn", flagImageResources.flagHN());
+        flagImagesMap.put("hr", flagImageResources.flagHR());
+        flagImagesMap.put("ht", flagImageResources.flagHT());
+        flagImagesMap.put("hu", flagImageResources.flagHU());
+        flagImagesMap.put("id", flagImageResources.flagID());
+        flagImagesMap.put("ie", flagImageResources.flagIE());
+        flagImagesMap.put("il", flagImageResources.flagIL());
+        flagImagesMap.put("in", flagImageResources.flagIN());
+        flagImagesMap.put("io", flagImageResources.flagIO());
+        flagImagesMap.put("iq", flagImageResources.flagIQ());
+        flagImagesMap.put("ir", flagImageResources.flagIR());
+        flagImagesMap.put("is", flagImageResources.flagIS());
+        flagImagesMap.put("it", flagImageResources.flagIT());
+        flagImagesMap.put("jm", flagImageResources.flagJM());
+        flagImagesMap.put("jo", flagImageResources.flagJO());
+        flagImagesMap.put("jp", flagImageResources.flagJP());
+        flagImagesMap.put("ke", flagImageResources.flagKE());
+        flagImagesMap.put("kg", flagImageResources.flagKG());
+        flagImagesMap.put("kh", flagImageResources.flagKH());
+        flagImagesMap.put("ki", flagImageResources.flagKI());
+        flagImagesMap.put("km", flagImageResources.flagKM());
+        flagImagesMap.put("kn", flagImageResources.flagKN());
+        flagImagesMap.put("kp", flagImageResources.flagKP());
+        flagImagesMap.put("kr", flagImageResources.flagKR());
+        flagImagesMap.put("kw", flagImageResources.flagKW());
+        flagImagesMap.put("ky", flagImageResources.flagKY());
+        flagImagesMap.put("kz", flagImageResources.flagKZ());
+        flagImagesMap.put("la", flagImageResources.flagLA());
+        flagImagesMap.put("lb", flagImageResources.flagLB());
+        flagImagesMap.put("lc", flagImageResources.flagLC());
+        flagImagesMap.put("li", flagImageResources.flagLI());
+        flagImagesMap.put("lk", flagImageResources.flagLK());
+        flagImagesMap.put("lr", flagImageResources.flagLR());
+        flagImagesMap.put("ls", flagImageResources.flagLS());
+        flagImagesMap.put("lt", flagImageResources.flagLT());
+        flagImagesMap.put("lu", flagImageResources.flagLU());
+        flagImagesMap.put("lv", flagImageResources.flagLV());
+        flagImagesMap.put("ly", flagImageResources.flagLY());
+        flagImagesMap.put("ma", flagImageResources.flagMA());
+        flagImagesMap.put("mc", flagImageResources.flagMC());
+        flagImagesMap.put("md", flagImageResources.flagMD());
+        flagImagesMap.put("me", flagImageResources.flagME());
+        flagImagesMap.put("mg", flagImageResources.flagMG());
+        flagImagesMap.put("mh", flagImageResources.flagMH());
+        flagImagesMap.put("mk", flagImageResources.flagMK());
+        flagImagesMap.put("ml", flagImageResources.flagML());
+        flagImagesMap.put("mm", flagImageResources.flagMM());
+        flagImagesMap.put("mn", flagImageResources.flagMN());
+        flagImagesMap.put("mo", flagImageResources.flagMO());
+        flagImagesMap.put("mp", flagImageResources.flagMP());
+        flagImagesMap.put("mq", flagImageResources.flagMQ());
+        flagImagesMap.put("mr", flagImageResources.flagMR());
+        flagImagesMap.put("ms", flagImageResources.flagMS());
+        flagImagesMap.put("mt", flagImageResources.flagMT());
+        flagImagesMap.put("mu", flagImageResources.flagMU());
+        flagImagesMap.put("mv", flagImageResources.flagMV());
+        flagImagesMap.put("mw", flagImageResources.flagMW());
+        flagImagesMap.put("mx", flagImageResources.flagMX());
+        flagImagesMap.put("my", flagImageResources.flagMY());
+        flagImagesMap.put("mz", flagImageResources.flagMZ());
+        flagImagesMap.put("na", flagImageResources.flagNA());
+        flagImagesMap.put("nc", flagImageResources.flagNC());
+        flagImagesMap.put("ne", flagImageResources.flagNE());
+        flagImagesMap.put("nf", flagImageResources.flagNF());
+        flagImagesMap.put("ng", flagImageResources.flagNG());
+        flagImagesMap.put("ni", flagImageResources.flagNI());
+        flagImagesMap.put("nl", flagImageResources.flagNL());
+        flagImagesMap.put("no", flagImageResources.flagNO());
+        flagImagesMap.put(NONE, flagImageResources.flagNONE());
+        flagImagesMap.put("np", flagImageResources.flagNP());
+        flagImagesMap.put("nr", flagImageResources.flagNR());
+        flagImagesMap.put("nu", flagImageResources.flagNU());
+        flagImagesMap.put("nz", flagImageResources.flagNZ());
+        flagImagesMap.put("om", flagImageResources.flagOM());
+        flagImagesMap.put("pa", flagImageResources.flagPA());
+        flagImagesMap.put("pe", flagImageResources.flagPE());
+        flagImagesMap.put("pf", flagImageResources.flagPF());
+        flagImagesMap.put("pg", flagImageResources.flagPG());
+        flagImagesMap.put("ph", flagImageResources.flagPH());
+        flagImagesMap.put("pk", flagImageResources.flagPK());
+        flagImagesMap.put("pl", flagImageResources.flagPL());
+        flagImagesMap.put("pm", flagImageResources.flagPM());
+        flagImagesMap.put("pn", flagImageResources.flagPN());
+        flagImagesMap.put("pr", flagImageResources.flagPR());
+        flagImagesMap.put("ps", flagImageResources.flagPS());
+        flagImagesMap.put("pt", flagImageResources.flagPT());
+        flagImagesMap.put("pw", flagImageResources.flagPW());
+        flagImagesMap.put("py", flagImageResources.flagPY());
+        flagImagesMap.put("qa", flagImageResources.flagQA());
+        flagImagesMap.put("re", flagImageResources.flagRE());
+        flagImagesMap.put("ro", flagImageResources.flagRO());
+        flagImagesMap.put("rs", flagImageResources.flagRS());
+        flagImagesMap.put("ru", flagImageResources.flagRU());
+        flagImagesMap.put("rw", flagImageResources.flagRW());
+        flagImagesMap.put("sa", flagImageResources.flagSA());
+        flagImagesMap.put("sb", flagImageResources.flagSB());
+        flagImagesMap.put("sc", flagImageResources.flagSC());
+        flagImagesMap.put("scotland", flagImageResources.flagSCOTLAND());
+        flagImagesMap.put("sd", flagImageResources.flagSD());
+        flagImagesMap.put("se", flagImageResources.flagSE());
+        flagImagesMap.put("sg", flagImageResources.flagSG());
+        flagImagesMap.put("sh", flagImageResources.flagSH());
+        flagImagesMap.put("si", flagImageResources.flagSI());
+        flagImagesMap.put("sj", flagImageResources.flagSJ());
+        flagImagesMap.put("sk", flagImageResources.flagSK());
+        flagImagesMap.put("sl", flagImageResources.flagSL());
+        flagImagesMap.put("sm", flagImageResources.flagSM());
+        flagImagesMap.put("sn", flagImageResources.flagSN());
+        flagImagesMap.put("so", flagImageResources.flagSO());
+        flagImagesMap.put("sr", flagImageResources.flagSR());
+        flagImagesMap.put("st", flagImageResources.flagST());
+        flagImagesMap.put("sv", flagImageResources.flagSV());
+        flagImagesMap.put("sy", flagImageResources.flagSY());
+        flagImagesMap.put("sz", flagImageResources.flagSZ());
+        flagImagesMap.put("tc", flagImageResources.flagTC());
+        flagImagesMap.put("td", flagImageResources.flagTD());
+        flagImagesMap.put("tf", flagImageResources.flagTF());
+        flagImagesMap.put("tg", flagImageResources.flagTG());
+        flagImagesMap.put("th", flagImageResources.flagTH());
+        flagImagesMap.put("tj", flagImageResources.flagTJ());
+        flagImagesMap.put("tk", flagImageResources.flagTK());
+        flagImagesMap.put("tl", flagImageResources.flagTL());
+        flagImagesMap.put("tm", flagImageResources.flagTM());
+        flagImagesMap.put("tn", flagImageResources.flagTN());
+        flagImagesMap.put("to", flagImageResources.flagTO());
+        flagImagesMap.put("tr", flagImageResources.flagTR());
+        flagImagesMap.put("tt", flagImageResources.flagTT());
+        flagImagesMap.put("tv", flagImageResources.flagTV());
+        flagImagesMap.put("tw", flagImageResources.flagTW());
+        flagImagesMap.put("tz", flagImageResources.flagTZ());
+        flagImagesMap.put("ua", flagImageResources.flagUA());
+        flagImagesMap.put("ug", flagImageResources.flagUG());
+        flagImagesMap.put("um", flagImageResources.flagUM());
+        flagImagesMap.put("us", flagImageResources.flagUS());
+        flagImagesMap.put("uy", flagImageResources.flagUY());
+        flagImagesMap.put("uz", flagImageResources.flagUZ());
+        flagImagesMap.put("va", flagImageResources.flagVA());
+        flagImagesMap.put("vc", flagImageResources.flagVC());
+        flagImagesMap.put("ve", flagImageResources.flagVE());
+        flagImagesMap.put("vg", flagImageResources.flagVG());
+        flagImagesMap.put("vi", flagImageResources.flagVI());
+        flagImagesMap.put("vn", flagImageResources.flagVN());
+        flagImagesMap.put("vu", flagImageResources.flagVU());
+        flagImagesMap.put("wales", flagImageResources.flagWALES());
+        flagImagesMap.put("wf", flagImageResources.flagWF());
+        flagImagesMap.put("ws", flagImageResources.flagWS());
+        flagImagesMap.put("ye", flagImageResources.flagYE());
+        flagImagesMap.put("yt", flagImageResources.flagYT());
+        flagImagesMap.put("za", flagImageResources.flagZA());
+        flagImagesMap.put("zm", flagImageResources.flagZM());
+        flagImagesMap.put("zw", flagImageResources.flagZW());
+    }
+
+    public static ImageResource getFlagImageResource(String twoLetterIsoCountryCode) {
+        return flagImagesMap.get(twoLetterIsoCountryCode.toLowerCase());
+    }
+
+    public static ImageResource getEmptyFlagImageResource() {
+        return flagImagesMap.get(NONE);
+    }
+    
+    public static SafeUri getFlagImageResource(String flagImageUrl, String twoLetterIsoCountryCode) {
+        if (flagImageUrl == null || flagImageUrl.isEmpty()) {
+            if (twoLetterIsoCountryCode == null || twoLetterIsoCountryCode.isEmpty()) {
+                return FlagImageResolver.getEmptyFlagImageResource().getSafeUri();
+            }
+            return  FlagImageResolver.getFlagImageResource(twoLetterIsoCountryCode).getSafeUri();
+        }
+        return UriUtils.fromTrustedString(flagImageUrl);
+    }
+
+}

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

@@ -1,5 +1,6 @@
 package com.sap.sailing.gwt.ui.leaderboard;
 
+import java.util.Collection;
 import java.util.Collections;
 import java.util.Comparator;
 import java.util.HashMap;
@@ -202,7 +203,7 @@ public class SortedCellTable<T> extends CellTable<T> {
      * 
      * @param list
      */
-    public void setList(List<T> list) {
+    public void setList(Collection<T> list) {
         dataProvider.getList().clear();
         if (list != null) {
             for (T element : list) {

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/server/SailingServiceImpl.java

@@ -61,16 +61,16 @@ import com.sap.sailing.domain.abstractlog.AbstractLog;
 import com.sap.sailing.domain.abstractlog.AbstractLogEvent;
 import com.sap.sailing.domain.abstractlog.MultiLogAnalyzer;
 import com.sap.sailing.domain.abstractlog.impl.AllEventsOfTypeFinder;
-import com.sap.sailing.domain.abstractlog.race.FixedMarkPassingEvent;
+import com.sap.sailing.domain.abstractlog.race.RaceLogFixedMarkPassingEvent;
 import com.sap.sailing.domain.abstractlog.race.RaceLog;
 import com.sap.sailing.domain.abstractlog.race.RaceLogEvent;
 import com.sap.sailing.domain.abstractlog.race.RaceLogEventFactory;
 import com.sap.sailing.domain.abstractlog.race.RaceLogFlagEvent;
-import com.sap.sailing.domain.abstractlog.race.SuppressedMarkPassingsEvent;
+import com.sap.sailing.domain.abstractlog.race.RaceLogSuppressedMarkPassingsEvent;
 import com.sap.sailing.domain.abstractlog.race.analyzing.impl.AbortingFlagFinder;
 import com.sap.sailing.domain.abstractlog.race.analyzing.impl.LastPublishedCourseDesignFinder;
 import com.sap.sailing.domain.abstractlog.race.analyzing.impl.MarkPassingDataFinder;
-import com.sap.sailing.domain.abstractlog.race.impl.FixedMarkPassingEventImpl;
+import com.sap.sailing.domain.abstractlog.race.impl.RaceLogFixedMarkPassingEventImpl;
 import com.sap.sailing.domain.abstractlog.race.state.ReadonlyRaceState;
 import com.sap.sailing.domain.abstractlog.race.state.impl.ReadonlyRaceStateImpl;
 import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.FlagPoleState;
@@ -5504,10 +5504,10 @@ public class SailingServiceImpl extends ProxiedRemoteServiceServlet implements S
             Date dateOfMarkPassing, CompetitorDTO competitorDTO) {
         RaceLog raceLog = getService().getRaceLog(leaderboardName, raceColumnDTO.getName(), fleet.getName());
         Competitor competitor = getCompetitor(competitorDTO);
-        FixedMarkPassingEvent oldFixedMarkPassingEvent = null;
+        RaceLogFixedMarkPassingEvent oldFixedMarkPassingEvent = null;
         for (RaceLogEvent event : raceLog.getUnrevokedEvents()) {
-            if (event instanceof FixedMarkPassingEventImpl && event.getInvolvedBoats().contains(competitor)) {
-                FixedMarkPassingEvent fixedEvent = (FixedMarkPassingEvent) event;
+            if (event instanceof RaceLogFixedMarkPassingEventImpl && event.getInvolvedBoats().contains(competitor)) {
+                RaceLogFixedMarkPassingEvent fixedEvent = (RaceLogFixedMarkPassingEvent) event;
                 if (fixedEvent.getZeroBasedIndexOfPassedWaypoint() == indexOfWaypoint) {
                     oldFixedMarkPassingEvent = fixedEvent;
                 }
@@ -5526,21 +5526,27 @@ public class SailingServiceImpl extends ProxiedRemoteServiceServlet implements S
                     new MillisecondsTimePoint(dateOfMarkPassing), indexOfWaypoint));
         }
     }
+    
+    public void setStartOfTracking(String leaderboardName, RaceColumnDTO raceColumn, FleetDTO fleet, TimePoint startOfTracking) {
+        
+        RaceLog raceLog = getService().getRaceLog(leaderboardName, raceColumn.getName(), fleet.getName());
+        
+    }
 
     @Override
     public void updateSuppressedMarkPassings(String leaderboardName, RaceColumnDTO raceColumnDTO, FleetDTO fleet,
             Integer newZeroBasedIndexOfSuppressedMarkPassing, CompetitorDTO competitorDTO) {
-        SuppressedMarkPassingsEvent oldSuppressedMarkPassingEvent = null;
+        RaceLogSuppressedMarkPassingsEvent oldSuppressedMarkPassingEvent = null;
         RaceLog raceLog = getService().getRaceLog(leaderboardName, raceColumnDTO.getName(), fleet.getName());
         Competitor competitor = getCompetitor(competitorDTO);
         NavigableSet<RaceLogEvent> unrevokedEvents = raceLog.getUnrevokedEvents();
         for (RaceLogEvent event : unrevokedEvents) {
-            if (event instanceof SuppressedMarkPassingsEvent && event.getInvolvedBoats().contains(competitor)) {
-                oldSuppressedMarkPassingEvent = (SuppressedMarkPassingsEvent) event;
+            if (event instanceof RaceLogSuppressedMarkPassingsEvent && event.getInvolvedBoats().contains(competitor)) {
+                oldSuppressedMarkPassingEvent = (RaceLogSuppressedMarkPassingsEvent) event;
                 break;
             }
         }
-
+        
         final boolean create;
         final boolean revoke;
         if (oldSuppressedMarkPassingEvent == null) {

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/shared/dispatch/event/LiveRaceDTO.java

@@ -1,15 +1,11 @@
 package com.sap.sailing.gwt.ui.shared.dispatch.event;
 
-import java.util.Date;
-
 import com.sap.sailing.gwt.ui.shared.race.FlagStateDTO;
-import com.sap.sailing.gwt.ui.shared.race.FleetMetadataDTO;
 import com.sap.sailing.gwt.ui.shared.race.RaceMetadataDTO;
 import com.sap.sailing.gwt.ui.shared.race.RaceProgressDTO;
 import com.sap.sailing.gwt.ui.shared.race.SimpleWindDTO;
-import com.sap.sse.common.Util;
 
-public class LiveRaceDTO extends RaceMetadataDTO implements Comparable<LiveRaceDTO> {
+public class LiveRaceDTO extends RaceMetadataDTO {
     
     private FlagStateDTO flagState;
     
@@ -48,57 +44,4 @@ public class LiveRaceDTO extends RaceMetadataDTO implements Comparable<LiveRaceD
     public void setProgress(RaceProgressDTO progress) {
         this.progress = progress;
     }
-
-    @Override
-    public int compareTo(LiveRaceDTO o) {
-        Date thisStart = getStart();
-        Date otherStart = o.getStart();
-        if(Util.equalsWithNull(thisStart, otherStart)) {
-            // cases where both start times are == null or equal
-            return compareBySecondaryCriteria(o);
-        }
-        if(thisStart == null) {
-            return 1;
-        }
-        if(otherStart == null) {
-            return -1;
-        }
-        return -thisStart.compareTo(otherStart);
-    }
-
-    private int compareBySecondaryCriteria(LiveRaceDTO o) {
-        String thisRegattaName = getRegattaName();
-        String otherRegattaName = o.getRegattaName();
-        if(thisRegattaName != otherRegattaName) {
-            if(thisRegattaName == null) {
-                return 1;
-            }
-            if(otherRegattaName == null) {
-                return -1;
-            }
-            int compareByRegatta = thisRegattaName.compareTo(otherRegattaName);
-            if(compareByRegatta != 0) {
-                return compareByRegatta;
-            }
-        }
-        int compareByRace = getRaceName().compareTo(o.getRaceName());
-        if(compareByRace != 0) {
-            return compareByRace;
-        }
-        FleetMetadataDTO thisFleet = getFleet();
-        FleetMetadataDTO otherFleet = o.getFleet();
-        if(thisFleet != otherFleet) {
-            if(thisFleet == null) {
-                return 1;
-            }
-            if(otherFleet == null) {
-                return -1;
-            }
-            int compareByFleet = thisFleet.compareTo(otherFleet);
-            if(compareByFleet != 0) {
-                return compareByFleet;
-            }
-        }
-        return getViewState().compareTo(o.getViewState());
-    }
 }

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/shared/dispatch/event/RaceContext.java

@@ -1,5 +1,6 @@
 package com.sap.sailing.gwt.ui.shared.dispatch.event;
 
+import java.util.Date;
 import java.util.List;
 
 import com.google.gwt.core.shared.GwtIncompatible;
@@ -47,7 +48,10 @@ import com.sap.sse.common.impl.MillisecondsTimePoint;
 
 @GwtIncompatible
 public class RaceContext {
-    private final MillisecondsTimePoint now = MillisecondsTimePoint.now();
+    private static final long TIME_BEFORE_START_TO_SHOW_RACES_AS_LIVE = 15 * 60 * 1000; // 15 min
+    private static final long TIME_TO_SHOW_CANCELED_RACES_AS_LIVE = 5 * 60 * 1000; // 5 min
+    
+    private final TimePoint now = MillisecondsTimePoint.now();
     private final Leaderboard leaderboard;
     private final RaceColumn raceColumn;
     private final Fleet fleet;
@@ -56,8 +60,12 @@ public class RaceContext {
     private final RaceLog raceLog;
     private final ReadonlyRaceState state;
     private final Event event;
-    private final long TIME_BEFORE_START_TO_SHOW_RACES_AS_LIVE = 15 * 60 * 1000; // 15 min
-    private final long TIME_TO_SHOW_CANCELED_RACES_AS_LIVE = 5 * 60 * 1000; // 5 min
+    
+    private TimePoint startTime;
+    private boolean startTimeCalculated = false;
+    private TimePoint finishTime;
+    private boolean finishTimeCalculated = false;
+    private RaceViewState raceViewState;
     
     public RaceContext(Event event, Leaderboard leaderboard, RaceColumn raceColumn, Fleet fleet, RaceLogResolver raceLogResolver) {
         this.event = event;
@@ -234,24 +242,33 @@ public class RaceContext {
         return null;
     }
     
+    public Date getStartTimeAsDate() {
+        TimePoint startTime = getStartTime();
+        return startTime == null ? null : startTime.asDate();
+    }
+    
     public TimePoint getStartTime() {
-        TimePoint startTime = null;
-        if (trackedRace != null) {
-            startTime = trackedRace.getStartOfRace();
-        }
-        if (startTime == null && state != null) {
-            startTime = state.getStartTime();
+        if(!startTimeCalculated) {
+            if (trackedRace != null) {
+                startTime = trackedRace.getStartOfRace();
+            }
+            if (startTime == null && state != null) {
+                startTime = state.getStartTime();
+            }
+            startTimeCalculated = true;
         }
         return startTime;
     }
 
     private TimePoint getFinishTime() {
-        TimePoint finishTime = null;
-        if (trackedRace != null) {
-            finishTime = trackedRace.getEndOfRace();
-        } else if (state != null) {
-            finishTime = state.getFinishedTime();
-        } 
+        if(!finishTimeCalculated) {
+            if (trackedRace != null) {
+                finishTime = trackedRace.getEndOfRace();
+            } else if (state != null) {
+                finishTime = state.getFinishedTime();
+            }
+            finishTimeCalculated = true;
+        }
         return finishTime;
     }
 
@@ -263,19 +280,17 @@ public class RaceContext {
     }
     
     public LiveRaceDTO getLiveRaceOrNull() {
-        TimePoint startTime = getStartTime();
-        TimePoint finishTime = getFinishTime();
         // a race is of 'public interest' of a race is a combination of it's 'live' state
         // and special flags states indicating how the postponed/canceled races will be continued
-        if(isLiveOrOfPublicInterest(startTime, finishTime)) {
+        if(isLiveOrOfPublicInterest()) {
             // the start time is always given for live races
             LiveRaceDTO liveRaceDTO = new LiveRaceDTO(getRegattaName(), raceColumn.getName());
-            liveRaceDTO.setViewState(getLiveRaceViewState(startTime, finishTime));
+            liveRaceDTO.setViewState(getLiveRaceViewState());
             liveRaceDTO.setRegattaDisplayName(getRegattaDisplayName());
             liveRaceDTO.setTrackedRaceName(trackedRace != null ? trackedRace.getRaceIdentifier().getRaceName() : null);
             liveRaceDTO.setTrackingState(getRaceTrackingState());
             liveRaceDTO.setFleet(getFleetMetadataOrNull());
-            liveRaceDTO.setStart(startTime == null ? null : startTime.asDate());
+            liveRaceDTO.setStart(getStartTimeAsDate());
             liveRaceDTO.setBoatClass(HomeServiceUtil.getBoatClassName(leaderboard));
             liveRaceDTO.setCourseArea(getCourseAreaOrNull());
             liveRaceDTO.setCourse(getCourseNameOrNull());
@@ -288,12 +303,14 @@ public class RaceContext {
         return null;
     }
     
-    private boolean isLiveOrOfPublicInterest(TimePoint startTime, TimePoint finishTime) {
+    public boolean isLiveOrOfPublicInterest() {
+        TimePoint startTime = getStartTime();
         boolean result = false;
         if(startTime != null) {
             if(trackedRace != null && trackedRace.hasGPSData() && trackedRace.hasWindData()) {
                 result = trackedRace.isLive(now);
             } else {
+                TimePoint finishTime = getFinishTime();
                 // no data from tracking but maybe a manual setting of the start and finish time
                 TimePoint startOfLivePeriod = startTime.minus(TIME_BEFORE_START_TO_SHOW_RACES_AS_LIVE);
                 TimePoint endOfLivePeriod = finishTime != null ? finishTime.plus(TimingConstants.IS_LIVE_GRACE_PERIOD_IN_MILLIS) : null; 
@@ -329,7 +346,16 @@ public class RaceContext {
         return trackingState;
     }
     
-    private RaceViewState getLiveRaceViewState(TimePoint startTime, TimePoint finishTime) {
+    private RaceViewState getLiveRaceViewState() {
+        if(raceViewState == null) {
+            raceViewState = calculateLiveRaceViewState();
+        }
+        return raceViewState;
+    }
+    
+    private RaceViewState calculateLiveRaceViewState() {
+        TimePoint startTime = getStartTime();
+        TimePoint finishTime = getFinishTime();
         RaceViewState raceState = RaceViewState.RUNNING;
         if (startTime != null && now.before(startTime)) {
             raceState = RaceViewState.SCHEDULED;

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/shared/dispatch/event/SimpleCompetitorDTO.java

@@ -0,0 +1,72 @@
+package com.sap.sailing.gwt.ui.shared.dispatch.event;
+
+import java.io.Serializable;
+
+import com.google.gwt.core.shared.GwtIncompatible;
+import com.sap.sailing.domain.base.Competitor;
+import com.sap.sailing.domain.base.Nationality;
+import com.sap.sailing.domain.common.dto.CompetitorDTO;
+import com.sap.sailing.domain.common.dto.NamedDTO;
+import com.sap.sse.common.CountryCode;
+
+public class SimpleCompetitorDTO extends NamedDTO implements Serializable {
+
+    private static final long serialVersionUID = -5743976446085202047L;
+    
+    private String sailID;
+    private String twoLetterIsoCountryCode;
+    private String flagImageURL;
+
+    protected SimpleCompetitorDTO() {
+    }
+    
+    @GwtIncompatible
+    public SimpleCompetitorDTO(Competitor competitor) {
+        super(competitor.getName());
+        final Nationality nationality = competitor.getTeam().getNationality();
+        CountryCode countryCode = nationality == null ? null : nationality.getCountryCode();
+        this.sailID = competitor.getBoat().getSailID();
+        this.twoLetterIsoCountryCode = countryCode.getTwoLetterISOCode();
+        this.flagImageURL = competitor.getFlagImage() == null ? null : competitor.getFlagImage().toString();
+    }
+
+    @GwtIncompatible
+    public SimpleCompetitorDTO(CompetitorDTO competitor) {
+        super(competitor.getName());
+        this.sailID = competitor.getSailID();
+        this.twoLetterIsoCountryCode = competitor.getTwoLetterIsoCountryCode();
+        this.flagImageURL = competitor.getFlagImageURL();
+    }
+
+    public SimpleCompetitorDTO(String name, String sailID, String twoLetterIsoCountryCode, String flagImageURL) {
+        super(name);
+        this.sailID = sailID;
+        this.twoLetterIsoCountryCode = twoLetterIsoCountryCode;
+        this.flagImageURL = flagImageURL;
+    }
+
+    public String getSailID() {
+        return sailID;
+    }
+
+    public void setSailID(String sailID) {
+        this.sailID = sailID;
+    }
+
+    public String getTwoLetterIsoCountryCode() {
+        return twoLetterIsoCountryCode;
+    }
+
+    public void setTwoLetterIsoCountryCode(String twoLetterIsoCountryCode) {
+        this.twoLetterIsoCountryCode = twoLetterIsoCountryCode;
+    }
+
+    public String getFlagImageURL() {
+        return flagImageURL;
+    }
+
+    public void setFlagImageURL(String flagImageURL) {
+        this.flagImageURL = flagImageURL;
+    }
+    
+}

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/shared/race/RaceMetadataDTO.java

@@ -4,8 +4,9 @@ import java.util.Date;
 
 import com.google.gwt.user.client.rpc.IsSerializable;
 import com.sap.sailing.gwt.ui.client.StringMessages;
+import com.sap.sse.common.Util;
 
-public class RaceMetadataDTO implements IsSerializable {
+public class RaceMetadataDTO implements IsSerializable, Comparable<RaceMetadataDTO> {
     
     public enum RaceViewState {
         PLANNED {       // no start time set
@@ -153,4 +154,57 @@ public class RaceMetadataDTO implements IsSerializable {
     public void setRegattaDisplayName(String regattaDisplayName) {
         this.regattaDisplayName = regattaDisplayName;
     }
+
+    @Override
+    public int compareTo(RaceMetadataDTO o) {
+        Date thisStart = getStart();
+        Date otherStart = o.getStart();
+        if(Util.equalsWithNull(thisStart, otherStart)) {
+            // cases where both start times are == null or equal
+            return compareBySecondaryCriteria(o);
+        }
+        if(thisStart == null) {
+            return 1;
+        }
+        if(otherStart == null) {
+            return -1;
+        }
+        return -thisStart.compareTo(otherStart);
+    }
+
+    private int compareBySecondaryCriteria(RaceMetadataDTO o) {
+        String thisRegattaName = getRegattaName();
+        String otherRegattaName = o.getRegattaName();
+        if(thisRegattaName != otherRegattaName) {
+            if(thisRegattaName == null) {
+                return 1;
+            }
+            if(otherRegattaName == null) {
+                return -1;
+            }
+            int compareByRegatta = thisRegattaName.compareTo(otherRegattaName);
+            if(compareByRegatta != 0) {
+                return compareByRegatta;
+            }
+        }
+        int compareByRace = getRaceName().compareTo(o.getRaceName());
+        if(compareByRace != 0) {
+            return compareByRace;
+        }
+        FleetMetadataDTO thisFleet = getFleet();
+        FleetMetadataDTO otherFleet = o.getFleet();
+        if(thisFleet != otherFleet) {
+            if(thisFleet == null) {
+                return 1;
+            }
+            if(otherFleet == null) {
+                return -1;
+            }
+            int compareByFleet = thisFleet.compareTo(otherFleet);
+            if(compareByFleet != 0) {
+                return compareByFleet;
+            }
+        }
+        return getViewState().compareTo(o.getViewState());
+    }
 }

java/com.sap.sailing.server.gateway.serialization.shared.android/src/com/sap/sailing/server/gateway/deserialization/racelog/impl/RaceLogEndOfTrackingEventDeserializer.java

@@ -0,0 +1,29 @@
+package com.sap.sailing.server.gateway.deserialization.racelog.impl;
+
+import java.io.Serializable;
+import java.util.List;
+
+import org.json.simple.JSONObject;
+
+import com.sap.sailing.domain.abstractlog.AbstractLogEventAuthor;
+import com.sap.sailing.domain.abstractlog.race.RaceLogEvent;
+import com.sap.sailing.domain.base.Competitor;
+import com.sap.sailing.server.gateway.deserialization.JsonDeserializationException;
+import com.sap.sailing.server.gateway.deserialization.JsonDeserializer;
+import com.sap.sse.common.TimePoint;
+
+public class RaceLogEndOfTrackingEventDeserializer extends BaseRaceLogEventDeserializer implements
+        JsonDeserializer<RaceLogEvent> {
+
+    public RaceLogEndOfTrackingEventDeserializer(JsonDeserializer<Competitor> competitorDeserializer) {
+        super(competitorDeserializer);
+    }
+
+    @Override
+    protected RaceLogEvent deserialize(JSONObject object, Serializable id, TimePoint createdAt,
+            AbstractLogEventAuthor author, TimePoint timePoint, int passId, List<Competitor> competitors)
+            throws JsonDeserializationException {
+        return factory.createEndOfTrackingEvent(timePoint, author, id, competitors, passId);
+    }
+
+}

java/com.sap.sailing.server.gateway.serialization.shared.android/src/com/sap/sailing/server/gateway/deserialization/racelog/impl/RaceLogEventDeserializer.java

@@ -27,6 +27,7 @@ import com.sap.sailing.server.gateway.serialization.racelog.impl.RaceLogDefineMa
 import com.sap.sailing.server.gateway.serialization.racelog.impl.RaceLogDenoteForTrackingEventSerializer;
 import com.sap.sailing.server.gateway.serialization.racelog.impl.RaceLogDeviceCompetitorMappingEventSerializer;
 import com.sap.sailing.server.gateway.serialization.racelog.impl.RaceLogDeviceMarkMappingEventSerializer;
+import com.sap.sailing.server.gateway.serialization.racelog.impl.RaceLogEndOfTrackingEventSerializer;
 import com.sap.sailing.server.gateway.serialization.racelog.impl.RaceLogFinishPositioningConfirmedEventSerializer;
 import com.sap.sailing.server.gateway.serialization.racelog.impl.RaceLogFinishPositioningListChangedEventSerializer;
 import com.sap.sailing.server.gateway.serialization.racelog.impl.RaceLogFixedMarkPassingEventSerializer;
@@ -38,6 +39,7 @@ import com.sap.sailing.server.gateway.serialization.racelog.impl.RaceLogProtestS
 import com.sap.sailing.server.gateway.serialization.racelog.impl.RaceLogRaceStatusEventSerializer;
 import com.sap.sailing.server.gateway.serialization.racelog.impl.RaceLogRegisterCompetitorEventSerializer;
 import com.sap.sailing.server.gateway.serialization.racelog.impl.RaceLogRevokeEventSerializer;
+import com.sap.sailing.server.gateway.serialization.racelog.impl.RaceLogStartOfTrackingEventSerializer;
 import com.sap.sailing.server.gateway.serialization.racelog.impl.RaceLogStartProcedureChangedEventSerializer;
 import com.sap.sailing.server.gateway.serialization.racelog.impl.RaceLogStartTimeEventSerializer;
 import com.sap.sailing.server.gateway.serialization.racelog.impl.RaceLogStartTrackingEventSerializer;
@@ -86,7 +88,9 @@ public class RaceLogEventDeserializer implements JsonDeserializer<RaceLogEvent>
                 new RaceLogCloseOpenEndedDeviceMappingEventDeserializer(competitorDeserializer),
                 new RaceLogAdditionalScoringInformationEventDeserializer(competitorDeserializer),
                 new RaceLogFixedMarkPassingEventDeserializer(competitorDeserializer),
-                new RaceLogSuppressedMarkPassingsEventDeserializer(competitorDeserializer));
+                new RaceLogSuppressedMarkPassingsEventDeserializer(competitorDeserializer),
+                new RaceLogStartOfTrackingEventDeserializer(competitorDeserializer),
+                new RaceLogEndOfTrackingEventDeserializer(competitorDeserializer));
     }
 
     protected final JsonDeserializer<RaceLogEvent> flagEventDeserializer;
@@ -113,6 +117,8 @@ public class RaceLogEventDeserializer implements JsonDeserializer<RaceLogEvent>
     protected final JsonDeserializer<RaceLogEvent> additionalScoringInformationEventDeserializer;
     protected final JsonDeserializer<RaceLogEvent> fixedMarkPassingEventDeserializer;
     protected final JsonDeserializer<RaceLogEvent> suppressedMarkPassingsDeserializer;
+    protected final JsonDeserializer<RaceLogEvent> startOfTrackingDeserializer;
+    protected final JsonDeserializer<RaceLogEvent> endOfTrackingDeserializer;
 
     public RaceLogEventDeserializer(JsonDeserializer<RaceLogEvent> flagEventDeserializer,
             JsonDeserializer<RaceLogEvent> startTimeEventDeserializer,
@@ -137,7 +143,9 @@ public class RaceLogEventDeserializer implements JsonDeserializer<RaceLogEvent>
             JsonDeserializer<RaceLogEvent> closeOpenEndedDeviceMappingEventDeserializer,
             JsonDeserializer<RaceLogEvent> additionalScoringInformationEventDeserializer, 
             JsonDeserializer<RaceLogEvent> fixedMarkPassingEventDeserializer,
-            JsonDeserializer<RaceLogEvent> suppressedMarkPassingsEventDeserializer) {
+            JsonDeserializer<RaceLogEvent> suppressedMarkPassingsEventDeserializer,
+            JsonDeserializer<RaceLogEvent> startOfTrackingEventDeserializer,
+            JsonDeserializer<RaceLogEvent> endOfTrackingEventDeserializer) {
         this.flagEventDeserializer = flagEventDeserializer;
         this.startTimeEventDeserializer = startTimeEventDeserializer;
         this.raceStatusEventDeserializer = raceStatusEventDeserializer;
@@ -162,6 +170,8 @@ public class RaceLogEventDeserializer implements JsonDeserializer<RaceLogEvent>
         this.additionalScoringInformationEventDeserializer = additionalScoringInformationEventDeserializer;
         this.fixedMarkPassingEventDeserializer = fixedMarkPassingEventDeserializer;
         this.suppressedMarkPassingsDeserializer = suppressedMarkPassingsEventDeserializer;
+        this.startOfTrackingDeserializer = startOfTrackingEventDeserializer;
+        this.endOfTrackingDeserializer = endOfTrackingEventDeserializer;
     }
 
     protected JsonDeserializer<RaceLogEvent> getDeserializer(JSONObject object) throws JsonDeserializationException {
@@ -215,6 +225,10 @@ public class RaceLogEventDeserializer implements JsonDeserializer<RaceLogEvent>
             return fixedMarkPassingEventDeserializer;
         } else if (type.equals(RaceLogSuppressedMarkPassingsEventSerializer.VALUE_CLASS)){
             return suppressedMarkPassingsDeserializer;
+        } else if (type.equalsIgnoreCase(RaceLogStartOfTrackingEventSerializer.VALUE_CLASS)){
+            return startOfTrackingDeserializer;
+        } else if (type.equals(RaceLogEndOfTrackingEventSerializer.VALUE_CLASS)){
+            return endOfTrackingDeserializer;
         }
 
         throw new JsonDeserializationException(String.format("There is no deserializer defined for event type %s.",

java/com.sap.sailing.server.gateway.serialization.shared.android/src/com/sap/sailing/server/gateway/deserialization/racelog/impl/RaceLogStartOfTrackingEventDeserializer.java

@@ -0,0 +1,29 @@
+package com.sap.sailing.server.gateway.deserialization.racelog.impl;
+
+import java.io.Serializable;
+import java.util.List;
+
+import org.json.simple.JSONObject;
+
+import com.sap.sailing.domain.abstractlog.AbstractLogEventAuthor;
+import com.sap.sailing.domain.abstractlog.race.RaceLogEvent;
+import com.sap.sailing.domain.base.Competitor;
+import com.sap.sailing.server.gateway.deserialization.JsonDeserializationException;
+import com.sap.sailing.server.gateway.deserialization.JsonDeserializer;
+import com.sap.sse.common.TimePoint;
+
+public class RaceLogStartOfTrackingEventDeserializer extends BaseRaceLogEventDeserializer implements
+        JsonDeserializer<RaceLogEvent> {
+
+    public RaceLogStartOfTrackingEventDeserializer(JsonDeserializer<Competitor> competitorDeserializer) {
+        super(competitorDeserializer);
+    }
+
+    @Override
+    protected RaceLogEvent deserialize(JSONObject object, Serializable id, TimePoint createdAt,
+            AbstractLogEventAuthor author, TimePoint timePoint, int passId, List<Competitor> competitors)
+            throws JsonDeserializationException {
+        return factory.createStartOfTrackingEvent(timePoint, author, id, competitors, passId);
+    }
+
+}

java/com.sap.sailing.server.gateway.serialization.shared.android/src/com/sap/sailing/server/gateway/serialization/racelog/impl/RaceLogEndOfTrackingEventSerializer.java

@@ -0,0 +1,22 @@
+package com.sap.sailing.server.gateway.serialization.racelog.impl;
+
+import com.sap.sailing.domain.abstractlog.race.RaceLogEndOfTrackingEvent;
+import com.sap.sailing.domain.abstractlog.race.RaceLogEvent;
+import com.sap.sailing.domain.base.Competitor;
+import com.sap.sailing.server.gateway.serialization.JsonSerializer;
+
+public class RaceLogEndOfTrackingEventSerializer extends BaseRaceLogEventSerializer implements
+        JsonSerializer<RaceLogEvent> {
+    
+    public static final String VALUE_CLASS = RaceLogEndOfTrackingEvent.class.getSimpleName();
+
+    public RaceLogEndOfTrackingEventSerializer(JsonSerializer<Competitor> competitorSerializer) {
+        super(competitorSerializer);
+    }
+
+    @Override
+    protected String getClassFieldValue() {
+        return VALUE_CLASS;
+    }
+
+}

java/com.sap.sailing.server.gateway.serialization.shared.android/src/com/sap/sailing/server/gateway/serialization/racelog/impl/RaceLogEventSerializer.java

@@ -2,7 +2,8 @@ package com.sap.sailing.server.gateway.serialization.racelog.impl;
 
 import org.json.simple.JSONObject;
 
-import com.sap.sailing.domain.abstractlog.race.FixedMarkPassingEvent;
+import com.sap.sailing.domain.abstractlog.race.RaceLogEndOfTrackingEvent;
+import com.sap.sailing.domain.abstractlog.race.RaceLogFixedMarkPassingEvent;
 import com.sap.sailing.domain.abstractlog.race.RaceLogCourseAreaChangedEvent;
 import com.sap.sailing.domain.abstractlog.race.RaceLogCourseDesignChangedEvent;
 import com.sap.sailing.domain.abstractlog.race.RaceLogDependentStartTimeEvent;
@@ -17,10 +18,11 @@ import com.sap.sailing.domain.abstractlog.race.RaceLogPathfinderEvent;
 import com.sap.sailing.domain.abstractlog.race.RaceLogProtestStartTimeEvent;
 import com.sap.sailing.domain.abstractlog.race.RaceLogRaceStatusEvent;
 import com.sap.sailing.domain.abstractlog.race.RaceLogRevokeEvent;
+import com.sap.sailing.domain.abstractlog.race.RaceLogStartOfTrackingEvent;
 import com.sap.sailing.domain.abstractlog.race.RaceLogStartProcedureChangedEvent;
 import com.sap.sailing.domain.abstractlog.race.RaceLogStartTimeEvent;
 import com.sap.sailing.domain.abstractlog.race.RaceLogWindFixEvent;
-import com.sap.sailing.domain.abstractlog.race.SuppressedMarkPassingsEvent;
+import com.sap.sailing.domain.abstractlog.race.RaceLogSuppressedMarkPassingsEvent;
 import com.sap.sailing.domain.abstractlog.race.scoring.RaceLogAdditionalScoringInformationEvent;
 import com.sap.sailing.domain.abstractlog.race.tracking.RaceLogCloseOpenEndedDeviceMappingEvent;
 import com.sap.sailing.domain.abstractlog.race.tracking.RaceLogDefineMarkEvent;
@@ -83,7 +85,10 @@ public class RaceLogEventSerializer implements JsonSerializer<RaceLogEvent>, Rac
                 new RaceLogAdditionalScoringInformationSerializer(competitorSerializer),
                 new RaceLogFixedMarkPassingEventSerializer(competitorSerializer),
                 new RaceLogSuppressedMarkPassingsEventSerializer(competitorSerializer),
-                new RaceLogDependentStartTimeEventSerializer(competitorSerializer));
+                new RaceLogDependentStartTimeEventSerializer(competitorSerializer),
+                new RaceLogStartOfTrackingEventSerializer(competitorSerializer),
+                new RaceLogEndOfTrackingEventSerializer(competitorSerializer));
+        
     }
 
     private final JsonSerializer<RaceLogEvent> flagEventSerializer;
@@ -111,9 +116,12 @@ public class RaceLogEventSerializer implements JsonSerializer<RaceLogEvent>, Rac
     private final JsonSerializer<RaceLogEvent> fixedMarkPassingEventSerializer;
     private final JsonSerializer<RaceLogEvent> suppressedMarkPassingsEventSerializer;
     private final JsonSerializer<RaceLogEvent> dependentStartTimeEventSerializer;
+    private final JsonSerializer<RaceLogEvent> startOfTrackingEventSerializer;
+    private final JsonSerializer<RaceLogEvent> endOfTrackingEventSerializer;
 
     private JsonSerializer<RaceLogEvent> chosenSerializer;
 
+
     public RaceLogEventSerializer(
             JsonSerializer<RaceLogEvent> flagEventSerializer,
             JsonSerializer<RaceLogEvent> startTimeSerializer,
@@ -139,7 +147,9 @@ public class RaceLogEventSerializer implements JsonSerializer<RaceLogEvent>, Rac
             JsonSerializer<RaceLogEvent> additionalScoringInformationSerializer,
             JsonSerializer<RaceLogEvent> fixedMarkPassingEventSerializer,
             JsonSerializer<RaceLogEvent> suppressedMarkPassingsSerializer,
-            JsonSerializer<RaceLogEvent> dependentStartTimeEventSerializer) {
+            JsonSerializer<RaceLogEvent> dependentStartTimeEventSerializer,
+            JsonSerializer<RaceLogEvent> startOfTrackingEventSerializer,
+            JsonSerializer<RaceLogEvent> endOfTrackingEventSerializer) {
         this.flagEventSerializer = flagEventSerializer;
         this.startTimeSerializer = startTimeSerializer;
         this.raceStatusSerializer = raceStatusSerializer;
@@ -164,7 +174,9 @@ public class RaceLogEventSerializer implements JsonSerializer<RaceLogEvent>, Rac
         this.additionalScoringInformationSerializer = additionalScoringInformationSerializer;
         this.fixedMarkPassingEventSerializer = fixedMarkPassingEventSerializer;
         this.suppressedMarkPassingsEventSerializer = suppressedMarkPassingsSerializer;
-        this.dependentStartTimeEventSerializer = dependentStartTimeEventSerializer; 
+        this.dependentStartTimeEventSerializer = dependentStartTimeEventSerializer;
+        this.startOfTrackingEventSerializer = startOfTrackingEventSerializer;
+        this.endOfTrackingEventSerializer = endOfTrackingEventSerializer;
         
         this.chosenSerializer = null;
     }
@@ -294,13 +306,13 @@ public class RaceLogEventSerializer implements JsonSerializer<RaceLogEvent>, Rac
     }
     
         @Override
-    public void visit(FixedMarkPassingEvent event) {
+    public void visit(RaceLogFixedMarkPassingEvent event) {
         chosenSerializer = fixedMarkPassingEventSerializer;
         
     }
 
     @Override
-    public void visit(SuppressedMarkPassingsEvent event) {
+    public void visit(RaceLogSuppressedMarkPassingsEvent event) {
         chosenSerializer = suppressedMarkPassingsEventSerializer;        
     }
     
@@ -308,4 +320,14 @@ public class RaceLogEventSerializer implements JsonSerializer<RaceLogEvent>, Rac
     public void visit(RaceLogDependentStartTimeEvent event) {
         chosenSerializer = dependentStartTimeEventSerializer;        
     }
+
+    @Override
+    public void visit(RaceLogStartOfTrackingEvent event) {
+        chosenSerializer = startOfTrackingEventSerializer;    
+    }
+
+    @Override
+    public void visit(RaceLogEndOfTrackingEvent event) {
+        chosenSerializer = endOfTrackingEventSerializer;        
+    }
 }

java/com.sap.sailing.server.gateway.serialization.shared.android/src/com/sap/sailing/server/gateway/serialization/racelog/impl/RaceLogFixedMarkPassingEventSerializer.java

@@ -2,7 +2,7 @@ package com.sap.sailing.server.gateway.serialization.racelog.impl;
 
 import org.json.simple.JSONObject;
 
-import com.sap.sailing.domain.abstractlog.race.FixedMarkPassingEvent;
+import com.sap.sailing.domain.abstractlog.race.RaceLogFixedMarkPassingEvent;
 import com.sap.sailing.domain.abstractlog.race.RaceLogEvent;
 import com.sap.sailing.domain.base.Competitor;
 import com.sap.sailing.server.gateway.serialization.JsonSerializer;
@@ -13,7 +13,7 @@ public class RaceLogFixedMarkPassingEventSerializer extends BaseRaceLogEventSeri
         super(competitorSerializer);
     }
 
-    public static final String VALUE_CLASS = FixedMarkPassingEvent.class.getSimpleName();
+    public static final String VALUE_CLASS = RaceLogFixedMarkPassingEvent.class.getSimpleName();
 
     public static final String FIELD_TIMEPOINT_OF_MARKPASSING = "timePointOfMarkPassing";
     public static final String FIELD_INDEX_OF_PASSED_WAYPOINT = "indexOfPassedWaypoint";
@@ -25,7 +25,7 @@ public class RaceLogFixedMarkPassingEventSerializer extends BaseRaceLogEventSeri
     
     @Override
     public JSONObject serialize(RaceLogEvent object) {
-        FixedMarkPassingEvent event = (FixedMarkPassingEvent) object;
+        RaceLogFixedMarkPassingEvent event = (RaceLogFixedMarkPassingEvent) object;
         
         JSONObject result = super.serialize(event);
         result.put(FIELD_INDEX_OF_PASSED_WAYPOINT, event.getZeroBasedIndexOfPassedWaypoint());

java/com.sap.sailing.server.gateway.serialization.shared.android/src/com/sap/sailing/server/gateway/serialization/racelog/impl/RaceLogStartOfTrackingEventSerializer.java

@@ -0,0 +1,21 @@
+package com.sap.sailing.server.gateway.serialization.racelog.impl;
+
+import com.sap.sailing.domain.abstractlog.race.RaceLogEvent;
+import com.sap.sailing.domain.abstractlog.race.RaceLogStartOfTrackingEvent;
+import com.sap.sailing.domain.base.Competitor;
+import com.sap.sailing.server.gateway.serialization.JsonSerializer;
+
+public class RaceLogStartOfTrackingEventSerializer extends BaseRaceLogEventSerializer implements
+        JsonSerializer<RaceLogEvent> {
+    public static final String VALUE_CLASS = RaceLogStartOfTrackingEvent.class.getSimpleName();
+
+    public RaceLogStartOfTrackingEventSerializer(JsonSerializer<Competitor> competitorSerializer) {
+        super(competitorSerializer);
+    }
+
+    @Override
+    protected String getClassFieldValue() {
+        return VALUE_CLASS;
+    }
+
+}

java/com.sap.sailing.server.gateway.serialization.shared.android/src/com/sap/sailing/server/gateway/serialization/racelog/impl/RaceLogSuppressedMarkPassingsEventSerializer.java

@@ -3,7 +3,7 @@ package com.sap.sailing.server.gateway.serialization.racelog.impl;
 import org.json.simple.JSONObject;
 
 import com.sap.sailing.domain.abstractlog.race.RaceLogEvent;
-import com.sap.sailing.domain.abstractlog.race.SuppressedMarkPassingsEvent;
+import com.sap.sailing.domain.abstractlog.race.RaceLogSuppressedMarkPassingsEvent;
 import com.sap.sailing.domain.base.Competitor;
 import com.sap.sailing.server.gateway.serialization.JsonSerializer;
 
@@ -13,7 +13,7 @@ public class RaceLogSuppressedMarkPassingsEventSerializer extends BaseRaceLogEve
         super(competitorSerializer);
     }
     
-    public static final String VALUE_CLASS = SuppressedMarkPassingsEvent.class.getSimpleName();
+    public static final String VALUE_CLASS = RaceLogSuppressedMarkPassingsEvent.class.getSimpleName();
     
     public final static String FIELD_INDEX_OF_FIRST_SUPPRESSED_WAYPOINTS = "indexOfFirstSuppressedWaypoints";
 
@@ -24,7 +24,7 @@ public class RaceLogSuppressedMarkPassingsEventSerializer extends BaseRaceLogEve
     
     @Override
     public JSONObject serialize(RaceLogEvent object) {
-        SuppressedMarkPassingsEvent event = (SuppressedMarkPassingsEvent) object;
+        RaceLogSuppressedMarkPassingsEvent event = (RaceLogSuppressedMarkPassingsEvent) object;
         
         JSONObject result = super.serialize(event);
         result.put(FIELD_INDEX_OF_FIRST_SUPPRESSED_WAYPOINTS, event.getZeroBasedIndexOfFirstSuppressedWaypoint());

java/com.sap.sailing.server.gateway.serialization.test/src/com/sap/sailing/server/gateway/serialization/test/racelog/RaceLogEventSerializerTest.java

@@ -49,6 +49,8 @@ public class RaceLogEventSerializerTest {
     private JsonSerializer<RaceLogEvent> fixedMarkPassingEventSerializer;
     private JsonSerializer<RaceLogEvent> suppressedMarkPassingsSerializer;
     private JsonSerializer<RaceLogEvent> dependentStartTimeEventSerializer;
+    private JsonSerializer<RaceLogEvent> startOfTrackingEventSerializer;
+    private JsonSerializer<RaceLogEvent> endOfTrackingEventSerializer;
 
     private RaceLogEventFactory factory;
     private AbstractLogEventAuthor author = new LogEventAuthorImpl("Test Author", 1);
@@ -81,6 +83,8 @@ public class RaceLogEventSerializerTest {
         fixedMarkPassingEventSerializer = mock(JsonSerializer.class);
         suppressedMarkPassingsSerializer = mock(JsonSerializer.class);
         dependentStartTimeEventSerializer = mock(JsonSerializer.class);
+        startOfTrackingEventSerializer = mock(JsonSerializer.class);
+        endOfTrackingEventSerializer = mock(JsonSerializer.class);
 
         serializer = new RaceLogEventSerializer(flagEventSerializer, startTimeSerializer, raceStatusSerializer,
                 courseAreaChangedEventSerializer, passChangedSerializer, courseDesignChangedEventSerializer,
@@ -92,7 +96,7 @@ public class RaceLogEventSerializerTest {
                 registerCompetitorEventSerializer, defineMarkEventSerializer,
                 closeOpenEndedDeviceMappingEventSerializer, fixedMarkPassingEventSerializer,
                 suppressedMarkPassingsSerializer, additionalScoringInformationSerializer,
-                dependentStartTimeEventSerializer);
+                dependentStartTimeEventSerializer, startOfTrackingEventSerializer, endOfTrackingEventSerializer);
 
         factory = RaceLogEventFactory.INSTANCE;
     }