added DefineMarkEvent

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

@@ -128,6 +128,7 @@ import com.sap.sailing.domain.racelog.RevokeEvent;
 import com.sap.sailing.domain.racelog.impl.CompetitorResultsImpl;
 import com.sap.sailing.domain.racelog.impl.RaceLogEventAuthorImpl;
 import com.sap.sailing.domain.racelog.impl.RaceLogImpl;
+import com.sap.sailing.domain.racelog.tracking.DefineMarkEvent;
 import com.sap.sailing.domain.racelog.tracking.DenoteForTrackingEvent;
 import com.sap.sailing.domain.racelog.tracking.DeviceCompetitorMappingEvent;
 import com.sap.sailing.domain.racelog.tracking.DeviceIdentifier;
@@ -1173,6 +1174,8 @@ public class DomainObjectFactoryImpl implements DomainObjectFactory {
             return loadRaceLogRevokeEvent(createdAt, author, logicalTimePoint, id, passId, competitors, dbObject);
         } else if (eventClass.equals(RegisterCompetitorEvent.class.getSimpleName())) {
             return loadRaceLogRegisterCompetitorEvent(createdAt, author, logicalTimePoint, id, passId, competitors, dbObject);
+        } else if (eventClass.equals(DefineMarkEvent.class.getSimpleName())) {
+            return loadRaceLogDefineMarkEvent(createdAt, author, logicalTimePoint, id, passId, competitors, dbObject);
         }
 
         throw new IllegalStateException(String.format("Unknown RaceLogEvent type %s", eventClass));
@@ -1243,6 +1246,12 @@ public class DomainObjectFactoryImpl implements DomainObjectFactory {
         return raceLogEventFactory.createRegisterCompetitorEvent(createdAt, author, logicalTimePoint, id, passId, competitors.get(0));
     }
 
+    private RaceLogEvent loadRaceLogDefineMarkEvent(TimePoint createdAt, RaceLogEventAuthor author, TimePoint logicalTimePoint,
+            Serializable id, Integer passId, List<Competitor> competitors, DBObject dbObject) {
+        Mark mark = loadMark((DBObject) dbObject.get(FieldNames.RACE_LOG_MARK.name()));
+        return raceLogEventFactory.createDefineMarkEvent(createdAt, author, logicalTimePoint, id, passId, mark);
+    }
+
     private RaceLogEvent loadRaceLogRaceLogProtestStartTimeEvent(TimePoint createdAt, RaceLogEventAuthor author,
             TimePoint logicalTimePoint, Serializable id, Integer passId, List<Competitor> competitors, DBObject dbObject) {
         TimePoint protestStartTime = loadTimePoint(dbObject, FieldNames.RACE_LOG_PROTEST_START_TIME);

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

@@ -76,7 +76,7 @@ public enum FieldNames {
     WAYPOINT_PASSINGINSTRUCTIONS, CONTROLPOINT, CONTROLPOINT_CLASS, MARK_ID, MARK_COLOR, MARK_NAME, MARK_PATTERN, MARK_SHAPE, MARK_TYPE,
     CONTROLPOINT_VALUE, CONTROLPOINTWITHTWOMARKS_ID, CONTROLPOINTWITHTWOMARKS_NAME, CONTROLPOINTWITHTWOMARKS_LEFT, CONTROLPOINTWITHTWOMARKS_RIGHT,
     RACE_LOG_POSITIONED_COMPETITORS, RACE_LOG_PATHFINDER_ID, RACE_LOG_GATE_LINE_OPENING_TIME, RACE_LOG_GOLF_DOWN_TIME, RACE_LOG_START_PROCEDURE_TYPE,
-    RACE_LOG_PROTEST_START_TIME, RACE_LOG_COURSE_DESIGN_NAME, RACE_LOG_REVOKED_EVENT_ID, RACE_LOG_FROM, RACE_LOG_TO,
+    RACE_LOG_PROTEST_START_TIME, RACE_LOG_COURSE_DESIGN_NAME, RACE_LOG_REVOKED_EVENT_ID, RACE_LOG_FROM, RACE_LOG_TO, RACE_LOG_MARK,
     /** @deprecated Replaced by WAYPOINT_PASSINGINSTRUCTIONS, still used to migrate old races*/ @Deprecated WAYPOINT_PASSINGSIDE,
     /** @deprecated Replaced by CONTROLPOINTWITHTWOMARKS_ID, still used to migrate old races*/ @Deprecated GATE_ID,
     /** @deprecated Replaced by CONTROLPOINTWITHTWOMARKS_NAME, still used to migrate old races*/ @Deprecated GATE_NAME,

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

@@ -79,6 +79,7 @@ import com.sap.sailing.domain.racelog.RaceLogStartProcedureChangedEvent;
 import com.sap.sailing.domain.racelog.RaceLogStartTimeEvent;
 import com.sap.sailing.domain.racelog.RaceLogWindFixEvent;
 import com.sap.sailing.domain.racelog.RevokeEvent;
+import com.sap.sailing.domain.racelog.tracking.DefineMarkEvent;
 import com.sap.sailing.domain.racelog.tracking.DenoteForTrackingEvent;
 import com.sap.sailing.domain.racelog.tracking.DeviceCompetitorMappingEvent;
 import com.sap.sailing.domain.racelog.tracking.DeviceIdentifier;
@@ -750,6 +751,14 @@ public class MongoObjectFactoryImpl implements MongoObjectFactory {
         result.put(FieldNames.RACE_LOG_EVENT.name(), storeRaceLogRegisterCompetitorEvent(event));
         return result;
     }
+
+    public DBObject storeRaceLogEntry(RaceLogIdentifier raceLogIdentifier, DefineMarkEvent event) {
+        BasicDBObject result = new BasicDBObject();
+        result.put(FieldNames.RACE_LOG_IDENTIFIER.name(), TripleSerializer.serialize(raceLogIdentifier.getIdentifier()));
+
+        result.put(FieldNames.RACE_LOG_EVENT.name(), storeRaceLogDefineMarkEvent(event));
+        return result;
+    }
     
     private Object storeRaceLogWindFix(RaceLogWindFixEvent event) {
         DBObject result = new BasicDBObject();
@@ -861,6 +870,15 @@ public class MongoObjectFactoryImpl implements MongoObjectFactory {
         return result;
     }
 
+    private Object storeRaceLogDefineMarkEvent(DefineMarkEvent event) {
+        DBObject result = new BasicDBObject();
+        storeRaceLogEventProperties(event, result);
+
+        result.put(FieldNames.RACE_LOG_EVENT_CLASS.name(), DefineMarkEvent.class.getSimpleName());
+        result.put(FieldNames.RACE_LOG_MARK.name(), storeMark(event.getMark()));
+        return result;
+    }
+
     public DBObject storeRaceLogFlagEvent(RaceLogFlagEvent flagEvent) {
         DBObject result = new BasicDBObject();
         storeRaceLogEventProperties(flagEvent, result);

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

@@ -21,6 +21,7 @@ import com.sap.sailing.domain.racelog.RaceLogStartProcedureChangedEvent;
 import com.sap.sailing.domain.racelog.RaceLogStartTimeEvent;
 import com.sap.sailing.domain.racelog.RaceLogWindFixEvent;
 import com.sap.sailing.domain.racelog.RevokeEvent;
+import com.sap.sailing.domain.racelog.tracking.DefineMarkEvent;
 import com.sap.sailing.domain.racelog.tracking.DenoteForTrackingEvent;
 import com.sap.sailing.domain.racelog.tracking.DeviceCompetitorMappingEvent;
 import com.sap.sailing.domain.racelog.tracking.DeviceMarkMappingEvent;
@@ -125,40 +126,45 @@ public class MongoRaceLogStoreVisitor implements RaceLogEventVisitor {
         storeEventInCollection(object);
     }
 
-	@Override
-	public void visit(DeviceCompetitorMappingEvent event) {
+    @Override
+    public void visit(DeviceCompetitorMappingEvent event) {
         DBObject object = mongoObjectFactory.storeRaceLogEntry(raceLogIdentifier, event);
         storeEventInCollection(object);
-	}
+    }
 
-	@Override
-	public void visit(DeviceMarkMappingEvent event) {
+    @Override
+    public void visit(DeviceMarkMappingEvent event) {
         DBObject object = mongoObjectFactory.storeRaceLogEntry(raceLogIdentifier, event);
         storeEventInCollection(object);
-	}
+    }
 
-	@Override
-	public void visit(DenoteForTrackingEvent event) {
+    @Override
+    public void visit(DenoteForTrackingEvent event) {
         DBObject object = mongoObjectFactory.storeRaceLogEntry(raceLogIdentifier, event);
         storeEventInCollection(object);
-	}
+    }
 
-	@Override
-	public void visit(StartTrackingEvent event) {
+    @Override
+    public void visit(StartTrackingEvent event) {
         DBObject object = mongoObjectFactory.storeRaceLogEntry(raceLogIdentifier, event);
         storeEventInCollection(object);
-	}
+    }
 
-	@Override
-	public void visit(RevokeEvent event) {
+    @Override
+    public void visit(RevokeEvent event) {
         DBObject object = mongoObjectFactory.storeRaceLogEntry(raceLogIdentifier, event);
         storeEventInCollection(object);
-	}
+    }
 
-	@Override
-	public void visit(RegisterCompetitorEvent event) {
+    @Override
+    public void visit(RegisterCompetitorEvent event) {
         DBObject object = mongoObjectFactory.storeRaceLogEntry(raceLogIdentifier, event);
         storeEventInCollection(object);
-	}
+    }
 
+    @Override
+    public void visit(DefineMarkEvent event) {
+        DBObject object = mongoObjectFactory.storeRaceLogEntry(raceLogIdentifier, event);
+        storeEventInCollection(object);
+    }
 }

java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/racelog/RaceLogEventFactory.java

@@ -12,6 +12,7 @@ import com.sap.sailing.domain.common.racelog.Flags;
 import com.sap.sailing.domain.common.racelog.RaceLogRaceStatus;
 import com.sap.sailing.domain.common.racelog.RacingProcedureType;
 import com.sap.sailing.domain.racelog.impl.RaceLogEventFactoryImpl;
+import com.sap.sailing.domain.racelog.tracking.DefineMarkEvent;
 import com.sap.sailing.domain.racelog.tracking.DenoteForTrackingEvent;
 import com.sap.sailing.domain.racelog.tracking.DeviceCompetitorMappingEvent;
 import com.sap.sailing.domain.racelog.tracking.DeviceIdentifier;
@@ -110,5 +111,6 @@ public interface RaceLogEventFactory {
     RevokeEvent createRevokeEvent(TimePoint logicalTimePoint, RaceLogEventAuthor author, int passId, Serializable revokedEventId);
     
     RegisterCompetitorEvent createRegisterCompetitorEvent(TimePoint logicalTimePoint, RaceLogEventAuthor author, int passId, Competitor competitor);
-
+    
+    DefineMarkEvent createDefineMarkEvent(TimePoint logicalTimePoint, RaceLogEventAuthor author, int passId, Mark mark);
 }

java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/racelog/RaceLogEventRestoreFactory.java

@@ -12,6 +12,7 @@ import com.sap.sailing.domain.common.racelog.Flags;
 import com.sap.sailing.domain.common.racelog.RaceLogRaceStatus;
 import com.sap.sailing.domain.common.racelog.RacingProcedureType;
 import com.sap.sailing.domain.racelog.impl.RaceLogEventRestoreFactoryImpl;
+import com.sap.sailing.domain.racelog.tracking.DefineMarkEvent;
 import com.sap.sailing.domain.racelog.tracking.DenoteForTrackingEvent;
 import com.sap.sailing.domain.racelog.tracking.DeviceCompetitorMappingEvent;
 import com.sap.sailing.domain.racelog.tracking.DeviceIdentifier;
@@ -82,4 +83,7 @@ public interface RaceLogEventRestoreFactory extends RaceLogEventFactory {
     
     RegisterCompetitorEvent createRegisterCompetitorEvent(TimePoint createdAt, RaceLogEventAuthor author,
     		TimePoint logicalTimePoint, Serializable pId, int passId, Competitor competitor);
+    
+    DefineMarkEvent createDefineMarkEvent(TimePoint createdAt, RaceLogEventAuthor author,
+                TimePoint logicalTimePoint, Serializable pId, int passId, Mark mark);
 }

java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/racelog/RaceLogEventVisitor.java

@@ -1,10 +1,11 @@
 package com.sap.sailing.domain.racelog;
 
-import com.sap.sailing.domain.racelog.tracking.RegisterCompetitorEvent;
-import com.sap.sailing.domain.racelog.tracking.StartTrackingEvent;
+import com.sap.sailing.domain.racelog.tracking.DefineMarkEvent;
 import com.sap.sailing.domain.racelog.tracking.DenoteForTrackingEvent;
 import com.sap.sailing.domain.racelog.tracking.DeviceCompetitorMappingEvent;
 import com.sap.sailing.domain.racelog.tracking.DeviceMarkMappingEvent;
+import com.sap.sailing.domain.racelog.tracking.RegisterCompetitorEvent;
+import com.sap.sailing.domain.racelog.tracking.StartTrackingEvent;
 
 
 public interface RaceLogEventVisitor {
@@ -45,4 +46,6 @@ public interface RaceLogEventVisitor {
     public void visit(RevokeEvent event);
     
     public void visit(RegisterCompetitorEvent event);
+    
+    public void visit(DefineMarkEvent event);
 }

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

@@ -15,6 +15,7 @@ import com.sap.sailing.domain.racelog.RaceLogStartProcedureChangedEvent;
 import com.sap.sailing.domain.racelog.RaceLogStartTimeEvent;
 import com.sap.sailing.domain.racelog.RaceLogWindFixEvent;
 import com.sap.sailing.domain.racelog.RevokeEvent;
+import com.sap.sailing.domain.racelog.tracking.DefineMarkEvent;
 import com.sap.sailing.domain.racelog.tracking.RegisterCompetitorEvent;
 import com.sap.sailing.domain.racelog.tracking.StartTrackingEvent;
 import com.sap.sailing.domain.racelog.tracking.DenoteForTrackingEvent;
@@ -120,5 +121,10 @@ public abstract class BaseRaceLogEventVisitor implements RaceLogEventVisitor {
     public void visit(RegisterCompetitorEvent event) {
 
     }
+    
+    @Override
+    public void visit(DefineMarkEvent event) {
+         
+    }
 
 }

java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/racelog/impl/RaceLogChangedVisitor.java

@@ -16,6 +16,7 @@ import com.sap.sailing.domain.racelog.RaceLogStartProcedureChangedEvent;
 import com.sap.sailing.domain.racelog.RaceLogStartTimeEvent;
 import com.sap.sailing.domain.racelog.RaceLogWindFixEvent;
 import com.sap.sailing.domain.racelog.RevokeEvent;
+import com.sap.sailing.domain.racelog.tracking.DefineMarkEvent;
 import com.sap.sailing.domain.racelog.tracking.RegisterCompetitorEvent;
 import com.sap.sailing.domain.racelog.tracking.StartTrackingEvent;
 import com.sap.sailing.domain.racelog.tracking.DenoteForTrackingEvent;
@@ -89,34 +90,38 @@ public class RaceLogChangedVisitor implements RaceLogEventVisitor {
         listener.eventAdded(event);
     }
 
-	@Override
-	public void visit(DeviceCompetitorMappingEvent event) {
+    @Override
+    public void visit(DeviceCompetitorMappingEvent event) {
         listener.eventAdded(event);
-	}
+    }
 
-	@Override
-	public void visit(DeviceMarkMappingEvent event) {
+    @Override
+    public void visit(DeviceMarkMappingEvent event) {
         listener.eventAdded(event);
-	}
+    }
 
-	@Override
-	public void visit(DenoteForTrackingEvent event) {
+    @Override
+    public void visit(DenoteForTrackingEvent event) {
         listener.eventAdded(event);
-	}
+    }
 
-	@Override
-	public void visit(StartTrackingEvent event) {
+    @Override
+    public void visit(StartTrackingEvent event) {
         listener.eventAdded(event);
-	}
+    }
 
-	@Override
-	public void visit(RevokeEvent event) {
+    @Override
+    public void visit(RevokeEvent event) {
         listener.eventAdded(event);
-	}
+    }
 
-	@Override
-	public void visit(RegisterCompetitorEvent event) {
-		listener.eventAdded(event);
-	}
+    @Override
+    public void visit(RegisterCompetitorEvent event) {
+        listener.eventAdded(event);
+    }
 
+    @Override
+    public void visit(DefineMarkEvent event) {
+        listener.eventAdded(event);
+    }
 }

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

@@ -30,12 +30,14 @@ import com.sap.sailing.domain.racelog.RaceLogStartProcedureChangedEvent;
 import com.sap.sailing.domain.racelog.RaceLogStartTimeEvent;
 import com.sap.sailing.domain.racelog.RaceLogWindFixEvent;
 import com.sap.sailing.domain.racelog.RevokeEvent;
+import com.sap.sailing.domain.racelog.tracking.DefineMarkEvent;
 import com.sap.sailing.domain.racelog.tracking.RegisterCompetitorEvent;
 import com.sap.sailing.domain.racelog.tracking.StartTrackingEvent;
 import com.sap.sailing.domain.racelog.tracking.DenoteForTrackingEvent;
 import com.sap.sailing.domain.racelog.tracking.DeviceCompetitorMappingEvent;
 import com.sap.sailing.domain.racelog.tracking.DeviceIdentifier;
 import com.sap.sailing.domain.racelog.tracking.DeviceMarkMappingEvent;
+import com.sap.sailing.domain.racelog.tracking.events.DefineMarkEventImpl;
 import com.sap.sailing.domain.racelog.tracking.events.RegisterCompetitorEventImpl;
 import com.sap.sailing.domain.racelog.tracking.events.StartTrackingEventImpl;
 import com.sap.sailing.domain.racelog.tracking.events.DenoteForTrackingEventImpl;
@@ -215,40 +217,46 @@ public class RaceLogEventFactoryImpl implements RaceLogEventFactory {
         return new RaceLogWindFixEventImpl(MillisecondsTimePoint.now(), author, logicalTimePoint, id, competitors, passId, wind);
     }
 
-	@Override
-	public DeviceCompetitorMappingEvent createDeviceCompetitorMappingEvent(TimePoint logicalTimePoint, RaceLogEventAuthor author,
-			DeviceIdentifier device, Competitor mappedTo, int passId, TimePoint from, TimePoint to) {
-		return new DeviceCompetitorMappingEventImpl(MillisecondsTimePoint.now(), author, logicalTimePoint, UUID.randomUUID(),
-				passId, mappedTo, device, from, to);
-	}
+    @Override
+    public DeviceCompetitorMappingEvent createDeviceCompetitorMappingEvent(TimePoint logicalTimePoint, RaceLogEventAuthor author,
+            DeviceIdentifier device, Competitor mappedTo, int passId, TimePoint from, TimePoint to) {
+        return new DeviceCompetitorMappingEventImpl(MillisecondsTimePoint.now(), author, logicalTimePoint, UUID.randomUUID(),
+                passId, mappedTo, device, from, to);
+    }
+
+    @Override
+    public DeviceMarkMappingEvent createDeviceMarkMappingEvent(TimePoint logicalTimePoint, RaceLogEventAuthor author,
+            DeviceIdentifier device, Mark mappedTo, int passId, TimePoint from, TimePoint to) {
+        return new DeviceMarkMappingEventImpl(MillisecondsTimePoint.now(), author, logicalTimePoint, UUID.randomUUID(),
+                passId, mappedTo, device, from, to);
+    }
+
+    @Override
+    public DenoteForTrackingEvent createDenoteForTrackingEvent(TimePoint logicalTimePoint, RaceLogEventAuthor author, int passId,
+            String raceName, BoatClass boatClass) {
+        return new DenoteForTrackingEventImpl(MillisecondsTimePoint.now(), author, logicalTimePoint, UUID.randomUUID(), passId, raceName, boatClass);
+    }
+
+    @Override
+    public StartTrackingEvent createStartTrackingEvent(TimePoint logicalTimePoint, RaceLogEventAuthor author, int passId) {
+        return new StartTrackingEventImpl(MillisecondsTimePoint.now(), author, logicalTimePoint, UUID.randomUUID(), passId);
+    }
+
+    @Override
+    public RevokeEvent createRevokeEvent(TimePoint logicalTimePoint, RaceLogEventAuthor author, int passId, Serializable revokedEventId) {
+        return new RevokeEventImpl(MillisecondsTimePoint.now(), author, logicalTimePoint, UUID.randomUUID(), passId, revokedEventId);
+    }
 
-	@Override
-	public DeviceMarkMappingEvent createDeviceMarkMappingEvent(TimePoint logicalTimePoint, RaceLogEventAuthor author,
-			DeviceIdentifier device, Mark mappedTo, int passId, TimePoint from, TimePoint to) {
-		return new DeviceMarkMappingEventImpl(MillisecondsTimePoint.now(), author, logicalTimePoint, UUID.randomUUID(),
-				passId, mappedTo, device, from, to);
-	}
-	
-	@Override
-	public DenoteForTrackingEvent createDenoteForTrackingEvent(TimePoint logicalTimePoint, RaceLogEventAuthor author, int passId,
-			String raceName, BoatClass boatClass) {
-		return new DenoteForTrackingEventImpl(MillisecondsTimePoint.now(), author, logicalTimePoint, UUID.randomUUID(), passId, raceName, boatClass);
-	}
-	
-	@Override
-	public StartTrackingEvent createStartTrackingEvent(TimePoint logicalTimePoint, RaceLogEventAuthor author, int passId) {
-		return new StartTrackingEventImpl(MillisecondsTimePoint.now(), author, logicalTimePoint, UUID.randomUUID(), passId);
-	}
-	
-	@Override
-	public RevokeEvent createRevokeEvent(TimePoint logicalTimePoint, RaceLogEventAuthor author, int passId, Serializable revokedEventId) {
-		return new RevokeEventImpl(MillisecondsTimePoint.now(), author, logicalTimePoint, UUID.randomUUID(), passId, revokedEventId);
-	}
-    
     @Override
     public RegisterCompetitorEvent createRegisterCompetitorEvent(TimePoint logicalTimePoint, RaceLogEventAuthor author,
-    		int passId, Competitor competitor) {
-    	return new RegisterCompetitorEventImpl(MillisecondsTimePoint.now(), author, logicalTimePoint, UUID.randomUUID(), passId, competitor);
+            int passId, Competitor competitor) {
+        return new RegisterCompetitorEventImpl(MillisecondsTimePoint.now(), author, logicalTimePoint, UUID.randomUUID(), passId, competitor);
+    }
+
+    @Override
+    public DefineMarkEvent createDefineMarkEvent(TimePoint logicalTimePoint, RaceLogEventAuthor author,
+            int passId, Mark mark) {
+        return new DefineMarkEventImpl(MillisecondsTimePoint.now(), author, logicalTimePoint, UUID.randomUUID(), passId, mark);
     }
 
 }

java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/racelog/impl/RaceLogEventRestoreFactoryImpl.java

@@ -28,12 +28,14 @@ import com.sap.sailing.domain.racelog.RaceLogStartProcedureChangedEvent;
 import com.sap.sailing.domain.racelog.RaceLogStartTimeEvent;
 import com.sap.sailing.domain.racelog.RaceLogWindFixEvent;
 import com.sap.sailing.domain.racelog.RevokeEvent;
+import com.sap.sailing.domain.racelog.tracking.DefineMarkEvent;
 import com.sap.sailing.domain.racelog.tracking.DenoteForTrackingEvent;
 import com.sap.sailing.domain.racelog.tracking.DeviceCompetitorMappingEvent;
 import com.sap.sailing.domain.racelog.tracking.DeviceIdentifier;
 import com.sap.sailing.domain.racelog.tracking.DeviceMarkMappingEvent;
 import com.sap.sailing.domain.racelog.tracking.RegisterCompetitorEvent;
 import com.sap.sailing.domain.racelog.tracking.StartTrackingEvent;
+import com.sap.sailing.domain.racelog.tracking.events.DefineMarkEventImpl;
 import com.sap.sailing.domain.racelog.tracking.events.DenoteForTrackingEventImpl;
 import com.sap.sailing.domain.racelog.tracking.events.DeviceCompetitorMappingEventImpl;
 import com.sap.sailing.domain.racelog.tracking.events.DeviceMarkMappingEventImpl;
@@ -126,39 +128,45 @@ public class RaceLogEventRestoreFactoryImpl extends RaceLogEventFactoryImpl impl
 
     @Override
     public DeviceCompetitorMappingEvent createDeviceCompetitorMappingEvent(TimePoint createdAt, RaceLogEventAuthor author,
-    		TimePoint logicalTimePoint, Serializable pId, DeviceIdentifier device, Competitor mappedTo, int passId, TimePoint from, TimePoint to) {
-    	return new DeviceCompetitorMappingEventImpl(createdAt, author, logicalTimePoint, pId, passId, mappedTo, device, from, to);
+            TimePoint logicalTimePoint, Serializable pId, DeviceIdentifier device, Competitor mappedTo, int passId, TimePoint from, TimePoint to) {
+        return new DeviceCompetitorMappingEventImpl(createdAt, author, logicalTimePoint, pId, passId, mappedTo, device, from, to);
     }
-    
+
     @Override
     public DeviceMarkMappingEvent createDeviceMarkMappingEvent(TimePoint createdAt, RaceLogEventAuthor author,
-    		TimePoint logicalTimePoint, Serializable pId, DeviceIdentifier device, Mark mappedTo, int passId, TimePoint from,
-    		TimePoint to) {
-    	return new DeviceMarkMappingEventImpl(createdAt, author, logicalTimePoint, pId, passId, mappedTo, device, from, to);
+            TimePoint logicalTimePoint, Serializable pId, DeviceIdentifier device, Mark mappedTo, int passId, TimePoint from,
+            TimePoint to) {
+        return new DeviceMarkMappingEventImpl(createdAt, author, logicalTimePoint, pId, passId, mappedTo, device, from, to);
     }
-    
+
     @Override
     public DenoteForTrackingEvent createDenoteForTrackingEvent(TimePoint createdAt, RaceLogEventAuthor author,
-    		TimePoint logicalTimePoint, Serializable pId, int passId, String raceName, BoatClass boatClass) {
-    	return new DenoteForTrackingEventImpl(createdAt, author, logicalTimePoint, pId, passId, raceName, boatClass);
+            TimePoint logicalTimePoint, Serializable pId, int passId, String raceName, BoatClass boatClass) {
+        return new DenoteForTrackingEventImpl(createdAt, author, logicalTimePoint, pId, passId, raceName, boatClass);
     }
-    
+
     @Override
     public StartTrackingEvent createStartTrackingEvent(TimePoint createdAt, RaceLogEventAuthor author, TimePoint logicalTimePoint,
-    		Serializable pId, int passId) {
-    	return new StartTrackingEventImpl(createdAt, author, logicalTimePoint, pId, passId);
+            Serializable pId, int passId) {
+        return new StartTrackingEventImpl(createdAt, author, logicalTimePoint, pId, passId);
     }
-    
+
     @Override
     public RevokeEvent createRevokeEvent(TimePoint createdAt, RaceLogEventAuthor author, TimePoint logicalTimePoint,
-    		Serializable pId, int passId, Serializable revokedEventId) {
-    	return new RevokeEventImpl(createdAt, author, logicalTimePoint, pId, passId, revokedEventId);
+            Serializable pId, int passId, Serializable revokedEventId) {
+        return new RevokeEventImpl(createdAt, author, logicalTimePoint, pId, passId, revokedEventId);
     }
-    
+
     @Override
     public RegisterCompetitorEvent createRegisterCompetitorEvent(TimePoint createdAt, RaceLogEventAuthor author, TimePoint logicalTimePoint,
-    		Serializable pId, int passId, Competitor competitor) {
-    	return new RegisterCompetitorEventImpl(createdAt, author, logicalTimePoint, pId, passId, competitor);
+            Serializable pId, int passId, Competitor competitor) {
+        return new RegisterCompetitorEventImpl(createdAt, author, logicalTimePoint, pId, passId, competitor);
+    }
+
+    @Override
+    public DefineMarkEvent createDefineMarkEvent(TimePoint createdAt, RaceLogEventAuthor author, TimePoint logicalTimePoint,
+            Serializable pId, int passId, Mark mark) {
+        return new DefineMarkEventImpl(createdAt, author, logicalTimePoint, pId, passId, mark);
     }
 
 }

java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/racelog/tracking/DefineMarkEvent.java

@@ -0,0 +1,13 @@
+package com.sap.sailing.domain.racelog.tracking;
+
+import com.sap.sailing.domain.base.Mark;
+import com.sap.sailing.domain.racelog.RaceLogEvent;
+
+/**
+ * Defines a mark, that can then be used to build a course.
+ * @author Fredrik Teschke
+ *
+ */
+public interface DefineMarkEvent extends RaceLogEvent {
+    Mark getMark();
+}

java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/racelog/tracking/analyzing/impl/DefinedMarkFinder.java

@@ -0,0 +1,30 @@
+package com.sap.sailing.domain.racelog.tracking.analyzing.impl;
+
+import java.io.Serializable;
+import java.util.HashMap;
+import java.util.Map;
+
+import com.sap.sailing.domain.base.Mark;
+import com.sap.sailing.domain.racelog.RaceLog;
+import com.sap.sailing.domain.racelog.RaceLogEvent;
+import com.sap.sailing.domain.racelog.analyzing.impl.RaceLogAnalyzer;
+import com.sap.sailing.domain.racelog.tracking.DefineMarkEvent;
+
+public class DefinedMarkFinder extends RaceLogAnalyzer<Iterable<Mark>> {
+    public DefinedMarkFinder(RaceLog raceLog) {
+        super(raceLog);
+    }
+
+    @Override
+    protected Iterable<Mark> performAnalysis() {
+        Map<Serializable, Mark> result = new HashMap<Serializable, Mark>();
+        for (RaceLogEvent event : getAllEvents()) {
+            if (event instanceof DefineMarkEvent) {
+                DefineMarkEvent dME = (DefineMarkEvent) event;
+                result.put(dME.getMark().getId(), dME.getMark());
+            }
+        }
+        return result.values();
+    }
+
+}

java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/racelog/tracking/events/DefineMarkEventImpl.java

@@ -0,0 +1,35 @@
+package com.sap.sailing.domain.racelog.tracking.events;
+
+import java.io.Serializable;
+import java.util.Collections;
+
+import com.sap.sailing.domain.base.Competitor;
+import com.sap.sailing.domain.base.Mark;
+import com.sap.sailing.domain.common.TimePoint;
+import com.sap.sailing.domain.racelog.RaceLogEventAuthor;
+import com.sap.sailing.domain.racelog.RaceLogEventVisitor;
+import com.sap.sailing.domain.racelog.impl.RaceLogEventImpl;
+import com.sap.sailing.domain.racelog.tracking.DefineMarkEvent;
+
+public class DefineMarkEventImpl extends RaceLogEventImpl implements DefineMarkEvent {
+    private static final long serialVersionUID = 277007856878002208L;
+    
+    private final Mark mark;
+    
+    public DefineMarkEventImpl(TimePoint createdAt, RaceLogEventAuthor author, TimePoint logicalTimePoint,
+            Serializable pId, int pPassId, Mark mark) {
+        super(createdAt, author, logicalTimePoint, pId, Collections.<Competitor>emptyList(), pPassId);
+         this.mark = mark;
+    }
+
+    @Override
+    public void accept(RaceLogEventVisitor visitor) {
+        visitor.visit(this);
+    }
+
+    @Override
+    public Mark getMark() {
+        return mark;
+    }
+
+}

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

@@ -20,6 +20,7 @@ import com.sap.sailing.domain.racelog.RaceLogStartProcedureChangedEvent;
 import com.sap.sailing.domain.racelog.RaceLogStartTimeEvent;
 import com.sap.sailing.domain.racelog.RaceLogWindFixEvent;
 import com.sap.sailing.domain.racelog.RevokeEvent;
+import com.sap.sailing.domain.racelog.tracking.DefineMarkEvent;
 import com.sap.sailing.domain.racelog.tracking.RegisterCompetitorEvent;
 import com.sap.sailing.domain.racelog.tracking.StartTrackingEvent;
 import com.sap.sailing.domain.racelog.tracking.DenoteForTrackingEvent;
@@ -109,33 +110,38 @@ public class RaceColumnRaceLogReplicator implements RaceLogEventVisitor, Seriali
         notifyOnAdd(event);
     }
 
-	@Override
-	public void visit(DeviceCompetitorMappingEvent event) {
+    @Override
+    public void visit(DeviceCompetitorMappingEvent event) {
         notifyOnAdd(event);
-	}
+    }
 
-	@Override
-	public void visit(DeviceMarkMappingEvent event) {
+    @Override
+    public void visit(DeviceMarkMappingEvent event) {
         notifyOnAdd(event);
-	}
+    }
 
-	@Override
-	public void visit(DenoteForTrackingEvent event) {
+    @Override
+    public void visit(DenoteForTrackingEvent event) {
         notifyOnAdd(event);
-	}
+    }
 
-	@Override
-	public void visit(StartTrackingEvent event) {
+    @Override
+    public void visit(StartTrackingEvent event) {
         notifyOnAdd(event);
-	}
+    }
 
-	@Override
-	public void visit(RevokeEvent event) {
+    @Override
+    public void visit(RevokeEvent event) {
         notifyOnAdd(event);
-	}
+    }
 
-	@Override
-	public void visit(RegisterCompetitorEvent event) {
+    @Override
+    public void visit(RegisterCompetitorEvent event) {
         notifyOnAdd(event);
-	}
+    }
+    
+    @Override
+    public void visit(DefineMarkEvent event) {
+        notifyOnAdd(event);
+    }
 }

java/com.sap.sailing.mongodb.test/src/com/sap/sailing/mongodb/test/StoreAndLoadRaceLogEventsTest.java

@@ -43,6 +43,7 @@ import com.sap.sailing.domain.racelog.RaceLogRaceStatusEvent;
 import com.sap.sailing.domain.racelog.RaceLogStartTimeEvent;
 import com.sap.sailing.domain.racelog.RevokeEvent;
 import com.sap.sailing.domain.racelog.impl.RaceLogEventAuthorImpl;
+import com.sap.sailing.domain.racelog.tracking.DefineMarkEvent;
 import com.sap.sailing.domain.racelog.tracking.DenoteForTrackingEvent;
 import com.sap.sailing.domain.racelog.tracking.DeviceCompetitorMappingEvent;
 import com.sap.sailing.domain.racelog.tracking.DeviceIdentifier;
@@ -249,6 +250,19 @@ public class StoreAndLoadRaceLogEventsTest extends AbstractMongoDBTest {
         assertEquals(expectedEvent.getCompetitor(), actualEvent.getCompetitor());
     }
 
+    @Test
+    public void testStoreAndLoadDefineMarkEvent() {
+        DefineMarkEvent expectedEvent = eventFactory.createDefineMarkEvent(
+                        expectedEventTime, author, expectedEventTime, expectedId, expectedPassId,
+                        DomainFactory.INSTANCE.getOrCreateMark("mytestmark"));
+
+        DBObject dbObject = mongoFactory.storeRaceLogEntry(logIdentifier, expectedEvent);
+        DefineMarkEvent actualEvent = loadEvent(dbObject);
+
+        assertBaseFields(expectedEvent, actualEvent);
+        assertEquals(expectedEvent.getMark(), actualEvent.getMark());
+    }
+
     /**
      * Will always wait a couple of milliseconds to ensure that {@link RaceLogEvent#getCreatedAt()} has passed.
      */

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

@@ -39,6 +39,7 @@ public class RaceLogEventSerializerTest {
     private JsonSerializer<RaceLogEvent> startTrackingEventSerializer;
     private JsonSerializer<RaceLogEvent> revokeEventSerializer;
     private JsonSerializer<RaceLogEvent> registerCompetitorEventSerializer;
+    private JsonSerializer<RaceLogEvent> defineMarkEventSerializer;
 
     private RaceLogEventFactory factory;
     private RaceLogEventAuthor author = new RaceLogEventAuthorImpl("Test Author", 1);
@@ -65,6 +66,7 @@ public class RaceLogEventSerializerTest {
         startTrackingEventSerializer = mock(JsonSerializer.class);
         revokeEventSerializer = mock(JsonSerializer.class);
         registerCompetitorEventSerializer = mock(JsonSerializer.class);
+        defineMarkEventSerializer = mock(JsonSerializer.class);
 
         serializer = new RaceLogEventSerializer(flagEventSerializer, startTimeSerializer, raceStatusSerializer,
                 courseAreaChangedEventSerializer, passChangedSerializer, courseDesignChangedEventSerializer,
@@ -72,7 +74,7 @@ public class RaceLogEventSerializerTest {
                 pathfinderEventSerializer, gateLineOpeningTimeEventSerializer,
                 startProcedureTypeChangedEventSerializer, protestStartTimeEventSerializer, windFixEventSerializer,
                 deviceCompetitorMappingEventSerializer, deviceMarkMappingEventSerializer, denoteForTrackingEventSerializer,
-                startTrackingEventSerializer, revokeEventSerializer, registerCompetitorEventSerializer);
+                startTrackingEventSerializer, revokeEventSerializer, registerCompetitorEventSerializer, defineMarkEventSerializer);
 
         factory = RaceLogEventFactory.INSTANCE;
     }
@@ -229,5 +231,13 @@ public class RaceLogEventSerializerTest {
         serializer.serialize(event);
         verify(registerCompetitorEventSerializer).serialize(event);
     }
+    
+    @Test
+    public void testDefineMarkEventSerializer() {
+        // we use the real event type here because we do not want to re-implement the dispatching.
+        RaceLogEvent event = factory.createDefineMarkEvent(null, author, 0, null);
+        serializer.serialize(event);
+        verify(defineMarkEventSerializer).serialize(event);
+    }
 
 }

java/com.sap.sailing.server.gateway.serialization/src/com/sap/sailing/server/gateway/deserialization/racelog/impl/RaceLogDefineMarkEventDeserializer.java

@@ -0,0 +1,33 @@
+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.base.Competitor;
+import com.sap.sailing.domain.base.Mark;
+import com.sap.sailing.domain.common.TimePoint;
+import com.sap.sailing.domain.racelog.RaceLogEvent;
+import com.sap.sailing.domain.racelog.RaceLogEventAuthor;
+import com.sap.sailing.server.gateway.deserialization.JsonDeserializationException;
+import com.sap.sailing.server.gateway.deserialization.JsonDeserializer;
+import com.sap.sailing.server.gateway.deserialization.impl.Helpers;
+import com.sap.sailing.server.gateway.serialization.racelog.impl.RaceLogDefineMarkEventSerializer;
+
+public class RaceLogDefineMarkEventDeserializer extends BaseRaceLogEventDeserializer {	
+    private final JsonDeserializer<Mark> markDeserializer;
+    public RaceLogDefineMarkEventDeserializer(JsonDeserializer<Competitor> competitorDeserializer,
+            JsonDeserializer<Mark> markDeserializer) {
+        super(competitorDeserializer);
+        this.markDeserializer = markDeserializer;
+    }
+
+    @Override
+    protected RaceLogEvent deserialize(JSONObject object, Serializable id, TimePoint createdAt, RaceLogEventAuthor author, TimePoint timePoint, int passId, List<Competitor> competitors)
+            throws JsonDeserializationException {
+    	Mark mark = markDeserializer.deserialize(Helpers.getNestedObjectSafe(object, RaceLogDefineMarkEventSerializer.FIELD_MARK));
+        
+        return factory.createDefineMarkEvent(createdAt, author, timePoint, id, passId, mark);
+    }
+}

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

@@ -21,6 +21,7 @@ import com.sap.sailing.server.gateway.deserialization.impl.WindJsonDeserializer;
 import com.sap.sailing.server.gateway.serialization.racelog.impl.BaseRaceLogEventSerializer;
 import com.sap.sailing.server.gateway.serialization.racelog.impl.RaceLogCourseAreaChangedEventSerializer;
 import com.sap.sailing.server.gateway.serialization.racelog.impl.RaceLogCourseDesignChangedEventSerializer;
+import com.sap.sailing.server.gateway.serialization.racelog.impl.RaceLogDefineMarkEventSerializer;
 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;
@@ -77,7 +78,8 @@ public class RaceLogEventDeserializer implements JsonDeserializer<RaceLogEvent>
                 new RaceLogDenoteForTrackingEventDeserializer(competitorDeserializer),
                 new RaceLogStartTrackingEventDeserializer(competitorDeserializer),
                 new RaceLogRevokeEventDeserializer(competitorDeserializer),
-                new RaceLogRegisterCompetitorEventDeserializer(competitorDeserializer));
+                new RaceLogRegisterCompetitorEventDeserializer(competitorDeserializer),
+                new RaceLogDefineMarkEventDeserializer(competitorDeserializer, new MarkDeserializer(domainFactory)));
     }
 
     protected final JsonDeserializer<RaceLogEvent> flagEventDeserializer;
@@ -99,6 +101,7 @@ public class RaceLogEventDeserializer implements JsonDeserializer<RaceLogEvent>
     protected final JsonDeserializer<RaceLogEvent> startTrackingEventDeserializer;
     protected final JsonDeserializer<RaceLogEvent> revokeEventDeserializer;
     protected final JsonDeserializer<RaceLogEvent> registerCompetitorEventDeserializer;
+    protected final JsonDeserializer<RaceLogEvent> defineMarkEventDeserializer;
 
     public RaceLogEventDeserializer(JsonDeserializer<RaceLogEvent> flagEventDeserializer,
             JsonDeserializer<RaceLogEvent> startTimeEventDeserializer,
@@ -118,7 +121,8 @@ public class RaceLogEventDeserializer implements JsonDeserializer<RaceLogEvent>
             JsonDeserializer<RaceLogEvent> denoteForTrackingEventDeserializer,
             JsonDeserializer<RaceLogEvent> startTrackingEventDeserializer,
             JsonDeserializer<RaceLogEvent> revokeEventDeserializer,
-            JsonDeserializer<RaceLogEvent> registerCompetitorEventDeserializer) {
+            JsonDeserializer<RaceLogEvent> registerCompetitorEventDeserializer,
+            JsonDeserializer<RaceLogEvent> defineMarkEventDeserializer) {
         this.flagEventDeserializer = flagEventDeserializer;
         this.startTimeEventDeserializer = startTimeEventDeserializer;
         this.raceStatusEventDeserializer = raceStatusEventDeserializer;
@@ -138,6 +142,7 @@ public class RaceLogEventDeserializer implements JsonDeserializer<RaceLogEvent>
         this.startTrackingEventDeserializer = startTrackingEventDeserializer;
         this.revokeEventDeserializer = revokeEventDeserializer;
         this.registerCompetitorEventDeserializer = registerCompetitorEventDeserializer;
+        this.defineMarkEventDeserializer = defineMarkEventDeserializer;
     }
 
     protected JsonDeserializer<RaceLogEvent> getDeserializer(JSONObject object) throws JsonDeserializationException {
@@ -181,6 +186,8 @@ public class RaceLogEventDeserializer implements JsonDeserializer<RaceLogEvent>
             return revokeEventDeserializer;
         } else if (type.equals(RaceLogRegisterCompetitorEventSerializer.VALUE_CLASS)) {
             return registerCompetitorEventDeserializer;
+        } else if (type.equals(RaceLogDefineMarkEventSerializer.VALUE_CLASS)) {
+            return defineMarkEventDeserializer;
         }
 
         throw new JsonDeserializationException(String.format("There is no deserializer defined for event type %s.",

java/com.sap.sailing.server.gateway.serialization/src/com/sap/sailing/server/gateway/serialization/racelog/impl/RaceLogDefineMarkEventSerializer.java

@@ -0,0 +1,38 @@
+package com.sap.sailing.server.gateway.serialization.racelog.impl;
+
+import org.json.simple.JSONObject;
+
+import com.sap.sailing.domain.base.Competitor;
+import com.sap.sailing.domain.base.ControlPoint;
+import com.sap.sailing.domain.racelog.RaceLogEvent;
+import com.sap.sailing.domain.racelog.tracking.DefineMarkEvent;
+import com.sap.sailing.server.gateway.serialization.JsonSerializer;
+
+public class RaceLogDefineMarkEventSerializer extends BaseRaceLogEventSerializer {
+    public static final String VALUE_CLASS = DefineMarkEvent.class.getSimpleName();
+    public static final String FIELD_MARK = "mark";
+    
+    private final JsonSerializer<ControlPoint> markSerializer;
+
+    public RaceLogDefineMarkEventSerializer(
+            JsonSerializer<Competitor> competitorSerializer, JsonSerializer<ControlPoint> markSerializer) {
+        super(competitorSerializer);
+        this.markSerializer = markSerializer;
+    }
+
+    @Override
+    protected String getClassFieldValue() {
+        return VALUE_CLASS;
+    }
+
+    @Override
+    public JSONObject serialize(RaceLogEvent object) {
+        DefineMarkEvent event = (DefineMarkEvent) object;
+
+        JSONObject result = super.serialize(event);
+        result.put(FIELD_MARK, markSerializer.serialize(event.getMark()));
+        
+        return result;
+    }
+
+}

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

@@ -21,6 +21,7 @@ import com.sap.sailing.domain.racelog.RaceLogStartProcedureChangedEvent;
 import com.sap.sailing.domain.racelog.RaceLogStartTimeEvent;
 import com.sap.sailing.domain.racelog.RaceLogWindFixEvent;
 import com.sap.sailing.domain.racelog.RevokeEvent;
+import com.sap.sailing.domain.racelog.tracking.DefineMarkEvent;
 import com.sap.sailing.domain.racelog.tracking.RegisterCompetitorEvent;
 import com.sap.sailing.domain.racelog.tracking.StartTrackingEvent;
 import com.sap.sailing.domain.racelog.tracking.DenoteForTrackingEvent;
@@ -72,7 +73,8 @@ public class RaceLogEventSerializer implements JsonSerializer<RaceLogEvent>, Rac
                 new RaceLogDenoteForTrackingEventSerializer(competitorSerializer),
                 new RaceLogStartTrackingEventSerializer(competitorSerializer),
                 new RaceLogRevokeEventSerializer(competitorSerializer),
-                new RaceLogRegisterCompetitorEventSerializer(competitorSerializer));
+                new RaceLogRegisterCompetitorEventSerializer(competitorSerializer),
+                new RaceLogDefineMarkEventSerializer(competitorSerializer, new MarkJsonSerializer()));
     }
 
     private final JsonSerializer<RaceLogEvent> flagEventSerializer;
@@ -94,6 +96,7 @@ public class RaceLogEventSerializer implements JsonSerializer<RaceLogEvent>, Rac
     private final JsonSerializer<RaceLogEvent> startTrackingSerializer;
     private final JsonSerializer<RaceLogEvent> revokeSerializer;
     private final JsonSerializer<RaceLogEvent> registerCompetitorSerializer;
+    private final JsonSerializer<RaceLogEvent> defineMarkSerializer;
     
     private JsonSerializer<RaceLogEvent> chosenSerializer;
 
@@ -116,7 +119,8 @@ public class RaceLogEventSerializer implements JsonSerializer<RaceLogEvent>, Rac
             JsonSerializer<RaceLogEvent> denoteForTrackingSerializer,
             JsonSerializer<RaceLogEvent> createRaceSerializer,
             JsonSerializer<RaceLogEvent> revokeSerializer,
-            JsonSerializer<RaceLogEvent> registerCompetitorSerializer) {
+            JsonSerializer<RaceLogEvent> registerCompetitorSerializer,
+            JsonSerializer<RaceLogEvent> defineMarkSerializer) {
         this.flagEventSerializer = flagEventSerializer;
         this.startTimeSerializer = startTimeSerializer;
         this.raceStatusSerializer = raceStatusSerializer;
@@ -136,6 +140,7 @@ public class RaceLogEventSerializer implements JsonSerializer<RaceLogEvent>, Rac
         this.startTrackingSerializer = createRaceSerializer;
         this.revokeSerializer = revokeSerializer;
         this.registerCompetitorSerializer = registerCompetitorSerializer;
+        this.defineMarkSerializer = defineMarkSerializer;
         
         this.chosenSerializer = null;
     }
@@ -220,32 +225,36 @@ public class RaceLogEventSerializer implements JsonSerializer<RaceLogEvent>, Rac
     public void visit(RaceLogWindFixEvent event) {
         chosenSerializer = windFixEventSerializer;
     }
-    
-	@Override
-	public void visit(DeviceCompetitorMappingEvent event) {
-		chosenSerializer = deviceCompetitorMappingSerializer;
-	}
-	
-	@Override
-	public void visit(DeviceMarkMappingEvent event) {
-		chosenSerializer = deviceMarkMappingSerializer;
-	}
-	
-	@Override
-	public void visit(DenoteForTrackingEvent event) {
-		chosenSerializer = denoteForTrackingSerializer;
-	}
-	@Override
-	public void visit(StartTrackingEvent event) {
-		chosenSerializer = startTrackingSerializer;
-	}
-	@Override
-	public void visit(RevokeEvent event) {
-		chosenSerializer = revokeSerializer;
-	}
-	@Override
-	public void visit(RegisterCompetitorEvent event) {
-		chosenSerializer = registerCompetitorSerializer;
-	}
 
+    @Override
+    public void visit(DeviceCompetitorMappingEvent event) {
+        chosenSerializer = deviceCompetitorMappingSerializer;
+    }
+
+    @Override
+    public void visit(DeviceMarkMappingEvent event) {
+        chosenSerializer = deviceMarkMappingSerializer;
+    }
+
+    @Override
+    public void visit(DenoteForTrackingEvent event) {
+        chosenSerializer = denoteForTrackingSerializer;
+    }
+    @Override
+    public void visit(StartTrackingEvent event) {
+        chosenSerializer = startTrackingSerializer;
+    }
+    @Override
+    public void visit(RevokeEvent event) {
+        chosenSerializer = revokeSerializer;
+    }
+    @Override
+    public void visit(RegisterCompetitorEvent event) {
+        chosenSerializer = registerCompetitorSerializer;
+    }
+
+    @Override
+    public void visit(DefineMarkEvent event) {
+        chosenSerializer = defineMarkSerializer;
+    }
 }