pull shared events and analyzers onto AbstractLog level

2026-11-07 11:32:16 +00:00 · 2014-11-27 01:26:53 +01:00
1 parent a4d941fa55
commit 9bf3d7c9c7
@@ -52,16 +52,14 @@ import com.sap.sailing.domain.abstractlog.race.RaceLogWindFixEvent;
 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.scoring.AdditionalScoringInformationType;
-import com.sap.sailing.domain.abstractlog.race.scoring.impl.AdditionalScoringInformationEventImpl;
-import com.sap.sailing.domain.abstractlog.race.tracking.CloseOpenEndedDeviceMappingEvent;
-import com.sap.sailing.domain.abstractlog.race.tracking.DefineMarkEvent;
-import com.sap.sailing.domain.abstractlog.race.tracking.DenoteForTrackingEvent;
-import com.sap.sailing.domain.abstractlog.race.tracking.DeviceCompetitorMappingEvent;
-import com.sap.sailing.domain.abstractlog.race.tracking.DeviceIdentifier;
-import com.sap.sailing.domain.abstractlog.race.tracking.DeviceMarkMappingEvent;
-import com.sap.sailing.domain.abstractlog.race.tracking.RegisterCompetitorEvent;
-import com.sap.sailing.domain.abstractlog.race.tracking.StartTrackingEvent;
-import com.sap.sailing.domain.abstractlog.race.tracking.impl.PlaceHolderDeviceIdentifierSerializationHandler;
+import com.sap.sailing.domain.abstractlog.race.scoring.impl.RaceLogAdditionalScoringInformationEventImpl;
+import com.sap.sailing.domain.abstractlog.race.tracking.RaceLogDefineMarkEvent;
+import com.sap.sailing.domain.abstractlog.race.tracking.RaceLogDenoteForTrackingEvent;
+import com.sap.sailing.domain.abstractlog.race.tracking.RaceLogStartTrackingEvent;
+import com.sap.sailing.domain.abstractlog.shared.events.CloseOpenEndedDeviceMappingEvent;
+import com.sap.sailing.domain.abstractlog.shared.events.DeviceCompetitorMappingEvent;
+import com.sap.sailing.domain.abstractlog.shared.events.DeviceMarkMappingEvent;
+import com.sap.sailing.domain.abstractlog.shared.events.RegisterCompetitorEvent;
 import com.sap.sailing.domain.base.BoatClass;
 import com.sap.sailing.domain.base.Competitor;
 import com.sap.sailing.domain.base.ControlPoint;
@@ -145,6 +143,8 @@ import com.sap.sailing.domain.persistence.racelog.tracking.DeviceIdentifierMongo
 import com.sap.sailing.domain.persistence.racelog.tracking.impl.PlaceHolderDeviceIdentifierMongoHandler;
 import com.sap.sailing.domain.racelog.RaceLogIdentifier;
 import com.sap.sailing.domain.racelog.RaceLogStore;
+import com.sap.sailing.domain.racelogtracking.DeviceIdentifier;
+import com.sap.sailing.domain.racelogtracking.impl.PlaceHolderDeviceIdentifierSerializationHandler;
 import com.sap.sailing.domain.tracking.TrackedRegattaRegistry;
 import com.sap.sailing.domain.tracking.Wind;
 import com.sap.sailing.domain.tracking.WindTrack;
@@ -1332,19 +1332,19 @@ public class DomainObjectFactoryImpl implements DomainObjectFactory {
            return loadRaceLogDeviceCompetitorMappingEvent(createdAt, author, logicalTimePoint, id, passId, competitors, dbObject);
        } else if (eventClass.equals(DeviceMarkMappingEvent.class.getSimpleName())) {
            return loadRaceLogDeviceMarkMappingEvent(createdAt, author, logicalTimePoint, id, passId, competitors, dbObject);
-        } else if (eventClass.equals(DenoteForTrackingEvent.class.getSimpleName())) {
+        } else if (eventClass.equals(RaceLogDenoteForTrackingEvent.class.getSimpleName())) {
            return loadRaceLogDenoteForTrackingEvent(createdAt, author, logicalTimePoint, id, passId, competitors, dbObject);
-        } else if (eventClass.equals(StartTrackingEvent.class.getSimpleName())) {
+        } else if (eventClass.equals(RaceLogStartTrackingEvent.class.getSimpleName())) {
            return loadRaceLogStartEvent(createdAt, author, logicalTimePoint, id, passId, competitors, dbObject);
        } else if (eventClass.equals(RevokeEvent.class.getSimpleName())) {
            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())) {
+        } else if (eventClass.equals(RaceLogDefineMarkEvent.class.getSimpleName())) {
            return loadRaceLogDefineMarkEvent(createdAt, author, logicalTimePoint, id, passId, competitors, dbObject);
        } else if (eventClass.equals(CloseOpenEndedDeviceMappingEvent.class.getSimpleName())) {
            return loadRaceLogCloseOpenEndedDeviceMappingEvent(createdAt, author, logicalTimePoint, id, passId, competitors, dbObject);
-        } else if (eventClass.equals(AdditionalScoringInformationEventImpl.class.getSimpleName())) {
+        } else if (eventClass.equals(RaceLogAdditionalScoringInformationEventImpl.class.getSimpleName())) {
            return loadRaceLogAdditionalScoringInformationEvent(createdAt, author, logicalTimePoint, id, passId, competitors, dbObject);
        }

@@ -1417,8 +1417,9 @@ public class DomainObjectFactoryImpl implements DomainObjectFactory {

    private RaceLogEvent loadRaceLogRegisterCompetitorEvent(TimePoint createdAt, AbstractLogEventAuthor author, TimePoint logicalTimePoint,
            Serializable id, Integer passId, List<Competitor> competitors, DBObject dbObject) {
-    	assert competitors.size() == 1 : "Should have exactly one competitor for RegisterCompetitorEvent";
-        return raceLogEventFactory.createRegisterCompetitorEvent(createdAt, author, logicalTimePoint, id, passId, competitors.get(0));
+    	Serializable competitorId = (Serializable) dbObject.get(FieldNames.RACE_LOG_COMPETITOR_ID.name());
+    	Competitor comp = baseDomainFactory.getCompetitorStore().getExistingCompetitorById(competitorId);
+        return raceLogEventFactory.createRegisterCompetitorEvent(createdAt, author, logicalTimePoint, id, passId, comp);
    }

    private RaceLogEvent loadRaceLogDefineMarkEvent(TimePoint createdAt, AbstractLogEventAuthor author, TimePoint logicalTimePoint,
@@ -87,7 +87,7 @@ public enum FieldNames {
    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_REVOKED_EVENT_TYPE, RACE_LOG_REVOKED_EVENT_SHORT_INFO,
    RACE_LOG_REVOKED_REASON, RACE_LOG_FROM, RACE_LOG_TO, RACE_LOG_MARK, RACE_LOG_DEVICE_MAPPING_EVENT_ID,
-    RACE_LOG_CLOSING_TIMEPOINT, MARK,
+    RACE_LOG_CLOSING_TIMEPOINT, MARK, RACE_LOG_COMPETITOR_ID,
    /** @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,
@@ -35,16 +35,19 @@ import com.sap.sailing.domain.abstractlog.race.RaceLogRevokeEvent;
 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.scoring.AdditionalScoringInformationEvent;
-import com.sap.sailing.domain.abstractlog.race.tracking.CloseOpenEndedDeviceMappingEvent;
-import com.sap.sailing.domain.abstractlog.race.tracking.DefineMarkEvent;
-import com.sap.sailing.domain.abstractlog.race.tracking.DenoteForTrackingEvent;
-import com.sap.sailing.domain.abstractlog.race.tracking.DeviceCompetitorMappingEvent;
-import com.sap.sailing.domain.abstractlog.race.tracking.DeviceIdentifier;
-import com.sap.sailing.domain.abstractlog.race.tracking.DeviceMappingEvent;
-import com.sap.sailing.domain.abstractlog.race.tracking.DeviceMarkMappingEvent;
-import com.sap.sailing.domain.abstractlog.race.tracking.RegisterCompetitorEvent;
-import com.sap.sailing.domain.abstractlog.race.tracking.StartTrackingEvent;
+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;
+import com.sap.sailing.domain.abstractlog.race.tracking.RaceLogDenoteForTrackingEvent;
+import com.sap.sailing.domain.abstractlog.race.tracking.RaceLogDeviceCompetitorMappingEvent;
+import com.sap.sailing.domain.abstractlog.race.tracking.RaceLogDeviceMarkMappingEvent;
+import com.sap.sailing.domain.abstractlog.race.tracking.RaceLogRegisterCompetitorEvent;
+import com.sap.sailing.domain.abstractlog.race.tracking.RaceLogStartTrackingEvent;
+import com.sap.sailing.domain.abstractlog.shared.events.CloseOpenEndedDeviceMappingEvent;
+import com.sap.sailing.domain.abstractlog.shared.events.DeviceCompetitorMappingEvent;
+import com.sap.sailing.domain.abstractlog.shared.events.DeviceMappingEvent;
+import com.sap.sailing.domain.abstractlog.shared.events.DeviceMarkMappingEvent;
+import com.sap.sailing.domain.abstractlog.shared.events.RegisterCompetitorEvent;
 import com.sap.sailing.domain.base.Competitor;
 import com.sap.sailing.domain.base.ControlPoint;
 import com.sap.sailing.domain.base.ControlPointWithTwoMarks;
@@ -90,6 +93,7 @@ import com.sap.sailing.domain.persistence.MongoObjectFactory;
 import com.sap.sailing.domain.persistence.racelog.tracking.DeviceIdentifierMongoHandler;
 import com.sap.sailing.domain.persistence.racelog.tracking.impl.PlaceHolderDeviceIdentifierMongoHandler;
 import com.sap.sailing.domain.racelog.RaceLogIdentifier;
+import com.sap.sailing.domain.racelogtracking.DeviceIdentifier;
 import com.sap.sailing.domain.tracking.Positioned;
 import com.sap.sailing.domain.tracking.TrackedRace;
 import com.sap.sailing.domain.tracking.TrackedRegatta;
@@ -101,7 +105,6 @@ import com.sap.sailing.server.gateway.serialization.impl.DeviceConfigurationJson
 import com.sap.sailing.server.gateway.serialization.impl.RegattaConfigurationJsonSerializer;
 import com.sap.sse.common.TimePoint;
 import com.sap.sse.common.Util;
-import com.sap.sse.common.WithID;
 import com.sap.sse.common.impl.MillisecondsTimePoint;

 public class MongoObjectFactoryImpl implements MongoObjectFactory {
@@ -789,28 +792,28 @@ public class MongoObjectFactoryImpl implements MongoObjectFactory {
        return result;
    }
    
-    public DBObject storeRaceLogEntry(RaceLogIdentifier raceLogIdentifier, DeviceCompetitorMappingEvent event) {
+    public DBObject storeRaceLogEntry(RaceLogIdentifier raceLogIdentifier, RaceLogDeviceCompetitorMappingEvent event) {
        BasicDBObject result = new BasicDBObject();
        storeRaceLogIdentifier(raceLogIdentifier, result);
        result.put(FieldNames.RACE_LOG_EVENT.name(), storeRaceLogDeviceCompetitorMappingEvent(event));
        return result;
    }

-    public DBObject storeRaceLogEntry(RaceLogIdentifier raceLogIdentifier, DeviceMarkMappingEvent event) {
+    public DBObject storeRaceLogEntry(RaceLogIdentifier raceLogIdentifier, RaceLogDeviceMarkMappingEvent event) {
        BasicDBObject result = new BasicDBObject();
        storeRaceLogIdentifier(raceLogIdentifier, result);
        result.put(FieldNames.RACE_LOG_EVENT.name(), storeRaceLogDeviceMarkMappingEvent(event));
        return result;
    }

-    public DBObject storeRaceLogEntry(RaceLogIdentifier raceLogIdentifier, DenoteForTrackingEvent event) {
+    public DBObject storeRaceLogEntry(RaceLogIdentifier raceLogIdentifier, RaceLogDenoteForTrackingEvent event) {
        BasicDBObject result = new BasicDBObject();
        storeRaceLogIdentifier(raceLogIdentifier, result);
        result.put(FieldNames.RACE_LOG_EVENT.name(), storeRaceLogDenoteForTrackingEvent(event));
        return result;
    }

-    public DBObject storeRaceLogEntry(RaceLogIdentifier raceLogIdentifier, StartTrackingEvent event) {
+    public DBObject storeRaceLogEntry(RaceLogIdentifier raceLogIdentifier, RaceLogStartTrackingEvent event) {
        BasicDBObject result = new BasicDBObject();
        storeRaceLogIdentifier(raceLogIdentifier, result);
        result.put(FieldNames.RACE_LOG_EVENT.name(), storeRaceLogStartTrackingEvent(event));
@@ -824,35 +827,35 @@ public class MongoObjectFactoryImpl implements MongoObjectFactory {
        return result;
    }

-    public DBObject storeRaceLogEntry(RaceLogIdentifier raceLogIdentifier, RegisterCompetitorEvent event) {
+    public DBObject storeRaceLogEntry(RaceLogIdentifier raceLogIdentifier, RaceLogRegisterCompetitorEvent event) {
        BasicDBObject result = new BasicDBObject();
        storeRaceLogIdentifier(raceLogIdentifier, result);
        result.put(FieldNames.RACE_LOG_EVENT.name(), storeRaceLogRegisterCompetitorEvent(event));
        return result;
    }

-    public DBObject storeRaceLogEntry(RaceLogIdentifier raceLogIdentifier, DefineMarkEvent event) {
+    public DBObject storeRaceLogEntry(RaceLogIdentifier raceLogIdentifier, RaceLogDefineMarkEvent event) {
        BasicDBObject result = new BasicDBObject();
        storeRaceLogIdentifier(raceLogIdentifier, result);
        result.put(FieldNames.RACE_LOG_EVENT.name(), storeRaceLogDefineMarkEvent(event));
        return result;
    }

-    public DBObject storeRaceLogEntry(RaceLogIdentifier raceLogIdentifier, CloseOpenEndedDeviceMappingEvent event) {
+    public DBObject storeRaceLogEntry(RaceLogIdentifier raceLogIdentifier, RaceLogCloseOpenEndedDeviceMappingEvent event) {
        BasicDBObject result = new BasicDBObject();
        storeRaceLogIdentifier(raceLogIdentifier, result);
        result.put(FieldNames.RACE_LOG_EVENT.name(), storeRaceLogCloseOpenEndedDeviceMappingEvent(event));
        return result;
    }
    
-    public DBObject storeRaceLogEntry(RaceLogIdentifier raceLogIdentifier, AdditionalScoringInformationEvent event) {
+    public DBObject storeRaceLogEntry(RaceLogIdentifier raceLogIdentifier, RaceLogAdditionalScoringInformationEvent event) {
        BasicDBObject result = new BasicDBObject();
        storeRaceLogIdentifier(raceLogIdentifier, result);
        result.put(FieldNames.RACE_LOG_EVENT.name(), storeAdditionalScoringInformation(event));
        return result;
    }
    
-    private Object storeAdditionalScoringInformation(AdditionalScoringInformationEvent event) {
+    private Object storeAdditionalScoringInformation(RaceLogAdditionalScoringInformationEvent event) {
        DBObject result = new BasicDBObject();
        storeRaceLogEventProperties(event, result);
        result.put(FieldNames.RACE_LOG_EVENT_CLASS.name(), event.getClass().getSimpleName());
@@ -892,15 +895,12 @@ public class MongoObjectFactoryImpl implements MongoObjectFactory {
        return result;
    }

-    private void storeRaceLogDeviceMappingEvent(DeviceMappingEvent<? extends WithID> event, DBObject result) {
-        DBObject deviceId = null;
-        try {
-            deviceId = storeDeviceId(deviceIdentifierServiceFinder, event.getDevice());
-        } catch (Exception e) {
-            logger.log(Level.WARNING, "Could not store deviceId for RaceLogEvent", e);
-            e.printStackTrace();
+    private void storeDeviceMappingEvent(DeviceMappingEvent<?, ?> event, DBObject result) {
+        try {
+            result.put(FieldNames.DEVICE_ID.name(), storeDeviceId(deviceIdentifierServiceFinder, event.getDevice()));
+        } catch (TransformationException | NoCorrespondingServiceRegisteredException e) {
+            logger.log(Level.WARNING, "Could not store device identifier for mappng event", e);
        }
-        result.put(FieldNames.DEVICE_ID.name(), deviceId);
        if (event.getFrom() != null) {
            storeTimePoint(event.getFrom(), result, FieldNames.RACE_LOG_FROM);
        }
@@ -909,38 +909,38 @@ public class MongoObjectFactoryImpl implements MongoObjectFactory {
        }
    }

-    private Object storeRaceLogDeviceCompetitorMappingEvent(DeviceCompetitorMappingEvent event) {
+    private Object storeRaceLogDeviceCompetitorMappingEvent(RaceLogDeviceCompetitorMappingEvent event) {
        DBObject result = new BasicDBObject();
        storeRaceLogEventProperties(event, result);
        result.put(FieldNames.RACE_LOG_EVENT_CLASS.name(), DeviceCompetitorMappingEvent.class.getSimpleName());
-        storeRaceLogDeviceMappingEvent(event, result);
+        storeDeviceMappingEvent(event, result);
        result.put(FieldNames.COMPETITOR_ID.name(), event.getMappedTo().getId());
        return result;
    }

-    private Object storeRaceLogDeviceMarkMappingEvent(DeviceMarkMappingEvent event) {
+    private Object storeRaceLogDeviceMarkMappingEvent(RaceLogDeviceMarkMappingEvent event) {
        DBObject result = new BasicDBObject();
        storeRaceLogEventProperties(event, result);
        result.put(FieldNames.RACE_LOG_EVENT_CLASS.name(), DeviceMarkMappingEvent.class.getSimpleName());
-        storeRaceLogDeviceMappingEvent(event, result);
+        storeDeviceMappingEvent(event, result);
        result.put(FieldNames.MARK.name(), storeMark(event.getMappedTo()));
        return result;
    }

-    private Object storeRaceLogDenoteForTrackingEvent(DenoteForTrackingEvent event) {
+    private Object storeRaceLogDenoteForTrackingEvent(RaceLogDenoteForTrackingEvent event) {
        DBObject result = new BasicDBObject();
        storeRaceLogEventProperties(event, result);
-        result.put(FieldNames.RACE_LOG_EVENT_CLASS.name(), DenoteForTrackingEvent.class.getSimpleName());
+        result.put(FieldNames.RACE_LOG_EVENT_CLASS.name(), RaceLogDenoteForTrackingEvent.class.getSimpleName());
        result.put(FieldNames.RACE_NAME.name(), event.getRaceName());
        result.put(FieldNames.BOAT_CLASS_NAME.name(), event.getBoatClass().getName());
        result.put(FieldNames.RACE_ID.name(), event.getRaceId());
        return result;
    }

-    private Object storeRaceLogStartTrackingEvent(StartTrackingEvent event) {
+    private Object storeRaceLogStartTrackingEvent(RaceLogStartTrackingEvent event) {
        DBObject result = new BasicDBObject();
        storeRaceLogEventProperties(event, result);
-        result.put(FieldNames.RACE_LOG_EVENT_CLASS.name(), StartTrackingEvent.class.getSimpleName());
+        result.put(FieldNames.RACE_LOG_EVENT_CLASS.name(), RaceLogStartTrackingEvent.class.getSimpleName());
        return result;
    }

@@ -955,22 +955,23 @@ public class MongoObjectFactoryImpl implements MongoObjectFactory {
        return result;
    }

-    private Object storeRaceLogRegisterCompetitorEvent(RegisterCompetitorEvent event) {
+    private Object storeRaceLogRegisterCompetitorEvent(RaceLogRegisterCompetitorEvent event) {
        DBObject result = new BasicDBObject();
        storeRaceLogEventProperties(event, result);
-        result.put(FieldNames.RACE_LOG_EVENT_CLASS.name(), RegisterCompetitorEvent.class.getSimpleName());
+        result.put(FieldNames.RACE_LOG_EVENT_CLASS.name(), RegisterCompetitorEvent.class.getSimpleName());
+        result.put(FieldNames.RACE_LOG_COMPETITOR_ID.name(), event.getCompetitor().getId());
        return result;
    }

-    private Object storeRaceLogDefineMarkEvent(DefineMarkEvent event) {
+    private Object storeRaceLogDefineMarkEvent(RaceLogDefineMarkEvent event) {
        DBObject result = new BasicDBObject();
        storeRaceLogEventProperties(event, result);
-        result.put(FieldNames.RACE_LOG_EVENT_CLASS.name(), DefineMarkEvent.class.getSimpleName());
+        result.put(FieldNames.RACE_LOG_EVENT_CLASS.name(), RaceLogDefineMarkEvent.class.getSimpleName());
        result.put(FieldNames.RACE_LOG_MARK.name(), storeMark(event.getMark()));
        return result;
    }

-    private Object storeRaceLogCloseOpenEndedDeviceMappingEvent(CloseOpenEndedDeviceMappingEvent event) {
+    private Object storeRaceLogCloseOpenEndedDeviceMappingEvent(RaceLogCloseOpenEndedDeviceMappingEvent event) {
        DBObject result = new BasicDBObject();
        storeRaceLogEventProperties(event, result);
        result.put(FieldNames.RACE_LOG_EVENT_CLASS.name(), CloseOpenEndedDeviceMappingEvent.class.getSimpleName());
@@ -18,14 +18,14 @@ import com.sap.sailing.domain.abstractlog.race.RaceLogRevokeEvent;
 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.scoring.AdditionalScoringInformationEvent;
-import com.sap.sailing.domain.abstractlog.race.tracking.CloseOpenEndedDeviceMappingEvent;
-import com.sap.sailing.domain.abstractlog.race.tracking.DefineMarkEvent;
-import com.sap.sailing.domain.abstractlog.race.tracking.DenoteForTrackingEvent;
-import com.sap.sailing.domain.abstractlog.race.tracking.DeviceCompetitorMappingEvent;
-import com.sap.sailing.domain.abstractlog.race.tracking.DeviceMarkMappingEvent;
-import com.sap.sailing.domain.abstractlog.race.tracking.RegisterCompetitorEvent;
-import com.sap.sailing.domain.abstractlog.race.tracking.StartTrackingEvent;
+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;
+import com.sap.sailing.domain.abstractlog.race.tracking.RaceLogDenoteForTrackingEvent;
+import com.sap.sailing.domain.abstractlog.race.tracking.RaceLogDeviceCompetitorMappingEvent;
+import com.sap.sailing.domain.abstractlog.race.tracking.RaceLogDeviceMarkMappingEvent;
+import com.sap.sailing.domain.abstractlog.race.tracking.RaceLogRegisterCompetitorEvent;
+import com.sap.sailing.domain.abstractlog.race.tracking.RaceLogStartTrackingEvent;
 import com.sap.sailing.domain.persistence.MongoObjectFactory;
 import com.sap.sailing.domain.racelog.RaceLogIdentifier;

@@ -121,25 +121,25 @@ public class MongoRaceLogStoreVisitor implements RaceLogEventVisitor {
    }

    @Override
-    public void visit(DeviceCompetitorMappingEvent event) {
+    public void visit(RaceLogDeviceCompetitorMappingEvent event) {
        DBObject object = mongoObjectFactory.storeRaceLogEntry(raceLogIdentifier, event);
        mongoObjectFactory.storeRaceLogEventEvent(object);
    }

    @Override
-    public void visit(DeviceMarkMappingEvent event) {
+    public void visit(RaceLogDeviceMarkMappingEvent event) {
        DBObject object = mongoObjectFactory.storeRaceLogEntry(raceLogIdentifier, event);
        mongoObjectFactory.storeRaceLogEventEvent(object);
    }

    @Override
-    public void visit(DenoteForTrackingEvent event) {
+    public void visit(RaceLogDenoteForTrackingEvent event) {
        DBObject object = mongoObjectFactory.storeRaceLogEntry(raceLogIdentifier, event);
        mongoObjectFactory.storeRaceLogEventEvent(object);
    }

    @Override
-    public void visit(StartTrackingEvent event) {
+    public void visit(RaceLogStartTrackingEvent event) {
        DBObject object = mongoObjectFactory.storeRaceLogEntry(raceLogIdentifier, event);
        mongoObjectFactory.storeRaceLogEventEvent(object);
    }
@@ -151,25 +151,25 @@ public class MongoRaceLogStoreVisitor implements RaceLogEventVisitor {
    }

    @Override
-    public void visit(RegisterCompetitorEvent event) {
+    public void visit(RaceLogRegisterCompetitorEvent event) {
        DBObject object = mongoObjectFactory.storeRaceLogEntry(raceLogIdentifier, event);
        mongoObjectFactory.storeRaceLogEventEvent(object);
    }

    @Override
-    public void visit(DefineMarkEvent event) {
+    public void visit(RaceLogDefineMarkEvent event) {
        DBObject object = mongoObjectFactory.storeRaceLogEntry(raceLogIdentifier, event);
        mongoObjectFactory.storeRaceLogEventEvent(object);
    }
    
    @Override
-    public void visit(CloseOpenEndedDeviceMappingEvent event) {
+    public void visit(RaceLogCloseOpenEndedDeviceMappingEvent event) {
        DBObject object = mongoObjectFactory.storeRaceLogEntry(raceLogIdentifier, event);
        mongoObjectFactory.storeRaceLogEventEvent(object);
    }

    @Override
-    public void visit(AdditionalScoringInformationEvent event) {
+    public void visit(RaceLogAdditionalScoringInformationEvent event) {
        DBObject object = mongoObjectFactory.storeRaceLogEntry(raceLogIdentifier, event);
        mongoObjectFactory.storeRaceLogEventEvent(object);
    }
@@ -1,6 +1,6 @@
 package com.sap.sailing.domain.persistence.racelog.tracking;

-import com.sap.sailing.domain.abstractlog.race.tracking.DeviceIdentifierSerializationHandler;
+import com.sap.sailing.domain.racelogtracking.DeviceIdentifierSerializationHandler;

 public interface DeviceIdentifierMongoHandler extends DeviceIdentifierSerializationHandler<Object> {
 }
@@ -15,10 +15,8 @@ import com.mongodb.DBCursor;
 import com.mongodb.DBObject;
 import com.mongodb.QueryBuilder;
 import com.sap.sailing.domain.abstractlog.race.RaceLog;
-import com.sap.sailing.domain.abstractlog.race.tracking.DeviceIdentifier;
-import com.sap.sailing.domain.abstractlog.race.tracking.DeviceMapping;
-import com.sap.sailing.domain.abstractlog.race.tracking.analyzing.impl.DeviceCompetitorMappingFinder;
-import com.sap.sailing.domain.abstractlog.race.tracking.analyzing.impl.DeviceMarkMappingFinder;
+import com.sap.sailing.domain.abstractlog.race.tracking.analyzing.impl.RaceLogDeviceCompetitorMappingFinder;
+import com.sap.sailing.domain.abstractlog.race.tracking.analyzing.impl.RaceLogDeviceMarkMappingFinder;
 import com.sap.sailing.domain.base.Competitor;
 import com.sap.sailing.domain.base.Mark;
 import com.sap.sailing.domain.common.TimeRange;
@@ -36,6 +34,8 @@ import com.sap.sailing.domain.persistence.racelog.tracking.DeviceIdentifierMongo
 import com.sap.sailing.domain.persistence.racelog.tracking.GPSFixMongoHandler;
 import com.sap.sailing.domain.persistence.racelog.tracking.MongoGPSFixStore;
 import com.sap.sailing.domain.racelog.tracking.GPSFixReceivedListener;
+import com.sap.sailing.domain.racelogtracking.DeviceIdentifier;
+import com.sap.sailing.domain.racelogtracking.DeviceMapping;
 import com.sap.sailing.domain.tracking.DynamicGPSFixTrack;
 import com.sap.sailing.domain.tracking.GPSFix;
 import com.sap.sailing.domain.tracking.GPSFixMoving;
@@ -107,7 +107,7 @@ public class MongoGPSFixStoreImpl implements MongoGPSFixStore {
    @Override
    public void loadCompetitorTrack(DynamicGPSFixTrack<Competitor, GPSFixMoving> track, RaceLog raceLog, Competitor competitor)
    throws NoCorrespondingServiceRegisteredException, TransformationException{
-        List<DeviceMapping<Competitor>> mappings = new DeviceCompetitorMappingFinder(raceLog).analyze().get(competitor);
+        List<DeviceMapping<Competitor>> mappings = new RaceLogDeviceCompetitorMappingFinder(raceLog).analyze().get(competitor);

        if (mappings != null) {
            for (DeviceMapping<Competitor> mapping : mappings) {
@@ -119,7 +119,7 @@ public class MongoGPSFixStoreImpl implements MongoGPSFixStore {
    @Override
    public void loadMarkTrack(DynamicGPSFixTrack<Mark, GPSFix> track, RaceLog raceLog, Mark mark)
    throws NoCorrespondingServiceRegisteredException, TransformationException{
-        List<DeviceMapping<Mark>> mappings = new DeviceMarkMappingFinder(raceLog).analyze().get(mark);
+        List<DeviceMapping<Mark>> mappings = new RaceLogDeviceMarkMappingFinder(raceLog).analyze().get(mark);

        if (mappings != null) {
            for (DeviceMapping<Mark> mapping : mappings) {
@@ -1,9 +1,9 @@
 package com.sap.sailing.domain.persistence.racelog.tracking.impl;

-import com.sap.sailing.domain.abstractlog.race.tracking.DeviceIdentifier;
-import com.sap.sailing.domain.abstractlog.race.tracking.impl.PlaceHolderDeviceIdentifierSerializationHandler;
 import com.sap.sailing.domain.common.racelog.tracking.TransformationException;
 import com.sap.sailing.domain.persistence.racelog.tracking.DeviceIdentifierMongoHandler;
+import com.sap.sailing.domain.racelogtracking.DeviceIdentifier;
+import com.sap.sailing.domain.racelogtracking.impl.PlaceHolderDeviceIdentifierSerializationHandler;

 public class PlaceHolderDeviceIdentifierMongoHandler extends PlaceHolderDeviceIdentifierSerializationHandler
 implements DeviceIdentifierMongoHandler {
@@ -11,7 +11,6 @@ import com.sap.sailing.domain.abstractlog.impl.LogEventAuthorImpl;
 import com.sap.sailing.domain.abstractlog.race.RaceLog;
 import com.sap.sailing.domain.abstractlog.race.RaceLogEventFactory;
 import com.sap.sailing.domain.abstractlog.race.impl.RaceLogImpl;
-import com.sap.sailing.domain.abstractlog.race.tracking.DeviceIdentifier;
 import com.sap.sailing.domain.base.Competitor;
 import com.sap.sailing.domain.base.DomainFactory;
 import com.sap.sailing.domain.base.Mark;
@@ -24,6 +23,7 @@ import com.sap.sailing.domain.racelog.tracking.GPSFixStore;
 import com.sap.sailing.domain.racelog.tracking.test.mock.MockDeviceAndSessionIdentifierWithGPSFixesDeserializer;
 import com.sap.sailing.domain.racelog.tracking.test.mock.MockSmartphoneImeiServiceFinderFactory;
 import com.sap.sailing.domain.racelog.tracking.test.mock.SmartphoneImeiIdentifier;
+import com.sap.sailing.domain.racelogtracking.DeviceIdentifier;
 import com.sap.sailing.domain.tracking.GPSFixMoving;
 import com.sap.sailing.domain.tracking.Track;
 import com.sap.sailing.domain.tracking.impl.GPSFixMovingImpl;
@@ -20,7 +20,6 @@ import org.junit.rules.ExpectedException;
 import com.sap.sailing.domain.abstractlog.AbstractLogEventAuthor;
 import com.sap.sailing.domain.abstractlog.race.RaceLog;
 import com.sap.sailing.domain.abstractlog.race.RaceLogEventFactory;
-import com.sap.sailing.domain.abstractlog.race.tracking.DeviceIdentifier;
 import com.sap.sailing.domain.base.Competitor;
 import com.sap.sailing.domain.base.DomainFactory;
 import com.sap.sailing.domain.base.Fleet;
@@ -39,6 +38,7 @@ import com.sap.sailing.domain.leaderboard.impl.HighPoint;
 import com.sap.sailing.domain.racelog.tracking.GPSFixStore;
 import com.sap.sailing.domain.racelog.tracking.test.mock.MockSmartphoneImeiServiceFinderFactory;
 import com.sap.sailing.domain.racelog.tracking.test.mock.SmartphoneImeiIdentifier;
+import com.sap.sailing.domain.racelogtracking.DeviceIdentifier;
 import com.sap.sailing.domain.racelogtracking.RaceLogTrackingAdapter;
 import com.sap.sailing.domain.racelogtracking.impl.RaceLogTrackingAdapterFactoryImpl;
 import com.sap.sailing.domain.tracking.Track;
@@ -9,7 +9,6 @@ import org.junit.Test;

 import com.sap.sailing.domain.abstractlog.race.RaceLog;
 import com.sap.sailing.domain.abstractlog.race.impl.RaceLogImpl;
-import com.sap.sailing.domain.abstractlog.race.tracking.DeviceIdentifier;
 import com.sap.sailing.domain.base.BoatClass;
 import com.sap.sailing.domain.base.Competitor;
 import com.sap.sailing.domain.base.Course;
@@ -27,6 +26,7 @@ import com.sap.sailing.domain.common.racelog.tracking.NoCorrespondingServiceRegi
 import com.sap.sailing.domain.common.racelog.tracking.TransformationException;
 import com.sap.sailing.domain.racelog.impl.EmptyRaceLogStore;
 import com.sap.sailing.domain.racelog.tracking.test.mock.SmartphoneImeiIdentifier;
+import com.sap.sailing.domain.racelogtracking.DeviceIdentifier;
 import com.sap.sailing.domain.racelogtracking.test.AbstractGPSFixStoreTest;
 import com.sap.sailing.domain.tracking.GPSFixMoving;
 import com.sap.sailing.domain.tracking.TrackedRegatta;
@@ -1,6 +1,6 @@
 package com.sap.sailing.domain.racelog.tracking.test.mock;

-import com.sap.sailing.domain.abstractlog.race.tracking.DeviceIdentifier;
+import com.sap.sailing.domain.racelogtracking.DeviceIdentifier;


 public class SmartphoneImeiIdentifier implements DeviceIdentifier {
@@ -1,7 +1,7 @@
 package com.sap.sailing.domain.racelog.tracking.test.mock;

-import com.sap.sailing.domain.abstractlog.race.tracking.DeviceIdentifier;
 import com.sap.sailing.domain.common.racelog.tracking.TransformationException;
+import com.sap.sailing.domain.racelogtracking.DeviceIdentifier;
 import com.sap.sailing.server.gateway.serialization.racelog.tracking.DeviceIdentifierJsonHandler;

 public class SmartphoneImeiJsonHandler extends SmartphoneImeiSerializationHandler
@@ -1,8 +1,8 @@
 package com.sap.sailing.domain.racelog.tracking.test.mock;

-import com.sap.sailing.domain.abstractlog.race.tracking.DeviceIdentifier;
 import com.sap.sailing.domain.common.racelog.tracking.TransformationException;
 import com.sap.sailing.domain.persistence.racelog.tracking.DeviceIdentifierMongoHandler;
+import com.sap.sailing.domain.racelogtracking.DeviceIdentifier;

 public class SmartphoneImeiMongoHandler extends SmartphoneImeiSerializationHandler
 implements DeviceIdentifierMongoHandler {
@@ -1,7 +1,7 @@
 package com.sap.sailing.domain.racelog.tracking.test.mock;

-import com.sap.sailing.domain.abstractlog.race.tracking.DeviceIdentifier;
 import com.sap.sailing.domain.common.racelog.tracking.TransformationException;
+import com.sap.sailing.domain.racelogtracking.DeviceIdentifier;
 import com.sap.sse.common.Util;

 public class SmartphoneImeiSerializationHandler {
@@ -1,6 +1,6 @@
 package com.sap.sailing.domain.racelog.tracking.test.mock;

-import com.sap.sailing.domain.abstractlog.race.tracking.DeviceIdentifierStringSerializationHandler;
+import com.sap.sailing.domain.racelogtracking.DeviceIdentifierStringSerializationHandler;

 public class SmartphoneImeiStringSerializationHandler extends SmartphoneImeiSerializationHandler
 implements DeviceIdentifierStringSerializationHandler {
@@ -2,8 +2,6 @@ package com.sap.sailing.domain.racelogtracking;

 import java.util.UUID;

-import com.sap.sailing.domain.abstractlog.race.tracking.DeviceIdentifier;
-
 /**
 * A device identifier used to identify a non-existent, virtual device, which is used only once as an
 * identifier to add a single fix to a track (i.e. pinging the location of that track's item).
@@ -4,9 +4,9 @@ import java.util.Set;

 import com.sap.sailing.domain.abstractlog.race.RaceLog;
 import com.sap.sailing.domain.abstractlog.race.RaceLogCourseDesignChangedEvent;
-import com.sap.sailing.domain.abstractlog.race.tracking.DefineMarkEvent;
-import com.sap.sailing.domain.abstractlog.race.tracking.DenoteForTrackingEvent;
-import com.sap.sailing.domain.abstractlog.race.tracking.StartTrackingEvent;
+import com.sap.sailing.domain.abstractlog.race.tracking.RaceLogDefineMarkEvent;
+import com.sap.sailing.domain.abstractlog.race.tracking.RaceLogDenoteForTrackingEvent;
+import com.sap.sailing.domain.abstractlog.race.tracking.RaceLogStartTrackingEvent;
 import com.sap.sailing.domain.base.Competitor;
 import com.sap.sailing.domain.base.ControlPoint;
 import com.sap.sailing.domain.base.Fleet;
@@ -32,7 +32,7 @@ public interface RaceLogTrackingAdapter {
     * <ul>
     * <li>Is the racelog denoted for tracking? If not, throw exception.</li>
     * <li>Is a {@link RaceLogRaceTracker} already listening for this racelog? If not, add one.</li>
-     * <li>Is a {@link StartTrackingEvent} present in the racelog? If not, add one</li>
+     * <li>Is a {@link RaceLogStartTrackingEvent} present in the racelog? If not, add one</li>
     * </ul>
     */
    void startTracking(RacingEventService service, Leaderboard leaderboard, RaceColumn raceColumn, Fleet fleet)
@@ -46,7 +46,7 @@ public interface RaceLogTrackingAdapter {
    boolean isRaceLogRaceTrackerAttached(RacingEventService service, RaceLog raceLog);

    /**
-     * Denotes the {@link RaceLog} for racelog-tracking, by inserting a {@link DenoteForTrackingEvent}.
+     * Denotes the {@link RaceLog} for racelog-tracking, by inserting a {@link RaceLogDenoteForTrackingEvent}.
     * 
     * @throws NotDenotableForRaceLogTrackingException
     *             Fails, if no {@link RaceLog}, or a non-empty {@link RaceLog}, or one with attached
@@ -57,7 +57,7 @@ public interface RaceLogTrackingAdapter {
            Fleet fleet, String raceName) throws NotDenotableForRaceLogTrackingException;
    
    /**
-     * Revoke the {@link DenoteForTrackingEvent}, and if it exists the {@link StartTrackingEvent}.
+     * Revoke the {@link RaceLogDenoteForTrackingEvent}, and if it exists the {@link RaceLogStartTrackingEvent}.
     * This does not affect existing an {@link RaceLogRaceTracker}
     * or {@link TrackedRace} for this {@code RaceLog}.
     */
@@ -80,7 +80,7 @@ public interface RaceLogTrackingAdapter {
     * Duplicate the course and competitor registrations in the newest {@link RaceLogCourseDesignChangedEvent}
     * in {@code from} race log to the {@code to} race logs.
     * The {@link Mark}s and {@link ControlPoint}s are duplicated and not reused. This also inserts the necessary
-     * {@link DefineMarkEvent}s into the {@code to} race logs.
+     * {@link RaceLogDefineMarkEvent}s into the {@code to} race logs.
     */
    void copyCourseAndCompetitors(RaceLog from, Set<RaceLog> to, SharedDomainFactory baseDomainFactory,
            RacingEventService service);
@@ -11,12 +11,12 @@ import org.osgi.framework.BundleActivator;
 import org.osgi.framework.BundleContext;
 import org.osgi.framework.ServiceRegistration;

-import com.sap.sailing.domain.abstractlog.race.tracking.DeviceIdentifierStringSerializationHandler;
-import com.sap.sailing.domain.abstractlog.race.tracking.SmartphoneUUIDIdentifier;
 import com.sap.sailing.domain.common.racelog.tracking.TypeBasedServiceFinder;
 import com.sap.sailing.domain.persistence.racelog.tracking.DeviceIdentifierMongoHandler;
+import com.sap.sailing.domain.racelogtracking.DeviceIdentifierStringSerializationHandler;
 import com.sap.sailing.domain.racelogtracking.PingDeviceIdentifierImpl;
 import com.sap.sailing.domain.racelogtracking.RaceLogTrackingAdapterFactory;
+import com.sap.sailing.domain.racelogtracking.SmartphoneUUIDIdentifier;
 import com.sap.sailing.domain.trackfiles.TrackFileImportDeviceIdentifier;
 import com.sap.sailing.domain.tracking.GPSFix;
 import com.sap.sailing.server.gateway.deserialization.JsonDeserializer;
@@ -1,7 +1,7 @@
 package com.sap.sailing.domain.racelogtracking.impl;

-import com.sap.sailing.domain.abstractlog.race.tracking.DeviceIdentifier;
 import com.sap.sailing.domain.common.racelog.tracking.TransformationException;
+import com.sap.sailing.domain.racelogtracking.DeviceIdentifier;
 import com.sap.sailing.server.gateway.serialization.racelog.tracking.DeviceIdentifierJsonHandler;

 public class PingDeviceIdentifierJsonHandler extends PingDeviceIdentifierSerializationHandler 
@@ -1,8 +1,8 @@
 package com.sap.sailing.domain.racelogtracking.impl;

-import com.sap.sailing.domain.abstractlog.race.tracking.DeviceIdentifier;
 import com.sap.sailing.domain.common.racelog.tracking.TransformationException;
 import com.sap.sailing.domain.persistence.racelog.tracking.DeviceIdentifierMongoHandler;
+import com.sap.sailing.domain.racelogtracking.DeviceIdentifier;

 public class PingDeviceIdentifierMongoHandler extends PingDeviceIdentifierSerializationHandler
 implements DeviceIdentifierMongoHandler {
@@ -2,8 +2,8 @@ package com.sap.sailing.domain.racelogtracking.impl;

 import java.util.UUID;

-import com.sap.sailing.domain.abstractlog.race.tracking.DeviceIdentifier;
 import com.sap.sailing.domain.common.racelog.tracking.TransformationException;
+import com.sap.sailing.domain.racelogtracking.DeviceIdentifier;
 import com.sap.sailing.domain.racelogtracking.PingDeviceIdentifier;
 import com.sap.sailing.domain.racelogtracking.PingDeviceIdentifierImpl;
 import com.sap.sse.common.Util;
@@ -1,6 +1,6 @@
 package com.sap.sailing.domain.racelogtracking.impl;

-import com.sap.sailing.domain.abstractlog.race.tracking.DeviceIdentifierStringSerializationHandler;
+import com.sap.sailing.domain.racelogtracking.DeviceIdentifierStringSerializationHandler;

 public class PingDeviceIdentifierStringSerializationHandler extends PingDeviceIdentifierSerializationHandler
 implements DeviceIdentifierStringSerializationHandler {
@@ -14,18 +14,16 @@ import com.sap.sailing.domain.abstractlog.race.RaceLog;
 import com.sap.sailing.domain.abstractlog.race.RaceLogCourseDesignChangedEvent;
 import com.sap.sailing.domain.abstractlog.race.analyzing.impl.LastPublishedCourseDesignFinder;
 import com.sap.sailing.domain.abstractlog.race.impl.BaseRaceLogEventVisitor;
-import com.sap.sailing.domain.abstractlog.race.tracking.DenoteForTrackingEvent;
-import com.sap.sailing.domain.abstractlog.race.tracking.DeviceCompetitorMappingEvent;
-import com.sap.sailing.domain.abstractlog.race.tracking.DeviceIdentifier;
-import com.sap.sailing.domain.abstractlog.race.tracking.DeviceMapping;
-import com.sap.sailing.domain.abstractlog.race.tracking.DeviceMarkMappingEvent;
-import com.sap.sailing.domain.abstractlog.race.tracking.StartTrackingEvent;
-import com.sap.sailing.domain.abstractlog.race.tracking.analyzing.impl.DeviceCompetitorMappingFinder;
-import com.sap.sailing.domain.abstractlog.race.tracking.analyzing.impl.DeviceMappingFinder;
-import com.sap.sailing.domain.abstractlog.race.tracking.analyzing.impl.DeviceMarkMappingFinder;
+import com.sap.sailing.domain.abstractlog.race.tracking.RaceLogDenoteForTrackingEvent;
+import com.sap.sailing.domain.abstractlog.race.tracking.RaceLogDeviceCompetitorMappingEvent;
+import com.sap.sailing.domain.abstractlog.race.tracking.RaceLogDeviceMarkMappingEvent;
+import com.sap.sailing.domain.abstractlog.race.tracking.RaceLogStartTrackingEvent;
 import com.sap.sailing.domain.abstractlog.race.tracking.analyzing.impl.RaceInformationFinder;
+import com.sap.sailing.domain.abstractlog.race.tracking.analyzing.impl.RaceLogDeviceCompetitorMappingFinder;
+import com.sap.sailing.domain.abstractlog.race.tracking.analyzing.impl.RaceLogDeviceMappingFinder;
+import com.sap.sailing.domain.abstractlog.race.tracking.analyzing.impl.RaceLogDeviceMarkMappingFinder;
 import com.sap.sailing.domain.abstractlog.race.tracking.analyzing.impl.RaceLogTrackingStateAnalyzer;
-import com.sap.sailing.domain.abstractlog.race.tracking.analyzing.impl.RegisteredCompetitorsAnalyzer;
+import com.sap.sailing.domain.abstractlog.shared.analyzing.RegisteredCompetitorsAnalyzer;
 import com.sap.sailing.domain.base.BoatClass;
 import com.sap.sailing.domain.base.Competitor;
 import com.sap.sailing.domain.base.ControlPoint;
@@ -52,6 +50,8 @@ import com.sap.sailing.domain.common.racelog.tracking.TransformationException;
 import com.sap.sailing.domain.markpassingcalculation.MarkPassingCalculator;
 import com.sap.sailing.domain.racelog.tracking.GPSFixReceivedListener;
 import com.sap.sailing.domain.racelog.tracking.GPSFixStore;
+import com.sap.sailing.domain.racelogtracking.DeviceIdentifier;
+import com.sap.sailing.domain.racelogtracking.DeviceMapping;
 import com.sap.sailing.domain.tracking.DynamicGPSFixTrack;
 import com.sap.sailing.domain.tracking.DynamicTrackedRace;
 import com.sap.sailing.domain.tracking.DynamicTrackedRegatta;
@@ -74,7 +74,7 @@ import difflib.PatchFailedException;
 * {@link RaceLogTrackingState#TRACKING} state, tracking commences immediately and existing fixes are loaded immediately
 * from the database.
 * <p>
- * Otherwise, the tracker waits until a {@link StartTrackingEvent} is received to perform these tasks.
+ * Otherwise, the tracker waits until a {@link RaceLogStartTrackingEvent} is received to perform these tasks.
 * 
 * @author Fredrik Teschke
 * 
@@ -170,11 +170,11 @@ public class RaceLogRaceTracker extends BaseRaceLogEventVisitor implements RaceT
    }

    private Map<Competitor, List<DeviceMapping<Competitor>>> getNewCompetitorMappings() {
-        return new DeviceCompetitorMappingFinder(params.getRaceLog()).analyze();
+        return new RaceLogDeviceCompetitorMappingFinder(params.getRaceLog()).analyze();
    }

    private Map<Mark, List<DeviceMapping<Mark>>> getNewMarkMappings() {
-        return new DeviceMarkMappingFinder(params.getRaceLog()).analyze();
+        return new RaceLogDeviceMarkMappingFinder(params.getRaceLog()).analyze();
    }

    /**
@@ -283,7 +283,7 @@ public class RaceLogRaceTracker extends BaseRaceLogEventVisitor implements RaceT
    }

    @Override
-    public void visit(DeviceMarkMappingEvent event) {
+    public void visit(RaceLogDeviceMarkMappingEvent event) {
        if (trackedRace != null) {
            updateMarkMappings(true);
            gpsFixStore.addListener(this, event.getDevice());
@@ -325,7 +325,7 @@ public class RaceLogRaceTracker extends BaseRaceLogEventVisitor implements RaceT
    }

    @Override
-    public void visit(DeviceCompetitorMappingEvent event) {
+    public void visit(RaceLogDeviceCompetitorMappingEvent event) {
        if (trackedRace != null) {
            updateCompetitorMappings(true);
            gpsFixStore.addListener(this, event.getDevice());
@@ -333,7 +333,7 @@ public class RaceLogRaceTracker extends BaseRaceLogEventVisitor implements RaceT
    }

    @Override
-    public void visit(StartTrackingEvent event) {
+    public void visit(RaceLogStartTrackingEvent event) {
        if (trackedRace == null)
            startTracking(event);
    }
@@ -356,12 +356,12 @@ public class RaceLogRaceTracker extends BaseRaceLogEventVisitor implements RaceT
        }
    }

-    private void startTracking(StartTrackingEvent event) {
+    private void startTracking(RaceLogStartTrackingEvent event) {
        RaceLog raceLog = params.getRaceLog();
        RaceColumn raceColumn = params.getRaceColumn();
        Fleet fleet = params.getFleet();

-        DenoteForTrackingEvent denoteEvent = new RaceInformationFinder(raceLog).analyze();
+        RaceLogDenoteForTrackingEvent denoteEvent = new RaceInformationFinder(raceLog).analyze();
        BoatClass boatClass = denoteEvent.getBoatClass();
        String raceName = denoteEvent.getRaceName();
        CourseBase courseBase = new LastPublishedCourseDesignFinder(raceLog).analyze();
@@ -397,7 +397,8 @@ public class RaceLogRaceTracker extends BaseRaceLogEventVisitor implements RaceT
        trackedRace.setStatus(new TrackedRaceStatusImpl(TrackedRaceStatusEnum.TRACKING, 0));
        
        //add listeners for devices in mappings
-        for (List<DeviceMapping<WithID>> mappings : new DeviceMappingFinder<WithID>(params.getRaceLog()).analyze().values()) {
+        for (List<DeviceMapping<WithID>> mappings :
+            new RaceLogDeviceMappingFinder<WithID>(params.getRaceLog()).analyze().values()) {
            for (DeviceMapping<WithID> mapping : mappings) {
                gpsFixStore.addListener(this, mapping.getDevice());
            }
@@ -10,20 +10,19 @@ import java.util.logging.Level;
 import java.util.logging.Logger;

 import com.sap.sailing.domain.abstractlog.AbstractLogEventAuthor;
-import com.sap.sailing.domain.abstractlog.Revokable;
 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.analyzing.impl.LastPublishedCourseDesignFinder;
-import com.sap.sailing.domain.abstractlog.race.tracking.DefineMarkEvent;
-import com.sap.sailing.domain.abstractlog.race.tracking.DenoteForTrackingEvent;
-import com.sap.sailing.domain.abstractlog.race.tracking.DeviceIdentifier;
-import com.sap.sailing.domain.abstractlog.race.tracking.RegisterCompetitorEvent;
-import com.sap.sailing.domain.abstractlog.race.tracking.StartTrackingEvent;
+import com.sap.sailing.domain.abstractlog.race.tracking.RaceLogDefineMarkEvent;
+import com.sap.sailing.domain.abstractlog.race.tracking.RaceLogDenoteForTrackingEvent;
+import com.sap.sailing.domain.abstractlog.race.tracking.RaceLogRegisterCompetitorEvent;
+import com.sap.sailing.domain.abstractlog.race.tracking.RaceLogStartTrackingEvent;
 import com.sap.sailing.domain.abstractlog.race.tracking.analyzing.impl.AllEventsOfTypeFinder;
 import com.sap.sailing.domain.abstractlog.race.tracking.analyzing.impl.LastEventOfTypeFinder;
 import com.sap.sailing.domain.abstractlog.race.tracking.analyzing.impl.RaceLogTrackingStateAnalyzer;
-import com.sap.sailing.domain.abstractlog.race.tracking.analyzing.impl.RegisteredCompetitorsAnalyzer;
+import com.sap.sailing.domain.abstractlog.shared.analyzing.RegisteredCompetitorsAnalyzer;
+import com.sap.sailing.domain.abstractlog.shared.events.RegisterCompetitorEvent;
 import com.sap.sailing.domain.base.BoatClass;
 import com.sap.sailing.domain.base.Competitor;
 import com.sap.sailing.domain.base.ControlPoint;
@@ -48,6 +47,7 @@ import com.sap.sailing.domain.common.racelog.tracking.TransformationException;
 import com.sap.sailing.domain.leaderboard.FlexibleLeaderboard;
 import com.sap.sailing.domain.leaderboard.Leaderboard;
 import com.sap.sailing.domain.leaderboard.RegattaLeaderboard;
+import com.sap.sailing.domain.racelogtracking.DeviceIdentifier;
 import com.sap.sailing.domain.racelogtracking.PingDeviceIdentifierImpl;
 import com.sap.sailing.domain.racelogtracking.RaceLogTrackingAdapter;
 import com.sap.sailing.domain.tracking.GPSFix;
@@ -91,7 +91,7 @@ public class RaceLogTrackingAdapterImpl implements RaceLogTrackingAdapter {
    }  

    /**
-     * Adds a {@link RaceLogRaceTracker}. If a {@link StartTrackingEvent} is already present in the {@code RaceLog}
+     * Adds a {@link RaceLogRaceTracker}. If a {@link RaceLogStartTrackingEvent} is already present in the {@code RaceLog}
     * linked to the {@code raceColumn} and {@code fleet}, a {@code TrackedRace} is created immediately and tracking begins.
     * Otherwise, the {@code RaceLogRaceTracker} waits until a {@code StartTrackingEvent} is added to perform these actions.
     * The race first has to be denoted for racelog tracking.
@@ -200,7 +200,7 @@ public class RaceLogTrackingAdapterImpl implements RaceLogTrackingAdapter {
    }
    
    private void revokeAlreadyDefinedMarks(RaceLog raceLog, AbstractLogEventAuthor author) {
-        List<RaceLogEvent> markEvents = new AllEventsOfTypeFinder(raceLog, true, DefineMarkEvent.class).analyze();
+        List<RaceLogEvent> markEvents = new AllEventsOfTypeFinder(raceLog, true, RaceLogDefineMarkEvent.class).analyze();
        for (RaceLogEvent event : markEvents) {
            try {
                raceLog.revokeEvent(author, event, "removing mark that was already defined");
@@ -263,8 +263,8 @@ public class RaceLogTrackingAdapterImpl implements RaceLogTrackingAdapter {

    @Override
    public void removeDenotationForRaceLogTracking(RacingEventService service, RaceLog raceLog) {
-        Revokable denoteForTrackingEvent = (Revokable) new LastEventOfTypeFinder(raceLog, true, DenoteForTrackingEvent.class).analyze();
-        Revokable startTrackingEvent = (Revokable) new LastEventOfTypeFinder(raceLog, true, StartTrackingEvent.class).analyze();
+        RaceLogEvent denoteForTrackingEvent = new LastEventOfTypeFinder(raceLog, true, RaceLogDenoteForTrackingEvent.class).analyze();
+        RaceLogEvent startTrackingEvent = new LastEventOfTypeFinder(raceLog, true, RaceLogStartTrackingEvent.class).analyze();
        try {
            raceLog.revokeEvent(service.getServerAuthor(), denoteForTrackingEvent, "remove denotation");
            raceLog.revokeEvent(service.getServerAuthor(), startTrackingEvent, "reset start time upon removing denotation");
@@ -295,10 +295,10 @@ public class RaceLogTrackingAdapterImpl implements RaceLogTrackingAdapter {
        //unregister
        for (RaceLogEvent event : raceLog.getUnrevokedEventsDescending()) {
            if (event instanceof RegisterCompetitorEvent) {
-                RegisterCompetitorEvent registerEvent = (RegisterCompetitorEvent) event;
+                RaceLogRegisterCompetitorEvent registerEvent = (RaceLogRegisterCompetitorEvent) event;
                if (toBeRemoved.contains(registerEvent.getCompetitor())) {
                    try {
-                        raceLog.revokeEvent(service.getServerAuthor(), (RegisterCompetitorEvent) event,
+                        raceLog.revokeEvent(service.getServerAuthor(), (RaceLogRegisterCompetitorEvent) event,
                        "unregistering competitor because no longer selected for registration");
                    } catch (NotRevokableException e) {
                        logger.log(Level.WARNING, "could not unregister competitor by adding RevokeEvent", e);
@@ -1,9 +1,9 @@
 package com.sap.sailing.domain.racelogtracking.impl;

-import com.sap.sailing.domain.abstractlog.race.tracking.DeviceIdentifier;
-import com.sap.sailing.domain.abstractlog.race.tracking.SmartphoneUUIDSerializationHandler;
 import com.sap.sailing.domain.common.racelog.tracking.TransformationException;
 import com.sap.sailing.domain.persistence.racelog.tracking.DeviceIdentifierMongoHandler;
+import com.sap.sailing.domain.racelogtracking.DeviceIdentifier;
+import com.sap.sailing.domain.racelogtracking.SmartphoneUUIDSerializationHandler;

 public class SmartphoneUUIDMongoHandler extends SmartphoneUUIDSerializationHandler
 implements DeviceIdentifierMongoHandler {
@@ -1,7 +1,7 @@
 package com.sap.sailing.domain.racelogtracking.impl;

-import com.sap.sailing.domain.abstractlog.race.tracking.DeviceIdentifierStringSerializationHandler;
-import com.sap.sailing.domain.abstractlog.race.tracking.SmartphoneUUIDSerializationHandler;
+import com.sap.sailing.domain.racelogtracking.DeviceIdentifierStringSerializationHandler;
+import com.sap.sailing.domain.racelogtracking.SmartphoneUUIDSerializationHandler;

 public class SmartphoneUUIDStringSerializationHandler extends SmartphoneUUIDSerializationHandler
 implements DeviceIdentifierStringSerializationHandler {
@@ -4,8 +4,8 @@ import java.util.UUID;

 import org.json.simple.JSONObject;

-import com.sap.sailing.domain.abstractlog.race.tracking.DeviceIdentifier;
 import com.sap.sailing.domain.common.racelog.tracking.TransformationException;
+import com.sap.sailing.domain.racelogtracking.DeviceIdentifier;
 import com.sap.sailing.domain.trackfiles.TrackFileImportDeviceIdentifier;
 import com.sap.sailing.domain.trackfiles.TrackFileImportDeviceIdentifierImpl;
 import com.sap.sailing.server.gateway.serialization.racelog.tracking.DeviceIdentifierJsonHandler;
@@ -4,9 +4,9 @@ import java.util.UUID;

 import com.mongodb.BasicDBObject;
 import com.mongodb.DBObject;
-import com.sap.sailing.domain.abstractlog.race.tracking.DeviceIdentifier;
 import com.sap.sailing.domain.common.racelog.tracking.TransformationException;
 import com.sap.sailing.domain.persistence.racelog.tracking.DeviceIdentifierMongoHandler;
+import com.sap.sailing.domain.racelogtracking.DeviceIdentifier;
 import com.sap.sailing.domain.trackfiles.TrackFileImportDeviceIdentifier;
 import com.sap.sailing.domain.trackfiles.TrackFileImportDeviceIdentifierImpl;
 import com.sap.sse.common.TimePoint;
@@ -2,9 +2,9 @@ package com.sap.sailing.domain.racelogtracking.impl;

 import java.util.UUID;

-import com.sap.sailing.domain.abstractlog.race.tracking.DeviceIdentifier;
-import com.sap.sailing.domain.abstractlog.race.tracking.DeviceIdentifierStringSerializationHandler;
 import com.sap.sailing.domain.common.racelog.tracking.TransformationException;
+import com.sap.sailing.domain.racelogtracking.DeviceIdentifier;
+import com.sap.sailing.domain.racelogtracking.DeviceIdentifierStringSerializationHandler;
 import com.sap.sailing.domain.trackfiles.TrackFileImportDeviceIdentifier;
 import com.sap.sailing.domain.trackfiles.TrackFileImportDeviceIdentifierImpl;
 import com.sap.sse.common.Util;
@@ -17,7 +17,7 @@ import com.sap.sailing.domain.abstractlog.race.RaceLogEvent;
 import com.sap.sailing.domain.abstractlog.race.RaceLogEventFactory;
 import com.sap.sailing.domain.abstractlog.race.impl.RaceLogChangedVisitor;
 import com.sap.sailing.domain.abstractlog.race.impl.RaceLogImpl;
-import com.sap.sailing.domain.abstractlog.race.tracking.DenoteForTrackingEvent;
+import com.sap.sailing.domain.abstractlog.race.tracking.RaceLogDenoteForTrackingEvent;
 import com.sap.sailing.domain.common.abstractlog.NotRevokableException;
 import com.sap.sse.common.TimePoint;
 import com.sap.sse.common.Util;
@@ -107,7 +107,7 @@ public class RaceLogRevocationTest {
    
    @Test
    public void sameEventRevokedByTwoClientsBeforeSync() throws NotRevokableException {
-        DenoteForTrackingEvent event = RaceLogEventFactory.INSTANCE.createDenoteForTrackingEvent(
+        RaceLogDenoteForTrackingEvent event = RaceLogEventFactory.INSTANCE.createDenoteForTrackingEvent(
                now(), serverAuthor, 0, "race", null, null);
        serverRaceLog.add(event);
        
@@ -16,7 +16,7 @@ import com.sap.sailing.domain.abstractlog.race.RaceLog;
 import com.sap.sailing.domain.abstractlog.race.RaceLogEventFactory;
 import com.sap.sailing.domain.abstractlog.race.RaceLogStartTimeEvent;
 import com.sap.sailing.domain.abstractlog.race.impl.RaceLogImpl;
-import com.sap.sailing.domain.abstractlog.race.tracking.DeviceCompetitorMappingEvent;
+import com.sap.sailing.domain.abstractlog.race.tracking.RaceLogDeviceCompetitorMappingEvent;
 import com.sap.sailing.domain.racelog.tracking.test.mock.SmartphoneImeiIdentifier;
 import com.sap.sailing.domain.test.AbstractLeaderboardTest;
 import com.sap.sse.common.Util;
@@ -79,7 +79,7 @@ public class SerializeRaceLogEventsTest {

    @Test
    public void testRaceLogSerializationWithEventContainingDeviceIdentifier() throws IOException, ClassNotFoundException {
-    	DeviceCompetitorMappingEvent mappingEvent = eventFactory.createDeviceCompetitorMappingEvent(
+        RaceLogDeviceCompetitorMappingEvent mappingEvent = eventFactory.createDeviceCompetitorMappingEvent(
        		MillisecondsTimePoint.now(), new LogEventAuthorImpl("Author Name", /* priority */0), new SmartphoneImeiIdentifier("1948364938463903"),
        		AbstractLeaderboardTest.createCompetitor("Test Competitor"), 0, new MillisecondsTimePoint(0), new MillisecondsTimePoint(10));
        raceLog.add(mappingEvent);
@@ -89,8 +89,8 @@ public class SerializeRaceLogEventsTest {
        raceLog.lockForRead();
        rl.lockForRead();
        try {
-        	DeviceCompetitorMappingEvent expected = ((DeviceCompetitorMappingEvent) raceLog.getFirstRawFix());
-        	DeviceCompetitorMappingEvent actual = ((DeviceCompetitorMappingEvent) rl.getFirstRawFix());
+            RaceLogDeviceCompetitorMappingEvent expected = ((RaceLogDeviceCompetitorMappingEvent) raceLog.getFirstRawFix());
+            RaceLogDeviceCompetitorMappingEvent actual = ((RaceLogDeviceCompetitorMappingEvent) rl.getFirstRawFix());
        	
            assertEquals(Util.size(raceLog.getRawFixes()), Util.size(rl.getRawFixes()));
            assertEquals(expected.getDevice().getIdentifierType(), actual.getDevice().getIdentifierType());
@@ -12,12 +12,12 @@ import org.junit.Test;

 import com.sap.sailing.domain.abstractlog.AbstractLogEventAuthor;
 import com.sap.sailing.domain.abstractlog.race.RaceLogEvent;
-import com.sap.sailing.domain.abstractlog.race.tracking.DeviceIdentifier;
-import com.sap.sailing.domain.abstractlog.race.tracking.DeviceMapping;
-import com.sap.sailing.domain.abstractlog.race.tracking.analyzing.impl.DeviceCompetitorMappingFinder;
+import com.sap.sailing.domain.abstractlog.race.tracking.analyzing.impl.RaceLogDeviceCompetitorMappingFinder;
 import com.sap.sailing.domain.base.Competitor;
 import com.sap.sailing.domain.base.impl.CompetitorImpl;
 import com.sap.sailing.domain.racelog.tracking.test.mock.SmartphoneImeiIdentifier;
+import com.sap.sailing.domain.racelogtracking.DeviceIdentifier;
+import com.sap.sailing.domain.racelogtracking.DeviceMapping;
 import com.sap.sse.common.TimePoint;
 import com.sap.sse.common.impl.MillisecondsTimePoint;

@@ -29,7 +29,7 @@ public class DeviceMappingFinderTest extends AbstractRaceLogTrackingTest {
    private int time = 0;
    
    private List<DeviceMapping<Competitor>> getMappings() {
-        return new DeviceCompetitorMappingFinder(log).analyze().get(competitor);
+        return new RaceLogDeviceCompetitorMappingFinder(log).analyze().get(competitor);
    }
    
    private TimePoint t() {
@@ -32,8 +32,9 @@ Export-Package: com.sap.sailing.domain.abstractlog,
 com.sap.sailing.domain.abstractlog.race.state.racingprocedure.rrs26.impl,
 com.sap.sailing.domain.abstractlog.race.tracking,
 com.sap.sailing.domain.abstractlog.race.tracking.analyzing.impl,
- com.sap.sailing.domain.abstractlog.race.tracking.events,
 com.sap.sailing.domain.abstractlog.race.tracking.impl,
+ com.sap.sailing.domain.abstractlog.shared.analyzing,
+ com.sap.sailing.domain.abstractlog.shared.events,
 com.sap.sailing.domain.base,
 com.sap.sailing.domain.base.configuration,
 com.sap.sailing.domain.base.configuration.impl,
@@ -41,6 +42,8 @@ Export-Package: com.sap.sailing.domain.abstractlog,
 com.sap.sailing.domain.base.impl,
 com.sap.sailing.domain.base.racegroup,
 com.sap.sailing.domain.base.racegroup.impl,
+ com.sap.sailing.domain.racelogtracking,
+ com.sap.sailing.domain.racelogtracking.impl,
 com.sap.sailing.domain.tracking,
 com.sap.sailing.domain.tracking.impl,
 com.sap.sailing.util.impl
@@ -16,6 +16,6 @@ import com.sap.sailing.domain.abstractlog.race.RaceLogEvent;
 * @author Fredrik Teschke
 *
 */
-public interface Revokable extends RaceLogEvent {
+public interface Revokable {

 }
@@ -1,27 +1,7 @@
 package com.sap.sailing.domain.abstractlog.race;

-import java.util.List;
-
 import com.sap.sailing.domain.abstractlog.AbstractLogEvent;
-import com.sap.sailing.domain.base.Competitor;

-public interface RaceLogEvent extends AbstractLogEvent<RaceLogEventVisitor> {
+public interface RaceLogEvent extends AbstractLogEvent<RaceLogEventVisitor>, RaceLogEventData {

-    /**
-     * Gets the event's pass identifier.
-     * 
-     * Each {@link RaceLogEvent} is associated to a certain pass. A pass is every attempt to start and run a race. A
-     * new pass is initiated when a new start time is proposed (e.g. after the race was aborted). There might be certain
-     * event type that are not strictly bound to its pass.
-     * 
-     */
-    int getPassId();
-
-    /**
-     * Gets the list of associated {@link Competitor}s.
-     * 
-     * A {@link RaceLogEvent} might be associated with a list of competitors, which are somehow relevant for this
-     * kind of event. An example is a list of competitors who are marked for an individual recall.
-     */
-    List<Competitor> getInvolvedBoats();
 }
@@ -0,0 +1,26 @@
+package com.sap.sailing.domain.abstractlog.race;
+
+import java.util.List;
+
+import com.sap.sailing.domain.base.Competitor;
+
+public interface RaceLogEventData {
+
+    /**
+     * Gets the event's pass identifier.
+     * 
+     * Each {@link RaceLogEventData} is associated to a certain pass. A pass is every attempt to start and run a race. A
+     * new pass is initiated when a new start time is proposed (e.g. after the race was aborted). There might be certain
+     * event type that are not strictly bound to its pass.
+     * 
+     */
+    int getPassId();
+
+    /**
+     * Gets the list of associated {@link Competitor}s.
+     * 
+     * A {@link RaceLogEventData} might be associated with a list of competitors, which are somehow relevant for this
+     * kind of event. An example is a list of competitors who are marked for an individual recall.
+     */
+    List<Competitor> getInvolvedBoats();
+}
@@ -5,16 +5,15 @@ import java.util.List;

 import com.sap.sailing.domain.abstractlog.AbstractLogEventAuthor;
 import com.sap.sailing.domain.abstractlog.race.impl.RaceLogEventFactoryImpl;
-import com.sap.sailing.domain.abstractlog.race.scoring.AdditionalScoringInformationEvent;
 import com.sap.sailing.domain.abstractlog.race.scoring.AdditionalScoringInformationType;
-import com.sap.sailing.domain.abstractlog.race.tracking.CloseOpenEndedDeviceMappingEvent;
-import com.sap.sailing.domain.abstractlog.race.tracking.DefineMarkEvent;
-import com.sap.sailing.domain.abstractlog.race.tracking.DenoteForTrackingEvent;
-import com.sap.sailing.domain.abstractlog.race.tracking.DeviceCompetitorMappingEvent;
-import com.sap.sailing.domain.abstractlog.race.tracking.DeviceIdentifier;
-import com.sap.sailing.domain.abstractlog.race.tracking.DeviceMarkMappingEvent;
-import com.sap.sailing.domain.abstractlog.race.tracking.RegisterCompetitorEvent;
-import com.sap.sailing.domain.abstractlog.race.tracking.StartTrackingEvent;
+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;
+import com.sap.sailing.domain.abstractlog.race.tracking.RaceLogDenoteForTrackingEvent;
+import com.sap.sailing.domain.abstractlog.race.tracking.RaceLogDeviceCompetitorMappingEvent;
+import com.sap.sailing.domain.abstractlog.race.tracking.RaceLogDeviceMarkMappingEvent;
+import com.sap.sailing.domain.abstractlog.race.tracking.RaceLogRegisterCompetitorEvent;
+import com.sap.sailing.domain.abstractlog.race.tracking.RaceLogStartTrackingEvent;
 import com.sap.sailing.domain.base.BoatClass;
 import com.sap.sailing.domain.base.Competitor;
 import com.sap.sailing.domain.base.CourseBase;
@@ -22,6 +21,7 @@ import com.sap.sailing.domain.base.Mark;
 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.racelogtracking.DeviceIdentifier;
 import com.sap.sailing.domain.tracking.Wind;
 import com.sap.sse.common.TimePoint;

@@ -101,26 +101,26 @@ public interface RaceLogEventFactory {
    RaceLogWindFixEvent createWindFixEvent(TimePoint logicalTimePoint, AbstractLogEventAuthor author,
            Serializable id, List<Competitor> competitors, int passId, Wind wind);

-    DeviceCompetitorMappingEvent createDeviceCompetitorMappingEvent(TimePoint logicalTimePoint, AbstractLogEventAuthor author,
+    RaceLogDeviceCompetitorMappingEvent createDeviceCompetitorMappingEvent(TimePoint logicalTimePoint, AbstractLogEventAuthor author,
            DeviceIdentifier device, Competitor mappedTo, int passId, TimePoint from, TimePoint to);

-    DeviceMarkMappingEvent createDeviceMarkMappingEvent(TimePoint logicalTimePoint, AbstractLogEventAuthor author,
+    RaceLogDeviceMarkMappingEvent createDeviceMarkMappingEvent(TimePoint logicalTimePoint, AbstractLogEventAuthor author,
            DeviceIdentifier device, Mark mappedTo, int passId, TimePoint from, TimePoint to);

-    DenoteForTrackingEvent createDenoteForTrackingEvent(TimePoint logicalTimePoint, AbstractLogEventAuthor author, int passId,
+    RaceLogDenoteForTrackingEvent createDenoteForTrackingEvent(TimePoint logicalTimePoint, AbstractLogEventAuthor author, int passId,
    		String raceName, BoatClass boatClass, Serializable raceId);

-    StartTrackingEvent createStartTrackingEvent(TimePoint logicalTimePoint, AbstractLogEventAuthor author, int passId);
+    RaceLogStartTrackingEvent createStartTrackingEvent(TimePoint logicalTimePoint, AbstractLogEventAuthor author, int passId);
    
    RaceLogRevokeEvent createRevokeEvent(AbstractLogEventAuthor author, int passId, RaceLogEvent toRevoke, String reason);
    
-    RegisterCompetitorEvent createRegisterCompetitorEvent(TimePoint logicalTimePoint, AbstractLogEventAuthor author, int passId, Competitor competitor);
+    RaceLogRegisterCompetitorEvent createRegisterCompetitorEvent(TimePoint logicalTimePoint, AbstractLogEventAuthor author, int passId, Competitor competitor);
    
-    DefineMarkEvent createDefineMarkEvent(TimePoint logicalTimePoint, AbstractLogEventAuthor author, int passId, Mark mark);
+    RaceLogDefineMarkEvent createDefineMarkEvent(TimePoint logicalTimePoint, AbstractLogEventAuthor author, int passId, Mark mark);
    
-    CloseOpenEndedDeviceMappingEvent createCloseOpenEndedDeviceMappingEvent(TimePoint logicalTimePoint, AbstractLogEventAuthor author, int passId,
+    RaceLogCloseOpenEndedDeviceMappingEvent createCloseOpenEndedDeviceMappingEvent(TimePoint logicalTimePoint, AbstractLogEventAuthor author, int passId,
            Serializable deviceMappingEventId, TimePoint closingTimePoint);

-    AdditionalScoringInformationEvent createAdditionalScoringInformationEvent(TimePoint timePoint, Serializable id, AbstractLogEventAuthor author, int currentPassId,
+    RaceLogAdditionalScoringInformationEvent createAdditionalScoringInformationEvent(TimePoint timePoint, Serializable id, AbstractLogEventAuthor author, int currentPassId,
            AdditionalScoringInformationType informationType);
 }
@@ -5,16 +5,15 @@ import java.util.List;

 import com.sap.sailing.domain.abstractlog.AbstractLogEventAuthor;
 import com.sap.sailing.domain.abstractlog.race.impl.RaceLogEventRestoreFactoryImpl;
-import com.sap.sailing.domain.abstractlog.race.scoring.AdditionalScoringInformationEvent;
 import com.sap.sailing.domain.abstractlog.race.scoring.AdditionalScoringInformationType;
-import com.sap.sailing.domain.abstractlog.race.tracking.CloseOpenEndedDeviceMappingEvent;
-import com.sap.sailing.domain.abstractlog.race.tracking.DefineMarkEvent;
-import com.sap.sailing.domain.abstractlog.race.tracking.DenoteForTrackingEvent;
-import com.sap.sailing.domain.abstractlog.race.tracking.DeviceCompetitorMappingEvent;
-import com.sap.sailing.domain.abstractlog.race.tracking.DeviceIdentifier;
-import com.sap.sailing.domain.abstractlog.race.tracking.DeviceMarkMappingEvent;
-import com.sap.sailing.domain.abstractlog.race.tracking.RegisterCompetitorEvent;
-import com.sap.sailing.domain.abstractlog.race.tracking.StartTrackingEvent;
+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;
+import com.sap.sailing.domain.abstractlog.race.tracking.RaceLogDenoteForTrackingEvent;
+import com.sap.sailing.domain.abstractlog.race.tracking.RaceLogDeviceCompetitorMappingEvent;
+import com.sap.sailing.domain.abstractlog.race.tracking.RaceLogDeviceMarkMappingEvent;
+import com.sap.sailing.domain.abstractlog.race.tracking.RaceLogRegisterCompetitorEvent;
+import com.sap.sailing.domain.abstractlog.race.tracking.RaceLogStartTrackingEvent;
 import com.sap.sailing.domain.base.BoatClass;
 import com.sap.sailing.domain.base.Competitor;
 import com.sap.sailing.domain.base.CourseBase;
@@ -22,6 +21,7 @@ import com.sap.sailing.domain.base.Mark;
 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.racelogtracking.DeviceIdentifier;
 import com.sap.sailing.domain.tracking.Wind;
 import com.sap.sse.common.TimePoint;

@@ -70,32 +70,32 @@ public interface RaceLogEventRestoreFactory extends RaceLogEventFactory {
    RaceLogWindFixEvent createWindFixEvent(TimePoint createdAt, AbstractLogEventAuthor author, TimePoint logicalTimePoint,
            Serializable id, List<Competitor> competitors, Integer passId, Wind wind);

-    DeviceCompetitorMappingEvent createDeviceCompetitorMappingEvent(TimePoint createdAt, AbstractLogEventAuthor author,
+    RaceLogDeviceCompetitorMappingEvent createDeviceCompetitorMappingEvent(TimePoint createdAt, AbstractLogEventAuthor author,
    		TimePoint logicalTimePoint, Serializable pId, DeviceIdentifier device, Competitor mappedTo, int passId, TimePoint from, TimePoint to);

-    DeviceMarkMappingEvent createDeviceMarkMappingEvent(TimePoint createdAt, AbstractLogEventAuthor author,
+    RaceLogDeviceMarkMappingEvent createDeviceMarkMappingEvent(TimePoint createdAt, AbstractLogEventAuthor author,
    		TimePoint logicalTimePoint, Serializable pId, DeviceIdentifier device, Mark mappedTo, int passId, TimePoint from, TimePoint to);

-    DenoteForTrackingEvent createDenoteForTrackingEvent(TimePoint createdAt, AbstractLogEventAuthor author,
+    RaceLogDenoteForTrackingEvent createDenoteForTrackingEvent(TimePoint createdAt, AbstractLogEventAuthor author,
    		TimePoint logicalTimePoint, Serializable pId, int passId, String raceName, BoatClass boatClass, Serializable raceId);

-    StartTrackingEvent createStartTrackingEvent(TimePoint createdAt, AbstractLogEventAuthor author,
+    RaceLogStartTrackingEvent createStartTrackingEvent(TimePoint createdAt, AbstractLogEventAuthor author,
    		TimePoint logicalTimePoint, Serializable pId, int passId);
    
    RaceLogRevokeEvent createRevokeEvent(TimePoint createdAt, AbstractLogEventAuthor author,
    		TimePoint logicalTimePoint, Serializable pId, int passId, Serializable revokedEventId,
    		String revokedEventType, String revokedEventShortInfo, String reason);
    
-    RegisterCompetitorEvent createRegisterCompetitorEvent(TimePoint createdAt, AbstractLogEventAuthor author,
+    RaceLogRegisterCompetitorEvent createRegisterCompetitorEvent(TimePoint createdAt, AbstractLogEventAuthor author,
    		TimePoint logicalTimePoint, Serializable pId, int passId, Competitor competitor);
    
-    DefineMarkEvent createDefineMarkEvent(TimePoint createdAt, AbstractLogEventAuthor author,
+    RaceLogDefineMarkEvent createDefineMarkEvent(TimePoint createdAt, AbstractLogEventAuthor author,
                TimePoint logicalTimePoint, Serializable pId, int passId, Mark mark);
    
-    CloseOpenEndedDeviceMappingEvent createCloseOpenEndedDeviceMappingEvent(TimePoint createdAt, AbstractLogEventAuthor author,
+    RaceLogCloseOpenEndedDeviceMappingEvent createCloseOpenEndedDeviceMappingEvent(TimePoint createdAt, AbstractLogEventAuthor author,
            TimePoint logicalTimePoint, Serializable pId, int passId, Serializable deviceMappingEventId, TimePoint closingTimePoint);

-    AdditionalScoringInformationEvent createAdditionalScoringInformationEvent(TimePoint createdAt, AbstractLogEventAuthor author,
+    RaceLogAdditionalScoringInformationEvent createAdditionalScoringInformationEvent(TimePoint createdAt, AbstractLogEventAuthor author,
            TimePoint logicalTimePoint, Serializable pId, List<Competitor> competitors, int passId,
            AdditionalScoringInformationType informationType);
 }
@@ -1,13 +1,13 @@
 package com.sap.sailing.domain.abstractlog.race;

-import com.sap.sailing.domain.abstractlog.race.scoring.AdditionalScoringInformationEvent;
-import com.sap.sailing.domain.abstractlog.race.tracking.CloseOpenEndedDeviceMappingEvent;
-import com.sap.sailing.domain.abstractlog.race.tracking.DefineMarkEvent;
-import com.sap.sailing.domain.abstractlog.race.tracking.DenoteForTrackingEvent;
-import com.sap.sailing.domain.abstractlog.race.tracking.DeviceCompetitorMappingEvent;
-import com.sap.sailing.domain.abstractlog.race.tracking.DeviceMarkMappingEvent;
-import com.sap.sailing.domain.abstractlog.race.tracking.RegisterCompetitorEvent;
-import com.sap.sailing.domain.abstractlog.race.tracking.StartTrackingEvent;
+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;
+import com.sap.sailing.domain.abstractlog.race.tracking.RaceLogDenoteForTrackingEvent;
+import com.sap.sailing.domain.abstractlog.race.tracking.RaceLogDeviceCompetitorMappingEvent;
+import com.sap.sailing.domain.abstractlog.race.tracking.RaceLogDeviceMarkMappingEvent;
+import com.sap.sailing.domain.abstractlog.race.tracking.RaceLogRegisterCompetitorEvent;
+import com.sap.sailing.domain.abstractlog.race.tracking.RaceLogStartTrackingEvent;


 public interface RaceLogEventVisitor {
@@ -39,19 +39,19 @@ public interface RaceLogEventVisitor {
    
    public void visit(RaceLogWindFixEvent event);
    
-    public void visit(DeviceCompetitorMappingEvent event);
+    public void visit(RaceLogDeviceCompetitorMappingEvent event);
    
-    public void visit(DeviceMarkMappingEvent event);
+    public void visit(RaceLogDeviceMarkMappingEvent event);
    
-    public void visit(DenoteForTrackingEvent event);
+    public void visit(RaceLogDenoteForTrackingEvent event);
    
-    public void visit(StartTrackingEvent event);
+    public void visit(RaceLogStartTrackingEvent event);
    
-    public void visit(RegisterCompetitorEvent event);
+    public void visit(RaceLogRegisterCompetitorEvent event);
    
-    public void visit(DefineMarkEvent event);
+    public void visit(RaceLogDefineMarkEvent event);
    
-    public void visit(CloseOpenEndedDeviceMappingEvent event);
+    public void visit(RaceLogCloseOpenEndedDeviceMappingEvent event);

-    public void visit(AdditionalScoringInformationEvent additionalScoringInformation);
+    public void visit(RaceLogAdditionalScoringInformationEvent additionalScoringInformation);
 }
@@ -5,11 +5,11 @@ import java.util.List;

 import com.sap.sailing.domain.abstractlog.race.RaceLog;
 import com.sap.sailing.domain.abstractlog.race.RaceLogEvent;
-import com.sap.sailing.domain.abstractlog.race.scoring.AdditionalScoringInformationEvent;
+import com.sap.sailing.domain.abstractlog.race.scoring.RaceLogAdditionalScoringInformationEvent;
 import com.sap.sailing.domain.abstractlog.race.scoring.AdditionalScoringInformationType;

 /**
- * Returns all {@link AdditionalScoringInformationEvent}s from the race log 
+ * Returns all {@link RaceLogAdditionalScoringInformationEvent}s from the race log 
 * that have not been revoked when using {@link #analyze()}. The resulting list 
 * has the newest event first. The pass id is not relevant for the result.
 * 
@@ -21,7 +21,7 @@ import com.sap.sailing.domain.abstractlog.race.scoring.AdditionalScoringInformat
 * 
 * @author Simon Marcel Pamies
 */
-public class AdditionalScoringInformationFinder extends RaceLogAnalyzer<List<AdditionalScoringInformationEvent>> {
+public class AdditionalScoringInformationFinder extends RaceLogAnalyzer<List<RaceLogAdditionalScoringInformationEvent>> {

    public AdditionalScoringInformationFinder(RaceLog raceLog) {
        super(raceLog);
@@ -31,10 +31,10 @@ public class AdditionalScoringInformationFinder extends RaceLogAnalyzer<List<Add
     * Analyze the race log for all events that match the given type filter. Returns only the <emph>newest</emph>
     * one as we assume that there can be only one unrevoked event of the same type.
     */
-    public AdditionalScoringInformationEvent analyze(AdditionalScoringInformationType filterBy) {
-        AdditionalScoringInformationEvent result = null;
-        final List<AdditionalScoringInformationEvent> allUnrevokedEventsFromNewestToOldest = analyze();
-        for (AdditionalScoringInformationEvent event : allUnrevokedEventsFromNewestToOldest) {
+    public RaceLogAdditionalScoringInformationEvent analyze(AdditionalScoringInformationType filterBy) {
+        RaceLogAdditionalScoringInformationEvent result = null;
+        final List<RaceLogAdditionalScoringInformationEvent> allUnrevokedEventsFromNewestToOldest = analyze();
+        for (RaceLogAdditionalScoringInformationEvent event : allUnrevokedEventsFromNewestToOldest) {
            if (event != null && event.getType() == filterBy) {
                result = event;
                break;
@@ -44,12 +44,12 @@ public class AdditionalScoringInformationFinder extends RaceLogAnalyzer<List<Add
    }

    @Override
-    protected List<AdditionalScoringInformationEvent> performAnalysis() {
-        final List<AdditionalScoringInformationEvent> result = new ArrayList<AdditionalScoringInformationEvent>();
+    protected List<RaceLogAdditionalScoringInformationEvent> performAnalysis() {
+        final List<RaceLogAdditionalScoringInformationEvent> result = new ArrayList<RaceLogAdditionalScoringInformationEvent>();
        // fetch all unrevoked events starting with newest going to oldest
        for (RaceLogEvent event : getLog().getUnrevokedEventsDescending()) {
-            if (event instanceof AdditionalScoringInformationEvent) {
-                result.add((AdditionalScoringInformationEvent) event);
+            if (event instanceof RaceLogAdditionalScoringInformationEvent) {
+                result.add((RaceLogAdditionalScoringInformationEvent) event);
            }
        }
        return result;
@@ -16,14 +16,14 @@ import com.sap.sailing.domain.abstractlog.race.RaceLogRevokeEvent;
 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.scoring.AdditionalScoringInformationEvent;
-import com.sap.sailing.domain.abstractlog.race.tracking.CloseOpenEndedDeviceMappingEvent;
-import com.sap.sailing.domain.abstractlog.race.tracking.DefineMarkEvent;
-import com.sap.sailing.domain.abstractlog.race.tracking.DenoteForTrackingEvent;
-import com.sap.sailing.domain.abstractlog.race.tracking.DeviceCompetitorMappingEvent;
-import com.sap.sailing.domain.abstractlog.race.tracking.DeviceMarkMappingEvent;
-import com.sap.sailing.domain.abstractlog.race.tracking.RegisterCompetitorEvent;
-import com.sap.sailing.domain.abstractlog.race.tracking.StartTrackingEvent;
+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;
+import com.sap.sailing.domain.abstractlog.race.tracking.RaceLogDenoteForTrackingEvent;
+import com.sap.sailing.domain.abstractlog.race.tracking.RaceLogDeviceCompetitorMappingEvent;
+import com.sap.sailing.domain.abstractlog.race.tracking.RaceLogDeviceMarkMappingEvent;
+import com.sap.sailing.domain.abstractlog.race.tracking.RaceLogRegisterCompetitorEvent;
+import com.sap.sailing.domain.abstractlog.race.tracking.RaceLogStartTrackingEvent;

 public abstract class AbstractRaceLogChangedVisitor implements RaceLogEventVisitor {
    protected abstract void notifyListenerAboutEventAdded(RaceLogEvent event);
@@ -88,22 +88,22 @@ public abstract class AbstractRaceLogChangedVisitor implements RaceLogEventVisit
    }

    @Override
-    public void visit(DeviceCompetitorMappingEvent event) {
+    public void visit(RaceLogDeviceCompetitorMappingEvent event) {
        notifyListenerAboutEventAdded(event);
    }

    @Override
-    public void visit(DeviceMarkMappingEvent event) {
+    public void visit(RaceLogDeviceMarkMappingEvent event) {
        notifyListenerAboutEventAdded(event);
    }

    @Override
-    public void visit(DenoteForTrackingEvent event) {
+    public void visit(RaceLogDenoteForTrackingEvent event) {
        notifyListenerAboutEventAdded(event);
    }

    @Override
-    public void visit(StartTrackingEvent event) {
+    public void visit(RaceLogStartTrackingEvent event) {
        notifyListenerAboutEventAdded(event);
    }

@@ -113,22 +113,22 @@ public abstract class AbstractRaceLogChangedVisitor implements RaceLogEventVisit
    }

    @Override
-    public void visit(RegisterCompetitorEvent event) {
+    public void visit(RaceLogRegisterCompetitorEvent event) {
        notifyListenerAboutEventAdded(event);
    }

    @Override
-    public void visit(DefineMarkEvent event) {
+    public void visit(RaceLogDefineMarkEvent event) {
        notifyListenerAboutEventAdded(event);
    }
    
    @Override
-    public void visit(CloseOpenEndedDeviceMappingEvent event) {
+    public void visit(RaceLogCloseOpenEndedDeviceMappingEvent event) {
        notifyListenerAboutEventAdded(event);
    }
    
    @Override
-    public void visit(AdditionalScoringInformationEvent additionalScoringInformation) {
+    public void visit(RaceLogAdditionalScoringInformationEvent additionalScoringInformation) {
        notifyListenerAboutEventAdded(additionalScoringInformation);
    }
 }
@@ -15,14 +15,14 @@ import com.sap.sailing.domain.abstractlog.race.RaceLogRevokeEvent;
 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.scoring.AdditionalScoringInformationEvent;
-import com.sap.sailing.domain.abstractlog.race.tracking.CloseOpenEndedDeviceMappingEvent;
-import com.sap.sailing.domain.abstractlog.race.tracking.DefineMarkEvent;
-import com.sap.sailing.domain.abstractlog.race.tracking.DenoteForTrackingEvent;
-import com.sap.sailing.domain.abstractlog.race.tracking.DeviceCompetitorMappingEvent;
-import com.sap.sailing.domain.abstractlog.race.tracking.DeviceMarkMappingEvent;
-import com.sap.sailing.domain.abstractlog.race.tracking.RegisterCompetitorEvent;
-import com.sap.sailing.domain.abstractlog.race.tracking.StartTrackingEvent;
+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;
+import com.sap.sailing.domain.abstractlog.race.tracking.RaceLogDenoteForTrackingEvent;
+import com.sap.sailing.domain.abstractlog.race.tracking.RaceLogDeviceCompetitorMappingEvent;
+import com.sap.sailing.domain.abstractlog.race.tracking.RaceLogDeviceMarkMappingEvent;
+import com.sap.sailing.domain.abstractlog.race.tracking.RaceLogRegisterCompetitorEvent;
+import com.sap.sailing.domain.abstractlog.race.tracking.RaceLogStartTrackingEvent;

 /**
 * Base class implementing {@link RaceLogEventVisitor}. Every method is implemented as a no-op.
@@ -95,22 +95,22 @@ public abstract class BaseRaceLogEventVisitor implements RaceLogEventVisitor {
    }
    
    @Override
-    public void visit(DeviceCompetitorMappingEvent event) {
+    public void visit(RaceLogDeviceCompetitorMappingEvent event) {
    	
    }
    
    @Override
-    public void visit(DeviceMarkMappingEvent event) {
+    public void visit(RaceLogDeviceMarkMappingEvent event) {
    	
    }
    
    @Override
-    public void visit(DenoteForTrackingEvent event) {
+    public void visit(RaceLogDenoteForTrackingEvent event) {
    	
    }
    
    @Override
-    public void visit(StartTrackingEvent event) {
+    public void visit(RaceLogStartTrackingEvent event) {
    	
    }
    
@@ -120,22 +120,22 @@ public abstract class BaseRaceLogEventVisitor implements RaceLogEventVisitor {
    }
    
    @Override
-    public void visit(RegisterCompetitorEvent event) {
+    public void visit(RaceLogRegisterCompetitorEvent event) {

    }
    
    @Override
-    public void visit(DefineMarkEvent event) {
+    public void visit(RaceLogDefineMarkEvent event) {
         
    }

    @Override
-    public void visit(CloseOpenEndedDeviceMappingEvent event) {
+    public void visit(RaceLogCloseOpenEndedDeviceMappingEvent event) {
        
    }
    
    @Override
-    public void visit(AdditionalScoringInformationEvent event) {
+    public void visit(RaceLogAdditionalScoringInformationEvent event) {
        
    }
 }
@@ -0,0 +1,36 @@
+package com.sap.sailing.domain.abstractlog.race.impl;
+
+import java.util.Collections;
+import java.util.List;
+
+import com.sap.sailing.domain.abstractlog.race.RaceLogEventData;
+import com.sap.sailing.domain.base.Competitor;
+
+public class RaceLogEventDataImpl implements RaceLogEventData {
+    private final List<Competitor> involvedBoats;
+    private final int passId;
+    
+    public RaceLogEventDataImpl(List<Competitor> involvedBoats, int passId) {
+        if (involvedBoats == null) {
+            this.involvedBoats = Collections.emptyList();
+        } else {
+            this.involvedBoats = involvedBoats;
+        }
+        this.passId = passId;
+    }
+
+    @Override
+    public List<Competitor> getInvolvedBoats() {
+        return involvedBoats;
+    }
+
+    @Override
+    public int getPassId() {
+        return passId;
+    }
+    
+    @Override
+    public String toString() {
+        return super.toString() + ", involvedBoats: " + getInvolvedBoats() + ", passId: " + getPassId();
+    }
+}
@@ -23,24 +23,23 @@ import com.sap.sailing.domain.abstractlog.race.RaceLogRevokeEvent;
 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.scoring.AdditionalScoringInformationEvent;
 import com.sap.sailing.domain.abstractlog.race.scoring.AdditionalScoringInformationType;
-import com.sap.sailing.domain.abstractlog.race.scoring.impl.AdditionalScoringInformationEventImpl;
-import com.sap.sailing.domain.abstractlog.race.tracking.CloseOpenEndedDeviceMappingEvent;
-import com.sap.sailing.domain.abstractlog.race.tracking.DefineMarkEvent;
-import com.sap.sailing.domain.abstractlog.race.tracking.DenoteForTrackingEvent;
-import com.sap.sailing.domain.abstractlog.race.tracking.DeviceCompetitorMappingEvent;
-import com.sap.sailing.domain.abstractlog.race.tracking.DeviceIdentifier;
-import com.sap.sailing.domain.abstractlog.race.tracking.DeviceMarkMappingEvent;
-import com.sap.sailing.domain.abstractlog.race.tracking.RegisterCompetitorEvent;
-import com.sap.sailing.domain.abstractlog.race.tracking.StartTrackingEvent;
-import com.sap.sailing.domain.abstractlog.race.tracking.events.CloseOpenEndedDeviceMappingEventImpl;
-import com.sap.sailing.domain.abstractlog.race.tracking.events.DefineMarkEventImpl;
-import com.sap.sailing.domain.abstractlog.race.tracking.events.DenoteForTrackingEventImpl;
-import com.sap.sailing.domain.abstractlog.race.tracking.events.DeviceCompetitorMappingEventImpl;
-import com.sap.sailing.domain.abstractlog.race.tracking.events.DeviceMarkMappingEventImpl;
-import com.sap.sailing.domain.abstractlog.race.tracking.events.RegisterCompetitorEventImpl;
-import com.sap.sailing.domain.abstractlog.race.tracking.events.StartTrackingEventImpl;
+import com.sap.sailing.domain.abstractlog.race.scoring.RaceLogAdditionalScoringInformationEvent;
+import com.sap.sailing.domain.abstractlog.race.scoring.impl.RaceLogAdditionalScoringInformationEventImpl;
+import com.sap.sailing.domain.abstractlog.race.tracking.RaceLogCloseOpenEndedDeviceMappingEvent;
+import com.sap.sailing.domain.abstractlog.race.tracking.RaceLogDefineMarkEvent;
+import com.sap.sailing.domain.abstractlog.race.tracking.RaceLogDenoteForTrackingEvent;
+import com.sap.sailing.domain.abstractlog.race.tracking.RaceLogDeviceCompetitorMappingEvent;
+import com.sap.sailing.domain.abstractlog.race.tracking.RaceLogDeviceMarkMappingEvent;
+import com.sap.sailing.domain.abstractlog.race.tracking.RaceLogRegisterCompetitorEvent;
+import com.sap.sailing.domain.abstractlog.race.tracking.RaceLogStartTrackingEvent;
+import com.sap.sailing.domain.abstractlog.race.tracking.impl.RaceLogCloseOpenEndedDeviceMappingEventImpl;
+import com.sap.sailing.domain.abstractlog.race.tracking.impl.RaceLogDefineMarkEventImpl;
+import com.sap.sailing.domain.abstractlog.race.tracking.impl.RaceLogDenoteForTrackingEventImpl;
+import com.sap.sailing.domain.abstractlog.race.tracking.impl.RaceLogDeviceCompetitorMappingEventImpl;
+import com.sap.sailing.domain.abstractlog.race.tracking.impl.RaceLogDeviceMarkMappingEventImpl;
+import com.sap.sailing.domain.abstractlog.race.tracking.impl.RaceLogRegisterCompetitorEventImpl;
+import com.sap.sailing.domain.abstractlog.race.tracking.impl.RaceLogStartTrackingEventImpl;
 import com.sap.sailing.domain.base.BoatClass;
 import com.sap.sailing.domain.base.Competitor;
 import com.sap.sailing.domain.base.CourseBase;
@@ -48,6 +47,7 @@ import com.sap.sailing.domain.base.Mark;
 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.racelogtracking.DeviceIdentifier;
 import com.sap.sailing.domain.tracking.Wind;
 import com.sap.sse.common.TimePoint;
 import com.sap.sse.common.impl.MillisecondsTimePoint;
@@ -224,29 +224,29 @@ public class RaceLogEventFactoryImpl implements RaceLogEventFactory {
    }

    @Override
-    public DeviceCompetitorMappingEvent createDeviceCompetitorMappingEvent(TimePoint logicalTimePoint, AbstractLogEventAuthor author,
+    public RaceLogDeviceCompetitorMappingEvent createDeviceCompetitorMappingEvent(TimePoint logicalTimePoint, AbstractLogEventAuthor author,
            DeviceIdentifier device, Competitor mappedTo, int passId, TimePoint from, TimePoint to) {
-        return new DeviceCompetitorMappingEventImpl(MillisecondsTimePoint.now(), author, logicalTimePoint, UUID.randomUUID(),
+        return new RaceLogDeviceCompetitorMappingEventImpl(MillisecondsTimePoint.now(), author, logicalTimePoint, UUID.randomUUID(),
                passId, mappedTo, device, from, to);
    }

    @Override
-    public DeviceMarkMappingEvent createDeviceMarkMappingEvent(TimePoint logicalTimePoint, AbstractLogEventAuthor author,
+    public RaceLogDeviceMarkMappingEvent createDeviceMarkMappingEvent(TimePoint logicalTimePoint, AbstractLogEventAuthor author,
            DeviceIdentifier device, Mark mappedTo, int passId, TimePoint from, TimePoint to) {
-        return new DeviceMarkMappingEventImpl(MillisecondsTimePoint.now(), author, logicalTimePoint, UUID.randomUUID(),
+        return new RaceLogDeviceMarkMappingEventImpl(MillisecondsTimePoint.now(), author, logicalTimePoint, UUID.randomUUID(),
                passId, mappedTo, device, from, to);
    }

    @Override
-    public DenoteForTrackingEvent createDenoteForTrackingEvent(TimePoint logicalTimePoint, AbstractLogEventAuthor author, int passId,
+    public RaceLogDenoteForTrackingEvent createDenoteForTrackingEvent(TimePoint logicalTimePoint, AbstractLogEventAuthor author, int passId,
            String raceName, BoatClass boatClass, Serializable raceId) {
-        return new DenoteForTrackingEventImpl(MillisecondsTimePoint.now(), author, logicalTimePoint, UUID.randomUUID(), passId, raceName,
+        return new RaceLogDenoteForTrackingEventImpl(MillisecondsTimePoint.now(), author, logicalTimePoint, UUID.randomUUID(), passId, raceName,
                boatClass, raceId);
    }

    @Override
-    public StartTrackingEvent createStartTrackingEvent(TimePoint logicalTimePoint, AbstractLogEventAuthor author, int passId) {
-        return new StartTrackingEventImpl(MillisecondsTimePoint.now(), author, logicalTimePoint, UUID.randomUUID(), passId);
+    public RaceLogStartTrackingEvent createStartTrackingEvent(TimePoint logicalTimePoint, AbstractLogEventAuthor author, int passId) {
+        return new RaceLogStartTrackingEventImpl(MillisecondsTimePoint.now(), author, logicalTimePoint, UUID.randomUUID(), passId);
    }

    @Override
@@ -255,28 +255,28 @@ public class RaceLogEventFactoryImpl implements RaceLogEventFactory {
    }

    @Override
-    public RegisterCompetitorEvent createRegisterCompetitorEvent(TimePoint logicalTimePoint, AbstractLogEventAuthor author,
+    public RaceLogRegisterCompetitorEvent createRegisterCompetitorEvent(TimePoint logicalTimePoint, AbstractLogEventAuthor author,
            int passId, Competitor competitor) {
-        return new RegisterCompetitorEventImpl(MillisecondsTimePoint.now(), author, logicalTimePoint, UUID.randomUUID(), passId, competitor);
+        return new RaceLogRegisterCompetitorEventImpl(MillisecondsTimePoint.now(), author, logicalTimePoint, UUID.randomUUID(), passId, competitor);
    }

    @Override
-    public DefineMarkEvent createDefineMarkEvent(TimePoint logicalTimePoint, AbstractLogEventAuthor author,
+    public RaceLogDefineMarkEvent createDefineMarkEvent(TimePoint logicalTimePoint, AbstractLogEventAuthor author,
            int passId, Mark mark) {
-        return new DefineMarkEventImpl(MillisecondsTimePoint.now(), author, logicalTimePoint, UUID.randomUUID(), passId, mark);
+        return new RaceLogDefineMarkEventImpl(MillisecondsTimePoint.now(), author, logicalTimePoint, UUID.randomUUID(), passId, mark);
    }

    @Override
-    public CloseOpenEndedDeviceMappingEvent createCloseOpenEndedDeviceMappingEvent(TimePoint logicalTimePoint,
+    public RaceLogCloseOpenEndedDeviceMappingEvent createCloseOpenEndedDeviceMappingEvent(TimePoint logicalTimePoint,
            AbstractLogEventAuthor author, int passId, Serializable deviceMappingEventId, TimePoint closingTimePoint) {
-        return new CloseOpenEndedDeviceMappingEventImpl(MillisecondsTimePoint.now(), author, logicalTimePoint,
+        return new RaceLogCloseOpenEndedDeviceMappingEventImpl(MillisecondsTimePoint.now(), author, logicalTimePoint,
                UUID.randomUUID(), passId, deviceMappingEventId, closingTimePoint);
    }

    @Override
-    public AdditionalScoringInformationEvent createAdditionalScoringInformationEvent(TimePoint timePoint, Serializable id,
+    public RaceLogAdditionalScoringInformationEvent createAdditionalScoringInformationEvent(TimePoint timePoint, Serializable id,
            AbstractLogEventAuthor author, int currentPassId, AdditionalScoringInformationType informationType) {
-        return new AdditionalScoringInformationEventImpl(MillisecondsTimePoint.now(), author, timePoint, id, Collections.<Competitor>emptyList(), currentPassId,
+        return new RaceLogAdditionalScoringInformationEventImpl(MillisecondsTimePoint.now(), author, timePoint, id, Collections.<Competitor>emptyList(), currentPassId,
                informationType);
    }
 }
@@ -6,35 +6,33 @@ import java.util.List;
 import com.sap.sailing.domain.abstractlog.AbstractLogEventAuthor;
 import com.sap.sailing.domain.abstractlog.impl.AbstractLogEventImpl;
 import com.sap.sailing.domain.abstractlog.race.RaceLogEvent;
+import com.sap.sailing.domain.abstractlog.race.RaceLogEventData;
 import com.sap.sailing.domain.abstractlog.race.RaceLogEventVisitor;
 import com.sap.sailing.domain.base.Competitor;
 import com.sap.sse.common.TimePoint;

 public abstract class RaceLogEventImpl extends AbstractLogEventImpl<RaceLogEventVisitor> implements RaceLogEvent {
-    private final List<Competitor> involvedBoats;
-    private final int passId;
-
    private static final long serialVersionUID = -2557594972618769182L;
+    private final RaceLogEventData raceLogEventData;

    public RaceLogEventImpl(TimePoint createdAt, AbstractLogEventAuthor author, TimePoint logicalTimePoint,
            Serializable pId, List<Competitor> pInvolvedBoats, int pPassId) {
        super(createdAt, author, logicalTimePoint, pId);
-        this.involvedBoats = pInvolvedBoats;
-        this.passId = pPassId;
+        this.raceLogEventData = new RaceLogEventDataImpl(pInvolvedBoats, pPassId);
    }
-
+    
    @Override
    public List<Competitor> getInvolvedBoats() {
-        return involvedBoats;
+        return raceLogEventData.getInvolvedBoats();
    }
-
+    
    @Override
    public int getPassId() {
-        return passId;
+        return raceLogEventData.getPassId();
    }
    
    @Override
    public String toString() {
-        return super.toString() + ", involvedBoats: " + getInvolvedBoats() + ", passId: " + getPassId();
+        return raceLogEventData.toString();
    }
 }
@@ -20,24 +20,23 @@ import com.sap.sailing.domain.abstractlog.race.RaceLogRevokeEvent;
 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.scoring.AdditionalScoringInformationEvent;
 import com.sap.sailing.domain.abstractlog.race.scoring.AdditionalScoringInformationType;
-import com.sap.sailing.domain.abstractlog.race.scoring.impl.AdditionalScoringInformationEventImpl;
-import com.sap.sailing.domain.abstractlog.race.tracking.CloseOpenEndedDeviceMappingEvent;
-import com.sap.sailing.domain.abstractlog.race.tracking.DefineMarkEvent;
-import com.sap.sailing.domain.abstractlog.race.tracking.DenoteForTrackingEvent;
-import com.sap.sailing.domain.abstractlog.race.tracking.DeviceCompetitorMappingEvent;
-import com.sap.sailing.domain.abstractlog.race.tracking.DeviceIdentifier;
-import com.sap.sailing.domain.abstractlog.race.tracking.DeviceMarkMappingEvent;
-import com.sap.sailing.domain.abstractlog.race.tracking.RegisterCompetitorEvent;
-import com.sap.sailing.domain.abstractlog.race.tracking.StartTrackingEvent;
-import com.sap.sailing.domain.abstractlog.race.tracking.events.CloseOpenEndedDeviceMappingEventImpl;
-import com.sap.sailing.domain.abstractlog.race.tracking.events.DefineMarkEventImpl;
-import com.sap.sailing.domain.abstractlog.race.tracking.events.DenoteForTrackingEventImpl;
-import com.sap.sailing.domain.abstractlog.race.tracking.events.DeviceCompetitorMappingEventImpl;
-import com.sap.sailing.domain.abstractlog.race.tracking.events.DeviceMarkMappingEventImpl;
-import com.sap.sailing.domain.abstractlog.race.tracking.events.RegisterCompetitorEventImpl;
-import com.sap.sailing.domain.abstractlog.race.tracking.events.StartTrackingEventImpl;
+import com.sap.sailing.domain.abstractlog.race.scoring.RaceLogAdditionalScoringInformationEvent;
+import com.sap.sailing.domain.abstractlog.race.scoring.impl.RaceLogAdditionalScoringInformationEventImpl;
+import com.sap.sailing.domain.abstractlog.race.tracking.RaceLogCloseOpenEndedDeviceMappingEvent;
+import com.sap.sailing.domain.abstractlog.race.tracking.RaceLogDefineMarkEvent;
+import com.sap.sailing.domain.abstractlog.race.tracking.RaceLogDenoteForTrackingEvent;
+import com.sap.sailing.domain.abstractlog.race.tracking.RaceLogDeviceCompetitorMappingEvent;
+import com.sap.sailing.domain.abstractlog.race.tracking.RaceLogDeviceMarkMappingEvent;
+import com.sap.sailing.domain.abstractlog.race.tracking.RaceLogRegisterCompetitorEvent;
+import com.sap.sailing.domain.abstractlog.race.tracking.RaceLogStartTrackingEvent;
+import com.sap.sailing.domain.abstractlog.race.tracking.impl.RaceLogCloseOpenEndedDeviceMappingEventImpl;
+import com.sap.sailing.domain.abstractlog.race.tracking.impl.RaceLogDefineMarkEventImpl;
+import com.sap.sailing.domain.abstractlog.race.tracking.impl.RaceLogDenoteForTrackingEventImpl;
+import com.sap.sailing.domain.abstractlog.race.tracking.impl.RaceLogDeviceCompetitorMappingEventImpl;
+import com.sap.sailing.domain.abstractlog.race.tracking.impl.RaceLogDeviceMarkMappingEventImpl;
+import com.sap.sailing.domain.abstractlog.race.tracking.impl.RaceLogRegisterCompetitorEventImpl;
+import com.sap.sailing.domain.abstractlog.race.tracking.impl.RaceLogStartTrackingEventImpl;
 import com.sap.sailing.domain.base.BoatClass;
 import com.sap.sailing.domain.base.Competitor;
 import com.sap.sailing.domain.base.CourseBase;
@@ -45,6 +44,7 @@ import com.sap.sailing.domain.base.Mark;
 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.racelogtracking.DeviceIdentifier;
 import com.sap.sailing.domain.tracking.Wind;
 import com.sap.sse.common.TimePoint;

@@ -131,28 +131,28 @@ public class RaceLogEventRestoreFactoryImpl extends RaceLogEventFactoryImpl impl
    }

    @Override
-    public DeviceCompetitorMappingEvent createDeviceCompetitorMappingEvent(TimePoint createdAt, AbstractLogEventAuthor author,
+    public RaceLogDeviceCompetitorMappingEvent createDeviceCompetitorMappingEvent(TimePoint createdAt, AbstractLogEventAuthor 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);
+        return new RaceLogDeviceCompetitorMappingEventImpl(createdAt, author, logicalTimePoint, pId, passId, mappedTo, device, from, to);
    }

    @Override
-    public DeviceMarkMappingEvent createDeviceMarkMappingEvent(TimePoint createdAt, AbstractLogEventAuthor author,
+    public RaceLogDeviceMarkMappingEvent createDeviceMarkMappingEvent(TimePoint createdAt, AbstractLogEventAuthor 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);
+        return new RaceLogDeviceMarkMappingEventImpl(createdAt, author, logicalTimePoint, pId, passId, mappedTo, device, from, to);
    }

    @Override
-    public DenoteForTrackingEvent createDenoteForTrackingEvent(TimePoint createdAt, AbstractLogEventAuthor author,
+    public RaceLogDenoteForTrackingEvent createDenoteForTrackingEvent(TimePoint createdAt, AbstractLogEventAuthor author,
            TimePoint logicalTimePoint, Serializable pId, int passId, String raceName, BoatClass boatClass, Serializable raceId) {
-        return new DenoteForTrackingEventImpl(createdAt, author, logicalTimePoint, pId, passId, raceName, boatClass, raceId);
+        return new RaceLogDenoteForTrackingEventImpl(createdAt, author, logicalTimePoint, pId, passId, raceName, boatClass, raceId);
    }

    @Override
-    public StartTrackingEvent createStartTrackingEvent(TimePoint createdAt, AbstractLogEventAuthor author, TimePoint logicalTimePoint,
+    public RaceLogStartTrackingEvent createStartTrackingEvent(TimePoint createdAt, AbstractLogEventAuthor author, TimePoint logicalTimePoint,
            Serializable pId, int passId) {
-        return new StartTrackingEventImpl(createdAt, author, logicalTimePoint, pId, passId);
+        return new RaceLogStartTrackingEventImpl(createdAt, author, logicalTimePoint, pId, passId);
    }

    @Override
@@ -162,29 +162,29 @@ public class RaceLogEventRestoreFactoryImpl extends RaceLogEventFactoryImpl impl
    }

    @Override
-    public RegisterCompetitorEvent createRegisterCompetitorEvent(TimePoint createdAt, AbstractLogEventAuthor author, TimePoint logicalTimePoint,
+    public RaceLogRegisterCompetitorEvent createRegisterCompetitorEvent(TimePoint createdAt, AbstractLogEventAuthor author, TimePoint logicalTimePoint,
            Serializable pId, int passId, Competitor competitor) {
-        return new RegisterCompetitorEventImpl(createdAt, author, logicalTimePoint, pId, passId, competitor);
+        return new RaceLogRegisterCompetitorEventImpl(createdAt, author, logicalTimePoint, pId, passId, competitor);
    }

    @Override
-    public DefineMarkEvent createDefineMarkEvent(TimePoint createdAt, AbstractLogEventAuthor author, TimePoint logicalTimePoint,
+    public RaceLogDefineMarkEvent createDefineMarkEvent(TimePoint createdAt, AbstractLogEventAuthor author, TimePoint logicalTimePoint,
            Serializable pId, int passId, Mark mark) {
-        return new DefineMarkEventImpl(createdAt, author, logicalTimePoint, pId, passId, mark);
+        return new RaceLogDefineMarkEventImpl(createdAt, author, logicalTimePoint, pId, passId, mark);
    }

    @Override
-    public CloseOpenEndedDeviceMappingEvent createCloseOpenEndedDeviceMappingEvent(TimePoint createdAt,
+    public RaceLogCloseOpenEndedDeviceMappingEvent createCloseOpenEndedDeviceMappingEvent(TimePoint createdAt,
            AbstractLogEventAuthor author, TimePoint logicalTimePoint, Serializable pId, int passId,
            Serializable deviceMappingEventId, TimePoint closingTimePoint) {
-        return new CloseOpenEndedDeviceMappingEventImpl(createdAt, author, logicalTimePoint, pId, passId,
+        return new RaceLogCloseOpenEndedDeviceMappingEventImpl(createdAt, author, logicalTimePoint, pId, passId,
                deviceMappingEventId, closingTimePoint);
    }

    @Override
-    public AdditionalScoringInformationEvent createAdditionalScoringInformationEvent(TimePoint createdAt,
+    public RaceLogAdditionalScoringInformationEvent createAdditionalScoringInformationEvent(TimePoint createdAt,
            AbstractLogEventAuthor author, TimePoint logicalTimePoint, Serializable pId, List<Competitor> competitors, int passId,
            AdditionalScoringInformationType informationType) {
-        return new AdditionalScoringInformationEventImpl(createdAt, author, logicalTimePoint, pId, competitors, passId, informationType);
+        return new RaceLogAdditionalScoringInformationEventImpl(createdAt, author, logicalTimePoint, pId, competitors, passId, informationType);
    }
 }
@@ -1,46 +1,51 @@
 package com.sap.sailing.domain.abstractlog.race.impl;

 import java.io.Serializable;
-import java.util.Collections;
 import java.util.List;

 import com.sap.sailing.domain.abstractlog.AbstractLogEventAuthor;
 import com.sap.sailing.domain.abstractlog.impl.RevokeEventImpl;
 import com.sap.sailing.domain.abstractlog.race.RaceLogEvent;
+import com.sap.sailing.domain.abstractlog.race.RaceLogEventData;
 import com.sap.sailing.domain.abstractlog.race.RaceLogEventVisitor;
 import com.sap.sailing.domain.abstractlog.race.RaceLogRevokeEvent;
 import com.sap.sailing.domain.base.Competitor;
 import com.sap.sse.common.TimePoint;

 public class RaceLogRevokeEventImpl extends RevokeEventImpl<RaceLogEventVisitor> implements RaceLogRevokeEvent {
-    private final int passId;
+    private static final long serialVersionUID = 1886722815573499311L;
+    private final RaceLogEventData raceLogEventData;
    
    public RaceLogRevokeEventImpl(AbstractLogEventAuthor author, int passId, RaceLogEvent toRevoke, String reason) {
        super(author, toRevoke, reason);
-        this.passId = passId;
+        this.raceLogEventData = new RaceLogEventDataImpl(null, passId);
    }
    
    public RaceLogRevokeEventImpl(TimePoint createdAt, AbstractLogEventAuthor author, TimePoint logicalTimePoint,
            Serializable pId, int passId, Serializable revokedEventId, String revokedEventType, String revokedEventShortInfo,
            String reason) {
        super(createdAt, author, logicalTimePoint, pId, revokedEventId, revokedEventType, revokedEventShortInfo, reason);
-        this.passId = passId; 
+        this.raceLogEventData = new RaceLogEventDataImpl(null, passId);
    }

-    private static final long serialVersionUID = 1886722815573499311L;

    @Override
    public int getPassId() {
-        return passId;
+        return raceLogEventData.getPassId();
    }

    @Override
    public List<Competitor> getInvolvedBoats() {
-        return Collections.emptyList();
+        return raceLogEventData.getInvolvedBoats();
    }

    @Override
    public void accept(RaceLogEventVisitor visitor) {
        visitor.visit(this);
    }
+    
+    @Override
+    public String toString() {
+        return raceLogEventData.toString(); 
+    }
 }
@@ -12,7 +12,7 @@ import com.sap.sailing.domain.abstractlog.race.RaceLogEvent;
 * 
 * @author Simon Marcel Pamies
 */
-public interface AdditionalScoringInformationEvent extends RaceLogEvent, Revokable, InvalidatesLeaderboardCache {
+public interface RaceLogAdditionalScoringInformationEvent extends RaceLogEvent, Revokable, InvalidatesLeaderboardCache {
    
    /**
     * @return the type of information this event holds
@@ -6,17 +6,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.impl.RaceLogEventImpl;
-import com.sap.sailing.domain.abstractlog.race.scoring.AdditionalScoringInformationEvent;
+import com.sap.sailing.domain.abstractlog.race.scoring.RaceLogAdditionalScoringInformationEvent;
 import com.sap.sailing.domain.abstractlog.race.scoring.AdditionalScoringInformationType;
 import com.sap.sailing.domain.base.Competitor;
 import com.sap.sse.common.TimePoint;

-public class AdditionalScoringInformationEventImpl extends RaceLogEventImpl implements AdditionalScoringInformationEvent {
+public class RaceLogAdditionalScoringInformationEventImpl extends RaceLogEventImpl implements RaceLogAdditionalScoringInformationEvent {
    private static final long serialVersionUID = -7627714111951381979L;
    
    private final AdditionalScoringInformationType informationType;
    
-    public AdditionalScoringInformationEventImpl(TimePoint createdAt, AbstractLogEventAuthor author, TimePoint logicalTimePoint,
+    public RaceLogAdditionalScoringInformationEventImpl(TimePoint createdAt, AbstractLogEventAuthor author, TimePoint logicalTimePoint,
            Serializable pId, List<Competitor> competitors, int pPassId, AdditionalScoringInformationType informationType) {
        super(createdAt, author, logicalTimePoint, pId, competitors, pPassId);
        this.informationType = informationType;
@@ -4,7 +4,7 @@ import com.sap.sailing.domain.abstractlog.AbstractLogEventAuthor;
 import com.sap.sailing.domain.abstractlog.race.CompetitorResults;
 import com.sap.sailing.domain.abstractlog.race.RaceLog;
 import com.sap.sailing.domain.abstractlog.race.RaceLogEvent;
-import com.sap.sailing.domain.abstractlog.race.scoring.AdditionalScoringInformationEvent;
+import com.sap.sailing.domain.abstractlog.race.scoring.RaceLogAdditionalScoringInformationEvent;
 import com.sap.sailing.domain.abstractlog.race.scoring.AdditionalScoringInformationType;
 import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.RacingProcedure;
 import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.RacingProcedurePrerequisite;
@@ -142,7 +142,7 @@ public interface RaceState extends ReadonlyRaceState {
    void setWindFix(TimePoint now, Wind wind);
    
    /**
-     * Marks this race state with a new {@link AdditionalScoringInformationEvent} or revokes
+     * Marks this race state with a new {@link RaceLogAdditionalScoringInformationEvent} or revokes
     * an already existing one.
     */
    void setAdditionalScoringInformationEnabled(TimePoint creationTimePoint, boolean enable, AdditionalScoringInformationType informationType);
@@ -10,7 +10,7 @@ import com.sap.sailing.domain.abstractlog.race.RaceLog;
 import com.sap.sailing.domain.abstractlog.race.RaceLogEventFactory;
 import com.sap.sailing.domain.abstractlog.race.analyzing.impl.AdditionalScoringInformationFinder;
 import com.sap.sailing.domain.abstractlog.race.analyzing.impl.RaceStatusAnalyzer;
-import com.sap.sailing.domain.abstractlog.race.scoring.AdditionalScoringInformationEvent;
+import com.sap.sailing.domain.abstractlog.race.scoring.RaceLogAdditionalScoringInformationEvent;
 import com.sap.sailing.domain.abstractlog.race.scoring.AdditionalScoringInformationType;
 import com.sap.sailing.domain.abstractlog.race.state.RaceState;
 import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.RacingProcedure;
@@ -169,7 +169,7 @@ public class RaceStateImpl extends ReadonlyRaceStateImpl implements RaceState {

    @Override
    public void setAdditionalScoringInformationEnabled(TimePoint timePoint, boolean enable, AdditionalScoringInformationType informationType) {
-        final AdditionalScoringInformationEvent event = new AdditionalScoringInformationFinder(raceLog).analyze(/*filterBy*/informationType);
+        final RaceLogAdditionalScoringInformationEvent event = new AdditionalScoringInformationFinder(raceLog).analyze(/*filterBy*/informationType);
        if (enable) {
            if (event == null) {
                raceLog.add(factory.createAdditionalScoringInformationEvent(timePoint, UUID.randomUUID(), author, raceLog.getCurrentPassId(), informationType));
@@ -188,7 +188,7 @@ public class RaceStateImpl extends ReadonlyRaceStateImpl implements RaceState {
    
    @Override
    public boolean isAdditionalScoringInformationEnabled(AdditionalScoringInformationType informationType) {
-        final AdditionalScoringInformationEvent event = new AdditionalScoringInformationFinder(raceLog).analyze(/*filterBy*/informationType);
+        final RaceLogAdditionalScoringInformationEvent event = new AdditionalScoringInformationFinder(raceLog).analyze(/*filterBy*/informationType);
        return event != null;
    }

@@ -1,7 +0,0 @@
-package com.sap.sailing.domain.abstractlog.race.tracking;
-
-import com.sap.sailing.domain.base.Competitor;
-
-public interface DeviceCompetitorMappingEvent extends DeviceMappingEvent<Competitor> {
-
-}
@@ -1,7 +0,0 @@
-package com.sap.sailing.domain.abstractlog.race.tracking;
-
-import com.sap.sailing.domain.base.Mark;
-
-public interface DeviceMarkMappingEvent extends DeviceMappingEvent<Mark> {
-
-}
@@ -0,0 +1,10 @@
+package com.sap.sailing.domain.abstractlog.race.tracking;
+
+import com.sap.sailing.domain.abstractlog.race.RaceLogEvent;
+import com.sap.sailing.domain.abstractlog.race.RaceLogEventVisitor;
+import com.sap.sailing.domain.abstractlog.shared.events.CloseOpenEndedDeviceMappingEvent;
+
+public interface RaceLogCloseOpenEndedDeviceMappingEvent extends RaceLogEvent,
+CloseOpenEndedDeviceMappingEvent<RaceLogEventVisitor> {
+
+}
@@ -9,6 +9,6 @@ import com.sap.sailing.domain.base.Mark;
 * @author Fredrik Teschke
 *
 */
-public interface DefineMarkEvent extends RaceLogEvent, Revokable {
+public interface RaceLogDefineMarkEvent extends RaceLogEvent, Revokable {
    Mark getMark();
 }
@@ -5,6 +5,7 @@ import java.io.Serializable;
 import com.sap.sailing.domain.abstractlog.Revokable;
 import com.sap.sailing.domain.abstractlog.race.RaceLog;
 import com.sap.sailing.domain.abstractlog.race.RaceLogEvent;
+import com.sap.sailing.domain.abstractlog.shared.events.DeviceMappingEvent;
 import com.sap.sailing.domain.base.BoatClass;

 /**
@@ -16,7 +17,7 @@ import com.sap.sailing.domain.base.BoatClass;
 * @author Fredrik Teschke
 *
 */
-public interface DenoteForTrackingEvent extends RaceLogEvent, Revokable {
+public interface RaceLogDenoteForTrackingEvent extends RaceLogEvent, Revokable {
    String getRaceName();
    BoatClass getBoatClass();
    Serializable getRaceId();
@@ -0,0 +1,10 @@
+package com.sap.sailing.domain.abstractlog.race.tracking;
+
+import com.sap.sailing.domain.abstractlog.race.RaceLogEvent;
+import com.sap.sailing.domain.abstractlog.race.RaceLogEventVisitor;
+import com.sap.sailing.domain.abstractlog.shared.events.DeviceCompetitorMappingEvent;
+
+public interface RaceLogDeviceCompetitorMappingEvent extends RaceLogEvent,
+DeviceCompetitorMappingEvent<RaceLogEventVisitor> {
+
+}
@@ -0,0 +1,10 @@
+package com.sap.sailing.domain.abstractlog.race.tracking;
+
+import com.sap.sailing.domain.abstractlog.race.RaceLogEvent;
+import com.sap.sailing.domain.abstractlog.race.RaceLogEventVisitor;
+import com.sap.sailing.domain.abstractlog.shared.events.DeviceMarkMappingEvent;
+
+public interface RaceLogDeviceMarkMappingEvent extends RaceLogEvent,
+DeviceMarkMappingEvent<RaceLogEventVisitor> {
+
+}
@@ -0,0 +1,10 @@
+package com.sap.sailing.domain.abstractlog.race.tracking;
+
+import com.sap.sailing.domain.abstractlog.race.RaceLogEvent;
+import com.sap.sailing.domain.abstractlog.race.RaceLogEventVisitor;
+import com.sap.sailing.domain.abstractlog.shared.events.RegisterCompetitorEvent;
+
+public interface RaceLogRegisterCompetitorEvent extends RaceLogEvent,
+RegisterCompetitorEvent<RaceLogEventVisitor> {
+
+}
@@ -3,15 +3,15 @@ package com.sap.sailing.domain.abstractlog.race.tracking;
 import com.sap.sailing.domain.abstractlog.Revokable;
 import com.sap.sailing.domain.abstractlog.race.RaceLog;
 import com.sap.sailing.domain.abstractlog.race.RaceLogEvent;
-import com.sap.sailing.domain.abstractlog.race.tracking.events.DeviceCompetitorMappingEventImpl;
+import com.sap.sailing.domain.abstractlog.race.tracking.impl.RaceLogDeviceCompetitorMappingEventImpl;

 /**
- * Closes the phase during which {@link DeviceCompetitorMappingEventImpl}s actually result
+ * Closes the phase during which {@link RaceLogDeviceCompetitorMappingEventImpl}s actually result
 * in competitors being added, and indicates that the server should create a {@link TrackedRace}
 * using the information in this {@link RaceLog}.
 * 
 * @author Fredrik Teschke
 *
 */
-public interface StartTrackingEvent extends RaceLogEvent, Revokable {
+public interface RaceLogStartTrackingEvent extends RaceLogEvent, Revokable {
 }
@@ -7,7 +7,7 @@ import java.util.List;
 import com.sap.sailing.domain.abstractlog.race.RaceLog;
 import com.sap.sailing.domain.abstractlog.race.RaceLogEvent;
 import com.sap.sailing.domain.abstractlog.race.analyzing.impl.RaceLogAnalyzer;
-import com.sap.sailing.domain.abstractlog.race.tracking.DefineMarkEvent;
+import com.sap.sailing.domain.abstractlog.race.tracking.RaceLogDefineMarkEvent;
 import com.sap.sailing.domain.base.Mark;

 public class DefinedMarkFinder extends RaceLogAnalyzer<Collection<Mark>> {
@@ -19,8 +19,8 @@ public class DefinedMarkFinder extends RaceLogAnalyzer<Collection<Mark>> {
    protected Collection<Mark> performAnalysis() {
        List< Mark> result = new ArrayList<Mark>();
        for (RaceLogEvent event : getLog().getUnrevokedEvents()) {
-            if (event instanceof DefineMarkEvent) {
-                DefineMarkEvent dME = (DefineMarkEvent) event;
+            if (event instanceof RaceLogDefineMarkEvent) {
+                RaceLogDefineMarkEvent dME = (RaceLogDefineMarkEvent) event;
                result.add(dME.getMark());
            }
        }
@@ -1,18 +0,0 @@
-package com.sap.sailing.domain.abstractlog.race.tracking.analyzing.impl;
-
-import com.sap.sailing.domain.abstractlog.race.RaceLog;
-import com.sap.sailing.domain.abstractlog.race.tracking.DeviceCompetitorMappingEvent;
-import com.sap.sailing.domain.abstractlog.race.tracking.DeviceMappingEvent;
-import com.sap.sailing.domain.base.Competitor;
-
-public class DeviceCompetitorMappingFinder extends DeviceMappingFinder<Competitor> {
-
-    public DeviceCompetitorMappingFinder(RaceLog raceLog) {
-        super(raceLog);
-    }
-
-    @Override
-    protected boolean isValidMapping(DeviceMappingEvent<?> mapping) {
-        return mapping instanceof DeviceCompetitorMappingEvent;
-    }
-}
@@ -1,18 +0,0 @@
-package com.sap.sailing.domain.abstractlog.race.tracking.analyzing.impl;
-
-import com.sap.sailing.domain.abstractlog.race.RaceLog;
-import com.sap.sailing.domain.abstractlog.race.tracking.DeviceMappingEvent;
-import com.sap.sailing.domain.abstractlog.race.tracking.DeviceMarkMappingEvent;
-import com.sap.sailing.domain.base.Mark;
-
-public class DeviceMarkMappingFinder extends DeviceMappingFinder<Mark> {
-
-    public DeviceMarkMappingFinder(RaceLog raceLog) {
-        super(raceLog);
-    }
-
-    @Override
-    protected boolean isValidMapping(DeviceMappingEvent<?> mapping) {
-        return mapping instanceof DeviceMarkMappingEvent;
-    }
-}
@@ -1,33 +0,0 @@
-package com.sap.sailing.domain.abstractlog.race.tracking.analyzing.impl;
-
-import com.sap.sailing.domain.abstractlog.race.RaceLog;
-import com.sap.sailing.domain.abstractlog.race.RaceLogEvent;
-import com.sap.sailing.domain.abstractlog.race.analyzing.impl.RaceLogAnalyzer;
-import com.sap.sailing.domain.abstractlog.race.tracking.DeviceMappingEvent;
-import com.sap.sse.common.WithID;
-
-public class LastPingMappingEventFinder<T extends WithID> extends RaceLogAnalyzer<DeviceMappingEvent<T>> {
-    private final WithID item;
-    
-    public LastPingMappingEventFinder(RaceLog raceLog, WithID forItem) {
-        super(raceLog);
-        this.item = forItem;
-    }
-
-    @Override
-    protected DeviceMappingEvent<T> performAnalysis() {
-        for (RaceLogEvent e : getLog().getUnrevokedEventsDescending()) {
-            if (e instanceof DeviceMappingEvent) {
-                DeviceMappingEvent<?> mappingEvent = (DeviceMappingEvent<?>) e;
-                if (item.equals(mappingEvent.getMappedTo()) && mappingEvent.getFrom() != null &&
-                        mappingEvent.getTo() != null && mappingEvent.getFrom().equals(mappingEvent.getTo())) {
-                    @SuppressWarnings("unchecked")
-                    DeviceMappingEvent<T> cast = (DeviceMappingEvent<T>) mappingEvent;
-                    return cast;
-                }
-            }
-        }
-        return null;
-    }
-
-}
@@ -1,49 +0,0 @@
-package com.sap.sailing.domain.abstractlog.race.tracking.analyzing.impl;
-
-import java.io.Serializable;
-import java.util.ArrayList;
-import java.util.List;
-
-import com.sap.sailing.domain.abstractlog.AbstractLogEventAuthor;
-import com.sap.sailing.domain.abstractlog.race.RaceLog;
-import com.sap.sailing.domain.abstractlog.race.RaceLogEventFactory;
-import com.sap.sailing.domain.abstractlog.race.analyzing.impl.RaceLogAnalyzer;
-import com.sap.sailing.domain.abstractlog.race.tracking.CloseOpenEndedDeviceMappingEvent;
-import com.sap.sailing.domain.abstractlog.race.tracking.DeviceMapping;
-import com.sap.sailing.domain.abstractlog.race.tracking.DeviceMappingEvent;
-import com.sap.sse.common.TimePoint;
-import com.sap.sse.common.impl.MillisecondsTimePoint;
-
-/**
- * Generates events that close the events that are responsible for the {@link #mapping}
- * that is passed to the constructor.
- * @author Fredrik Teschke
- *
- */
-public class OpenEndedDeviceMappingCloser extends RaceLogAnalyzer<List<CloseOpenEndedDeviceMappingEvent>> {
-    private final DeviceMapping<?> mapping;
-    private final AbstractLogEventAuthor author;
-    private final TimePoint closingTimePoint;
-
-    public OpenEndedDeviceMappingCloser(RaceLog raceLog, DeviceMapping<?> mapping, AbstractLogEventAuthor author,
-            TimePoint closingTimePoint) {
-        super(raceLog);
-        this.mapping = mapping;
-        this.author = author;
-        this.closingTimePoint = closingTimePoint;
-    }
-
-    @Override
-    protected List<CloseOpenEndedDeviceMappingEvent> performAnalysis() {
-        List<CloseOpenEndedDeviceMappingEvent> result = new ArrayList<CloseOpenEndedDeviceMappingEvent>();
-
-        for (Serializable eventId : mapping.getOriginalRaceLogEventIds()) {
-            DeviceMappingEvent<?> event = (DeviceMappingEvent<?>) getLog().getEventById(eventId);
-            if (event.getFrom() == null || event.getTo() == null) {
-                result.add(RaceLogEventFactory.INSTANCE.createCloseOpenEndedDeviceMappingEvent(
-                        MillisecondsTimePoint.now(), author, getLog().getCurrentPassId(), event.getId(), closingTimePoint));
-            }
-        }
-        return result;
-    }
-}
@@ -3,18 +3,18 @@ package com.sap.sailing.domain.abstractlog.race.tracking.analyzing.impl;
 import com.sap.sailing.domain.abstractlog.race.RaceLog;
 import com.sap.sailing.domain.abstractlog.race.RaceLogEvent;
 import com.sap.sailing.domain.abstractlog.race.analyzing.impl.RaceLogAnalyzer;
-import com.sap.sailing.domain.abstractlog.race.tracking.DenoteForTrackingEvent;
+import com.sap.sailing.domain.abstractlog.race.tracking.RaceLogDenoteForTrackingEvent;

-public class RaceInformationFinder extends RaceLogAnalyzer<DenoteForTrackingEvent> {
+public class RaceInformationFinder extends RaceLogAnalyzer<RaceLogDenoteForTrackingEvent> {
    public RaceInformationFinder(RaceLog raceLog) {
        super(raceLog);
    }

    @Override
-    protected DenoteForTrackingEvent performAnalysis() {
+    protected RaceLogDenoteForTrackingEvent performAnalysis() {
        for (RaceLogEvent event : getAllEvents()) {
-            if (event instanceof DenoteForTrackingEvent) {
-                return (DenoteForTrackingEvent) event;
+            if (event instanceof RaceLogDenoteForTrackingEvent) {
+                return (RaceLogDenoteForTrackingEvent) event;
            }
        }

@@ -0,0 +1,15 @@
+package com.sap.sailing.domain.abstractlog.race.tracking.analyzing.impl;
+
+import com.sap.sailing.domain.abstractlog.race.RaceLog;
+import com.sap.sailing.domain.abstractlog.race.RaceLogEvent;
+import com.sap.sailing.domain.abstractlog.race.RaceLogEventVisitor;
+import com.sap.sailing.domain.abstractlog.shared.analyzing.DeviceCompetitorMappingFinder;
+
+public class RaceLogDeviceCompetitorMappingFinder
+extends DeviceCompetitorMappingFinder<RaceLog, RaceLogEvent, RaceLogEventVisitor> {
+
+    public RaceLogDeviceCompetitorMappingFinder(RaceLog log) {
+        super(log);
+    }
+
+}
@@ -0,0 +1,16 @@
+package com.sap.sailing.domain.abstractlog.race.tracking.analyzing.impl;
+
+import com.sap.sailing.domain.abstractlog.race.RaceLog;
+import com.sap.sailing.domain.abstractlog.race.RaceLogEvent;
+import com.sap.sailing.domain.abstractlog.race.RaceLogEventVisitor;
+import com.sap.sailing.domain.abstractlog.shared.analyzing.DeviceMappingFinder;
+import com.sap.sse.common.WithID;
+
+public class RaceLogDeviceMappingFinder<ItemT extends WithID>
+extends DeviceMappingFinder<RaceLog, RaceLogEvent, RaceLogEventVisitor, ItemT> {
+
+    public RaceLogDeviceMappingFinder(RaceLog log) {
+        super(log);
+    }
+
+}
@@ -0,0 +1,15 @@
+package com.sap.sailing.domain.abstractlog.race.tracking.analyzing.impl;
+
+import com.sap.sailing.domain.abstractlog.race.RaceLog;
+import com.sap.sailing.domain.abstractlog.race.RaceLogEvent;
+import com.sap.sailing.domain.abstractlog.race.RaceLogEventVisitor;
+import com.sap.sailing.domain.abstractlog.shared.analyzing.DeviceMarkMappingFinder;
+
+public class RaceLogDeviceMarkMappingFinder
+extends DeviceMarkMappingFinder<RaceLog, RaceLogEvent, RaceLogEventVisitor> {
+
+    public RaceLogDeviceMarkMappingFinder(RaceLog log) {
+        super(log);
+    }
+
+}
@@ -0,0 +1,16 @@
+package com.sap.sailing.domain.abstractlog.race.tracking.analyzing.impl;
+
+import com.sap.sailing.domain.abstractlog.race.RaceLog;
+import com.sap.sailing.domain.abstractlog.race.RaceLogEvent;
+import com.sap.sailing.domain.abstractlog.race.RaceLogEventVisitor;
+import com.sap.sailing.domain.abstractlog.shared.analyzing.LastPingMappingEventFinder;
+import com.sap.sse.common.WithID;
+
+public class RaceLogLastPingMappingEventFinder<ItemT extends WithID>
+extends LastPingMappingEventFinder<RaceLog, RaceLogEvent, RaceLogEventVisitor, ItemT> {
+
+    public RaceLogLastPingMappingEventFinder(RaceLog log, WithID forItem) {
+        super(log, forItem);
+    }
+
+}
@@ -0,0 +1,30 @@
+package com.sap.sailing.domain.abstractlog.race.tracking.analyzing.impl;
+
+import java.io.Serializable;
+
+import com.sap.sailing.domain.abstractlog.AbstractLogEventAuthor;
+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.RaceLogEventVisitor;
+import com.sap.sailing.domain.abstractlog.race.tracking.RaceLogCloseOpenEndedDeviceMappingEvent;
+import com.sap.sailing.domain.abstractlog.shared.analyzing.OpenEndedDeviceMappingCloser;
+import com.sap.sailing.domain.racelogtracking.DeviceMapping;
+import com.sap.sse.common.TimePoint;
+
+public class RaceLogOpenEndedDeviceMappingCloser extends
+        OpenEndedDeviceMappingCloser<RaceLog, RaceLogEvent, RaceLogEventVisitor, RaceLogCloseOpenEndedDeviceMappingEvent> {
+
+    public RaceLogOpenEndedDeviceMappingCloser(RaceLog log, DeviceMapping<?> mapping, AbstractLogEventAuthor author,
+            TimePoint closingTimePoint) {
+        super(log, mapping, author, closingTimePoint);
+    }
+
+    @Override
+    protected RaceLogCloseOpenEndedDeviceMappingEvent createCloseEvent(TimePoint logicalTimePoint,
+            Serializable eventToCloseId) {
+        return RaceLogEventFactory.INSTANCE.createCloseOpenEndedDeviceMappingEvent(
+                logicalTimePoint, author, getLog().getCurrentPassId(), eventToCloseId, closingTimePoint);
+    }
+
+}
@@ -3,8 +3,8 @@ package com.sap.sailing.domain.abstractlog.race.tracking.analyzing.impl;
 import com.sap.sailing.domain.abstractlog.race.RaceLog;
 import com.sap.sailing.domain.abstractlog.race.RaceLogEvent;
 import com.sap.sailing.domain.abstractlog.race.analyzing.impl.RaceLogAnalyzer;
-import com.sap.sailing.domain.abstractlog.race.tracking.DenoteForTrackingEvent;
-import com.sap.sailing.domain.abstractlog.race.tracking.StartTrackingEvent;
+import com.sap.sailing.domain.abstractlog.race.tracking.RaceLogDenoteForTrackingEvent;
+import com.sap.sailing.domain.abstractlog.race.tracking.RaceLogStartTrackingEvent;
 import com.sap.sailing.domain.common.racelog.tracking.RaceLogTrackingState;

 public class RaceLogTrackingStateAnalyzer extends RaceLogAnalyzer<RaceLogTrackingState> {
@@ -16,9 +16,9 @@ public class RaceLogTrackingStateAnalyzer extends RaceLogAnalyzer<RaceLogTrackin
    @Override
    protected RaceLogTrackingState performAnalysis() {
        for (RaceLogEvent event : getLog().getUnrevokedEventsDescending()) {
-            if (event instanceof StartTrackingEvent) {
+            if (event instanceof RaceLogStartTrackingEvent) {
                return RaceLogTrackingState.TRACKING;
-            } else if (event instanceof DenoteForTrackingEvent) {
+            } else if (event instanceof RaceLogDenoteForTrackingEvent) {
                return RaceLogTrackingState.AWAITING_RACE_DEFINITION;
            }
        }
@@ -1,42 +0,0 @@
-package com.sap.sailing.domain.abstractlog.race.tracking.events;
-
-import java.io.Serializable;
-import java.util.Collections;
-
-import com.sap.sailing.domain.abstractlog.AbstractLogEventAuthor;
-import com.sap.sailing.domain.abstractlog.race.RaceLogEventVisitor;
-import com.sap.sailing.domain.abstractlog.race.impl.RaceLogEventImpl;
-import com.sap.sailing.domain.abstractlog.race.tracking.CloseOpenEndedDeviceMappingEvent;
-import com.sap.sailing.domain.base.Competitor;
-import com.sap.sse.common.TimePoint;
-
-public class CloseOpenEndedDeviceMappingEventImpl extends RaceLogEventImpl implements CloseOpenEndedDeviceMappingEvent {
-    private static final long serialVersionUID = -2401732623610224918L;
-    
-    private final Serializable deviceMappingEventId;
-    private final TimePoint closingTimePoint;
-
-    public CloseOpenEndedDeviceMappingEventImpl(TimePoint createdAt, AbstractLogEventAuthor author,
-            TimePoint logicalTimePoint, Serializable pId, int pPassId,
-            Serializable deviceMappingEventId, TimePoint closingTimePoint) {
-        super(createdAt, author, logicalTimePoint, pId, Collections.<Competitor>emptyList(), pPassId);
-        this.deviceMappingEventId = deviceMappingEventId;
-        this.closingTimePoint = closingTimePoint;
-    }
-
-    @Override
-    public void accept(RaceLogEventVisitor visitor) {
-        visitor.visit(this);
-    }
-
-    @Override
-    public Serializable getDeviceMappingEventId() {
-        return deviceMappingEventId;
-    }
-
-    @Override
-    public TimePoint getClosingTimePoint() {
-        return closingTimePoint;
-    }
-
-}
@@ -1,25 +0,0 @@
-package com.sap.sailing.domain.abstractlog.race.tracking.events;
-
-import java.io.Serializable;
-
-import com.sap.sailing.domain.abstractlog.AbstractLogEventAuthor;
-import com.sap.sailing.domain.abstractlog.race.RaceLogEventVisitor;
-import com.sap.sailing.domain.abstractlog.race.tracking.DeviceIdentifier;
-import com.sap.sailing.domain.abstractlog.race.tracking.DeviceMarkMappingEvent;
-import com.sap.sailing.domain.base.Mark;
-import com.sap.sse.common.TimePoint;
-
-public class DeviceMarkMappingEventImpl extends AbstractDeviceMappingEventImpl<Mark>
-implements DeviceMarkMappingEvent {
-    public DeviceMarkMappingEventImpl(TimePoint createdAt, AbstractLogEventAuthor author, TimePoint logicalTimePoint,
-            Serializable pId, int pPassId, Mark mappedTo, DeviceIdentifier device, TimePoint from, TimePoint to) {
-        super(createdAt, author, logicalTimePoint, pId, pPassId, mappedTo, device, from, to);
-    }
-
-    private static final long serialVersionUID = -1494030544804758753L;
-
-    @Override
-    public void accept(RaceLogEventVisitor visitor) {
-        visitor.visit(this);
-    }
-}
@@ -1,35 +0,0 @@
-package com.sap.sailing.domain.abstractlog.race.tracking.events;
-
-import java.io.Serializable;
-import java.util.Collections;
-
-import com.sap.sailing.domain.abstractlog.AbstractLogEventAuthor;
-import com.sap.sailing.domain.abstractlog.race.RaceLogEventVisitor;
-import com.sap.sailing.domain.abstractlog.race.impl.RaceLogEventImpl;
-import com.sap.sailing.domain.abstractlog.race.tracking.RegisterCompetitorEvent;
-import com.sap.sailing.domain.base.Competitor;
-import com.sap.sse.common.TimePoint;
-
-public class RegisterCompetitorEventImpl extends RaceLogEventImpl implements RegisterCompetitorEvent {
-    private static final long serialVersionUID = -30864810737555657L;
-    
-    public RegisterCompetitorEventImpl(TimePoint createdAt, AbstractLogEventAuthor author, TimePoint logicalTimePoint,
-            Serializable pId, int pPassId, Competitor competitor) {
-        super(createdAt, author, logicalTimePoint, pId, Collections.singletonList(competitor), pPassId);
-    }
-
-    @Override
-    public void accept(RaceLogEventVisitor visitor) {
-        visitor.visit(this);
-    }
-
-    @Override
-    public Competitor getCompetitor() {
-        return getInvolvedBoats().get(0);
-    } 
-
-    @Override
-    public String getShortInfo() {
-        return "competitor: " + getCompetitor().toString();
-    }
-}
@@ -0,0 +1,43 @@
+package com.sap.sailing.domain.abstractlog.race.tracking.impl;
+
+import java.io.Serializable;
+import java.util.List;
+
+import com.sap.sailing.domain.abstractlog.AbstractLogEventAuthor;
+import com.sap.sailing.domain.abstractlog.race.RaceLogEvent;
+import com.sap.sailing.domain.abstractlog.race.RaceLogEventData;
+import com.sap.sailing.domain.abstractlog.race.RaceLogEventVisitor;
+import com.sap.sailing.domain.abstractlog.race.impl.RaceLogEventDataImpl;
+import com.sap.sailing.domain.abstractlog.shared.events.impl.AbstractDeviceMappingEventImpl;
+import com.sap.sailing.domain.base.Competitor;
+import com.sap.sailing.domain.racelogtracking.DeviceIdentifier;
+import com.sap.sse.common.TimePoint;
+import com.sap.sse.common.WithID;
+
+public abstract class AbstractRaceLogDeviceMappingEventImpl<ItemT extends WithID>
+extends AbstractDeviceMappingEventImpl<RaceLogEventVisitor, ItemT> implements RaceLogEvent {
+    private static final long serialVersionUID = -5114645637316367845L;
+    private final RaceLogEventData raceLogEventData;
+    
+    public AbstractRaceLogDeviceMappingEventImpl(TimePoint createdAt, AbstractLogEventAuthor author,
+            TimePoint logicalTimePoint, Serializable id, int passId, ItemT mappedTo, DeviceIdentifier device,
+            TimePoint from, TimePoint to) {
+        super(createdAt, author, logicalTimePoint, id, mappedTo, device, from, to);
+        this.raceLogEventData = new RaceLogEventDataImpl(null, passId);
+    }
+    
+    @Override
+    public int getPassId() {
+        return raceLogEventData.getPassId();
+    }
+
+    @Override
+    public List<Competitor> getInvolvedBoats() {
+        return raceLogEventData.getInvolvedBoats();
+    }
+
+    @Override
+    public String toString() {
+        return raceLogEventData.toString();
+    }
+}
@@ -0,0 +1,46 @@
+package com.sap.sailing.domain.abstractlog.race.tracking.impl;
+
+import java.io.Serializable;
+import java.util.List;
+
+import com.sap.sailing.domain.abstractlog.AbstractLogEventAuthor;
+import com.sap.sailing.domain.abstractlog.race.RaceLogEventData;
+import com.sap.sailing.domain.abstractlog.race.RaceLogEventVisitor;
+import com.sap.sailing.domain.abstractlog.race.impl.RaceLogEventDataImpl;
+import com.sap.sailing.domain.abstractlog.race.tracking.RaceLogCloseOpenEndedDeviceMappingEvent;
+import com.sap.sailing.domain.abstractlog.shared.events.impl.BaseCloseOpenEndedDeviceMappingEventImpl;
+import com.sap.sailing.domain.base.Competitor;
+import com.sap.sse.common.TimePoint;
+
+public class RaceLogCloseOpenEndedDeviceMappingEventImpl extends BaseCloseOpenEndedDeviceMappingEventImpl<RaceLogEventVisitor>
+implements RaceLogCloseOpenEndedDeviceMappingEvent {
+    private static final long serialVersionUID = -5114645637316367845L;
+    private final RaceLogEventData raceLogEventData;
+    
+    public RaceLogCloseOpenEndedDeviceMappingEventImpl(TimePoint createdAt, AbstractLogEventAuthor author,
+            TimePoint logicalTimePoint, Serializable id, int passId, Serializable deviceMappingEventId,
+            TimePoint closingTimePoint) {
+        super(createdAt, author, logicalTimePoint, id, deviceMappingEventId, closingTimePoint);
+        this.raceLogEventData = new RaceLogEventDataImpl(null, passId);
+    }
+    
+    @Override
+    public int getPassId() {
+        return raceLogEventData.getPassId();
+    }
+
+    @Override
+    public List<Competitor> getInvolvedBoats() {
+        return raceLogEventData.getInvolvedBoats();
+    }
+
+    @Override
+    public String toString() {
+        return raceLogEventData.toString();
+    }
+
+    @Override
+    public void accept(RaceLogEventVisitor visitor) {
+        visitor.visit(this);
+    }
+}
@@ -1,4 +1,4 @@
-package com.sap.sailing.domain.abstractlog.race.tracking.events;
+package com.sap.sailing.domain.abstractlog.race.tracking.impl;

 import java.io.Serializable;
 import java.util.Collections;
@@ -6,17 +6,17 @@ import java.util.Collections;
 import com.sap.sailing.domain.abstractlog.AbstractLogEventAuthor;
 import com.sap.sailing.domain.abstractlog.race.RaceLogEventVisitor;
 import com.sap.sailing.domain.abstractlog.race.impl.RaceLogEventImpl;
-import com.sap.sailing.domain.abstractlog.race.tracking.DefineMarkEvent;
+import com.sap.sailing.domain.abstractlog.race.tracking.RaceLogDefineMarkEvent;
 import com.sap.sailing.domain.base.Competitor;
 import com.sap.sailing.domain.base.Mark;
 import com.sap.sse.common.TimePoint;

-public class DefineMarkEventImpl extends RaceLogEventImpl implements DefineMarkEvent {
+public class RaceLogDefineMarkEventImpl extends RaceLogEventImpl implements RaceLogDefineMarkEvent {
    private static final long serialVersionUID = 277007856878002208L;
    
    private final Mark mark;
    
-    public DefineMarkEventImpl(TimePoint createdAt, AbstractLogEventAuthor author, TimePoint logicalTimePoint,
+    public RaceLogDefineMarkEventImpl(TimePoint createdAt, AbstractLogEventAuthor author, TimePoint logicalTimePoint,
            Serializable pId, int pPassId, Mark mark) {
        super(createdAt, author, logicalTimePoint, pId, Collections.<Competitor>emptyList(), pPassId);
         this.mark = mark;
@@ -1,4 +1,4 @@
-package com.sap.sailing.domain.abstractlog.race.tracking.events;
+package com.sap.sailing.domain.abstractlog.race.tracking.impl;

 import java.io.Serializable;
 import java.util.Collections;
@@ -6,20 +6,20 @@ import java.util.Collections;
 import com.sap.sailing.domain.abstractlog.AbstractLogEventAuthor;
 import com.sap.sailing.domain.abstractlog.race.RaceLogEventVisitor;
 import com.sap.sailing.domain.abstractlog.race.impl.RaceLogEventImpl;
-import com.sap.sailing.domain.abstractlog.race.tracking.DenoteForTrackingEvent;
+import com.sap.sailing.domain.abstractlog.race.tracking.RaceLogDenoteForTrackingEvent;
 import com.sap.sailing.domain.base.BoatClass;
 import com.sap.sailing.domain.base.Competitor;
 import com.sap.sse.common.TimePoint;

-public class DenoteForTrackingEventImpl extends RaceLogEventImpl implements
-DenoteForTrackingEvent {
+public class RaceLogDenoteForTrackingEventImpl extends RaceLogEventImpl implements
+RaceLogDenoteForTrackingEvent {
    private static final long serialVersionUID = 6937741283401976385L;

    private final String raceName;
    private final BoatClass boatClass;
    private final Serializable raceId;

-    public DenoteForTrackingEventImpl(TimePoint createdAt,
+    public RaceLogDenoteForTrackingEventImpl(TimePoint createdAt,
            AbstractLogEventAuthor author, TimePoint logicalTimePoint,
            Serializable pId, int pPassId,
            String raceName, BoatClass boatClass, Serializable raceId) {
@@ -1,17 +1,17 @@
-package com.sap.sailing.domain.abstractlog.race.tracking.events;
+package com.sap.sailing.domain.abstractlog.race.tracking.impl;

 import java.io.Serializable;

 import com.sap.sailing.domain.abstractlog.AbstractLogEventAuthor;
 import com.sap.sailing.domain.abstractlog.race.RaceLogEventVisitor;
-import com.sap.sailing.domain.abstractlog.race.tracking.DeviceCompetitorMappingEvent;
-import com.sap.sailing.domain.abstractlog.race.tracking.DeviceIdentifier;
+import com.sap.sailing.domain.abstractlog.race.tracking.RaceLogDeviceCompetitorMappingEvent;
 import com.sap.sailing.domain.base.Competitor;
+import com.sap.sailing.domain.racelogtracking.DeviceIdentifier;
 import com.sap.sse.common.TimePoint;

-public class DeviceCompetitorMappingEventImpl extends AbstractDeviceMappingEventImpl<Competitor>
-implements DeviceCompetitorMappingEvent {
-    public DeviceCompetitorMappingEventImpl(TimePoint createdAt, AbstractLogEventAuthor author, TimePoint logicalTimePoint,
+public class RaceLogDeviceCompetitorMappingEventImpl extends AbstractRaceLogDeviceMappingEventImpl<Competitor>
+implements RaceLogDeviceCompetitorMappingEvent {
+    public RaceLogDeviceCompetitorMappingEventImpl(TimePoint createdAt, AbstractLogEventAuthor author, TimePoint logicalTimePoint,
            Serializable pId, int pPassId, Competitor mappedTo, DeviceIdentifier device, TimePoint from, TimePoint to) {
        super(createdAt, author, logicalTimePoint, pId, pPassId, mappedTo, device, from, to);
    }
@@ -0,0 +1,25 @@
+package com.sap.sailing.domain.abstractlog.race.tracking.impl;
+
+import java.io.Serializable;
+
+import com.sap.sailing.domain.abstractlog.AbstractLogEventAuthor;
+import com.sap.sailing.domain.abstractlog.race.RaceLogEventVisitor;
+import com.sap.sailing.domain.abstractlog.race.tracking.RaceLogDeviceMarkMappingEvent;
+import com.sap.sailing.domain.base.Mark;
+import com.sap.sailing.domain.racelogtracking.DeviceIdentifier;
+import com.sap.sse.common.TimePoint;
+
+public class RaceLogDeviceMarkMappingEventImpl extends AbstractRaceLogDeviceMappingEventImpl<Mark>
+implements RaceLogDeviceMarkMappingEvent {
+    private static final long serialVersionUID = -7223543830755457196L;
+
+    public RaceLogDeviceMarkMappingEventImpl(TimePoint createdAt, AbstractLogEventAuthor author, TimePoint logicalTimePoint,
+            Serializable pId, int pPassId, Mark mappedTo, DeviceIdentifier device, TimePoint from, TimePoint to) {
+        super(createdAt, author, logicalTimePoint, pId, pPassId, mappedTo, device, from, to);
+    }
+
+    @Override
+    public void accept(RaceLogEventVisitor visitor) {
+        visitor.visit(this);
+    }
+}
@@ -0,0 +1,45 @@
+package com.sap.sailing.domain.abstractlog.race.tracking.impl;
+
+import java.io.Serializable;
+import java.util.List;
+
+import com.sap.sailing.domain.abstractlog.AbstractLogEventAuthor;
+import com.sap.sailing.domain.abstractlog.race.RaceLogEventData;
+import com.sap.sailing.domain.abstractlog.race.RaceLogEventVisitor;
+import com.sap.sailing.domain.abstractlog.race.impl.RaceLogEventDataImpl;
+import com.sap.sailing.domain.abstractlog.race.tracking.RaceLogRegisterCompetitorEvent;
+import com.sap.sailing.domain.abstractlog.shared.events.impl.BaseRegisterCompetitorEventImpl;
+import com.sap.sailing.domain.base.Competitor;
+import com.sap.sse.common.TimePoint;
+
+public class RaceLogRegisterCompetitorEventImpl extends BaseRegisterCompetitorEventImpl<RaceLogEventVisitor>
+implements RaceLogRegisterCompetitorEvent {
+    private static final long serialVersionUID = -5114645637316367845L;
+    private final RaceLogEventData raceLogEventData;
+    
+    public RaceLogRegisterCompetitorEventImpl(TimePoint createdAt, AbstractLogEventAuthor author,
+            TimePoint logicalTimePoint, Serializable id, int passId, Competitor competitor) {
+        super(createdAt, author, logicalTimePoint, id, competitor);
+        this.raceLogEventData = new RaceLogEventDataImpl(null, passId);
+    }
+    
+    @Override
+    public int getPassId() {
+        return raceLogEventData.getPassId();
+    }
+
+    @Override
+    public List<Competitor> getInvolvedBoats() {
+        return raceLogEventData.getInvolvedBoats();
+    }
+
+    @Override
+    public String toString() {
+        return raceLogEventData.toString();
+    }
+
+    @Override
+    public void accept(RaceLogEventVisitor visitor) {
+        visitor.visit(this);
+    }
+}
@@ -1,4 +1,4 @@
-package com.sap.sailing.domain.abstractlog.race.tracking.events;
+package com.sap.sailing.domain.abstractlog.race.tracking.impl;

 import java.io.Serializable;
 import java.util.Collections;
@@ -6,15 +6,15 @@ import java.util.Collections;
 import com.sap.sailing.domain.abstractlog.AbstractLogEventAuthor;
 import com.sap.sailing.domain.abstractlog.race.RaceLogEventVisitor;
 import com.sap.sailing.domain.abstractlog.race.impl.RaceLogEventImpl;
-import com.sap.sailing.domain.abstractlog.race.tracking.StartTrackingEvent;
+import com.sap.sailing.domain.abstractlog.race.tracking.RaceLogStartTrackingEvent;
 import com.sap.sailing.domain.base.Competitor;
 import com.sap.sse.common.TimePoint;

-public class StartTrackingEventImpl extends RaceLogEventImpl implements
-StartTrackingEvent {
+public class RaceLogStartTrackingEventImpl extends RaceLogEventImpl implements
+RaceLogStartTrackingEvent {
    private static final long serialVersionUID = 6017954368580125221L;

-    public StartTrackingEventImpl(TimePoint createdAt, AbstractLogEventAuthor author,
+    public RaceLogStartTrackingEventImpl(TimePoint createdAt, AbstractLogEventAuthor author,
            TimePoint logicalTimePoint, Serializable pId, int pPassId) {
        super(createdAt, author, logicalTimePoint, pId, Collections.<Competitor>emptyList(), pPassId);
    }
@@ -0,0 +1,21 @@
+package com.sap.sailing.domain.abstractlog.shared.analyzing;
+
+import com.sap.sailing.domain.abstractlog.AbstractLog;
+import com.sap.sailing.domain.abstractlog.AbstractLogEvent;
+import com.sap.sailing.domain.abstractlog.shared.events.DeviceCompetitorMappingEvent;
+import com.sap.sailing.domain.abstractlog.shared.events.DeviceMappingEvent;
+import com.sap.sailing.domain.base.Competitor;
+
+public class DeviceCompetitorMappingFinder<LogT extends AbstractLog
+<EventT, VisitorT>, EventT extends AbstractLogEvent<VisitorT>, VisitorT>
+extends DeviceMappingFinder<LogT, EventT, VisitorT, Competitor> {
+
+    public DeviceCompetitorMappingFinder(LogT log) {
+        super(log);
+    }
+
+    @Override
+    protected boolean isValidMapping(DeviceMappingEvent<?, ?> mapping) {
+        return mapping instanceof DeviceCompetitorMappingEvent;
+    }
+}
@@ -1,4 +1,4 @@
-package com.sap.sailing.domain.abstractlog.race.tracking.analyzing.impl;
+package com.sap.sailing.domain.abstractlog.shared.analyzing;

 import java.io.Serializable;
 import java.util.ArrayList;
@@ -8,16 +8,17 @@ import java.util.List;
 import java.util.Map;
 import java.util.logging.Logger;

+import com.sap.sailing.domain.abstractlog.AbstractLog;
+import com.sap.sailing.domain.abstractlog.AbstractLogAnalyzer;
+import com.sap.sailing.domain.abstractlog.AbstractLogEvent;
 import com.sap.sailing.domain.abstractlog.race.RaceLog;
-import com.sap.sailing.domain.abstractlog.race.RaceLogEvent;
-import com.sap.sailing.domain.abstractlog.race.analyzing.impl.RaceLogAnalyzer;
-import com.sap.sailing.domain.abstractlog.race.tracking.CloseOpenEndedDeviceMappingEvent;
-import com.sap.sailing.domain.abstractlog.race.tracking.DeviceIdentifier;
-import com.sap.sailing.domain.abstractlog.race.tracking.DeviceMapping;
-import com.sap.sailing.domain.abstractlog.race.tracking.DeviceMappingEvent;
-import com.sap.sailing.domain.abstractlog.race.tracking.impl.DeviceMappingImpl;
+import com.sap.sailing.domain.abstractlog.shared.events.CloseOpenEndedDeviceMappingEvent;
+import com.sap.sailing.domain.abstractlog.shared.events.DeviceMappingEvent;
 import com.sap.sailing.domain.common.TimeRange;
 import com.sap.sailing.domain.common.impl.TimeRangeImpl;
+import com.sap.sailing.domain.racelogtracking.DeviceIdentifier;
+import com.sap.sailing.domain.racelogtracking.DeviceMapping;
+import com.sap.sailing.domain.racelogtracking.impl.DeviceMappingImpl;
 import com.sap.sse.common.TimePoint;
 import com.sap.sse.common.WithID;

@@ -34,14 +35,15 @@ import com.sap.sse.common.WithID;
 * {@code DeviceMapping}, the only changes being introduced by closing open time ranges in cases where an
 * according {@code CloseOpenEndedDeviceMappingEvent} exists.
 */
-public class DeviceMappingFinder<ItemT extends WithID> extends RaceLogAnalyzer<Map<ItemT, List<DeviceMapping<ItemT>>>> {
+public class DeviceMappingFinder<LogT extends AbstractLog<EventT, VisitorT>, EventT extends AbstractLogEvent<VisitorT>,
+VisitorT, ItemT extends WithID> extends AbstractLogAnalyzer<LogT, EventT, VisitorT, Map<ItemT, List<DeviceMapping<ItemT>>>> {
    private static Logger logger = Logger.getLogger(DeviceMappingFinder.class.getName());
    
-    public DeviceMappingFinder(RaceLog raceLog) {
-        super(raceLog);
+    public DeviceMappingFinder(LogT log) {
+        super(log);
    }

-    protected boolean isValidMapping(DeviceMappingEvent<?> mapping) {
+    protected boolean isValidMapping(DeviceMappingEvent<?, ?> mapping) {
        return mapping instanceof DeviceMappingEvent;
    }

@@ -61,18 +63,18 @@ public class DeviceMappingFinder<ItemT extends WithID> extends RaceLogAnalyzer<M
    }
    @Override
    protected Map<ItemT, List<DeviceMapping<ItemT>>> performAnalysis() {
-        Map<ItemT, List<DeviceMappingEvent<ItemT>>> events = new HashMap<ItemT, List<DeviceMappingEvent<ItemT>>>();
+        Map<ItemT, List<DeviceMappingEvent<?, ItemT>>> events = new HashMap<ItemT, List<DeviceMappingEvent<?, ItemT>>>();
        Map<ItemT, List<DeviceMapping<ItemT>>> mappings = new HashMap<ItemT, List<DeviceMapping<ItemT>>>();
-        Map<Serializable, CloseOpenEndedDeviceMappingEvent> closingEvents = new HashMap<Serializable, CloseOpenEndedDeviceMappingEvent>();
+        Map<Serializable, CloseOpenEndedDeviceMappingEvent<?>> closingEvents = new HashMap<Serializable, CloseOpenEndedDeviceMappingEvent<?>>();

-        for (RaceLogEvent e : getLog().getUnrevokedEvents()) {
-            if (e instanceof DeviceMappingEvent && isValidMapping(((DeviceMappingEvent<?>) e))) {
+        for (EventT e : getLog().getUnrevokedEvents()) {
+            if (e instanceof DeviceMappingEvent && isValidMapping(((DeviceMappingEvent<?, ?>) e))) {
                @SuppressWarnings("unchecked")
-                DeviceMappingEvent<ItemT> mappingEvent = (DeviceMappingEvent<ItemT>) e;
+                DeviceMappingEvent<?, ItemT> mappingEvent = (DeviceMappingEvent<?, ItemT>) e;
                getItemSet(events, mappingEvent.getMappedTo()).add(mappingEvent);
            } else if (e instanceof CloseOpenEndedDeviceMappingEvent) {
                //a higher priority closing events for the same mapping event overwrites the lower priority one
-                CloseOpenEndedDeviceMappingEvent closingEvent = (CloseOpenEndedDeviceMappingEvent) e;
+                CloseOpenEndedDeviceMappingEvent<?> closingEvent = (CloseOpenEndedDeviceMappingEvent<?>) e;
                closingEvents.put(closingEvent.getDeviceMappingEventId(), closingEvent);
            }
        }
@@ -84,11 +86,11 @@ public class DeviceMappingFinder<ItemT extends WithID> extends RaceLogAnalyzer<M
        return mappings;
    }
    
-    private List<DeviceMapping<ItemT>> closeOpenRanges(List<DeviceMappingEvent<ItemT>> events, ItemT item,
-            Map<Serializable, CloseOpenEndedDeviceMappingEvent> closingEvents) {
+    private List<DeviceMapping<ItemT>> closeOpenRanges(List<DeviceMappingEvent<?, ItemT>> events, ItemT item,
+            Map<Serializable, CloseOpenEndedDeviceMappingEvent<?>> closingEvents) {
        List<DeviceMapping<ItemT>> result = new ArrayList<DeviceMapping<ItemT>>();
        
-        for (DeviceMappingEvent<ItemT> event : events) {            
+        for (DeviceMappingEvent<?, ItemT> event : events) {            
            TimePoint from = event.getFrom();
            TimePoint to = event.getTo();
            TimePoint closingTimePoint = closingEvents.containsKey(event.getId()) ?
@@ -0,0 +1,21 @@
+package com.sap.sailing.domain.abstractlog.shared.analyzing;
+
+import com.sap.sailing.domain.abstractlog.AbstractLog;
+import com.sap.sailing.domain.abstractlog.AbstractLogEvent;
+import com.sap.sailing.domain.abstractlog.shared.events.DeviceMappingEvent;
+import com.sap.sailing.domain.abstractlog.shared.events.DeviceMarkMappingEvent;
+import com.sap.sailing.domain.base.Mark;
+
+public class DeviceMarkMappingFinder
+<LogT extends AbstractLog<EventT, VisitorT>, EventT extends AbstractLogEvent<VisitorT>, VisitorT>
+extends DeviceMappingFinder<LogT, EventT, VisitorT, Mark> {
+
+    public DeviceMarkMappingFinder(LogT log) {
+        super(log);
+    }
+
+    @Override
+    protected boolean isValidMapping(DeviceMappingEvent<?, ?> mapping) {
+        return mapping instanceof DeviceMarkMappingEvent;
+    }
+}
@@ -0,0 +1,35 @@
+package com.sap.sailing.domain.abstractlog.shared.analyzing;
+
+import com.sap.sailing.domain.abstractlog.AbstractLog;
+import com.sap.sailing.domain.abstractlog.AbstractLogAnalyzer;
+import com.sap.sailing.domain.abstractlog.AbstractLogEvent;
+import com.sap.sailing.domain.abstractlog.shared.events.DeviceMappingEvent;
+import com.sap.sse.common.WithID;
+
+public class LastPingMappingEventFinder <LogT extends AbstractLog<EventT, VisitorT>,
+EventT extends AbstractLogEvent<VisitorT>, VisitorT, ItemT extends WithID>
+extends AbstractLogAnalyzer<LogT, EventT, VisitorT, DeviceMappingEvent<VisitorT, ItemT>> {
+    private final WithID item;
+    
+    public LastPingMappingEventFinder(LogT log, WithID forItem) {
+        super(log);
+        this.item = forItem;
+    }
+
+    @Override
+    protected DeviceMappingEvent<VisitorT, ItemT> performAnalysis() {
+        for (EventT e : getLog().getUnrevokedEventsDescending()) {
+            if (e instanceof DeviceMappingEvent) {
+                DeviceMappingEvent<?, ?> mappingEvent = (DeviceMappingEvent<?, ?>) e;
+                if (item.equals(mappingEvent.getMappedTo()) && mappingEvent.getFrom() != null &&
+                        mappingEvent.getTo() != null && mappingEvent.getFrom().equals(mappingEvent.getTo())) {
+                    @SuppressWarnings("unchecked")
+                    DeviceMappingEvent<VisitorT, ItemT> cast = (DeviceMappingEvent<VisitorT, ItemT>) mappingEvent;
+                    return cast;
+                }
+            }
+        }
+        return null;
+    }
+
+}
@@ -0,0 +1,53 @@
+package com.sap.sailing.domain.abstractlog.shared.analyzing;
+
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.List;
+
+import com.sap.sailing.domain.abstractlog.AbstractLog;
+import com.sap.sailing.domain.abstractlog.AbstractLogAnalyzer;
+import com.sap.sailing.domain.abstractlog.AbstractLogEvent;
+import com.sap.sailing.domain.abstractlog.AbstractLogEventAuthor;
+import com.sap.sailing.domain.abstractlog.shared.events.CloseOpenEndedDeviceMappingEvent;
+import com.sap.sailing.domain.abstractlog.shared.events.DeviceMappingEvent;
+import com.sap.sailing.domain.racelogtracking.DeviceMapping;
+import com.sap.sse.common.TimePoint;
+import com.sap.sse.common.impl.MillisecondsTimePoint;
+
+/**
+ * Generates events that close the events that are responsible for the {@link #mapping}
+ * that is passed to the constructor.
+ * @author Fredrik Teschke
+ *
+ */
+public abstract class OpenEndedDeviceMappingCloser<LogT extends AbstractLog<EventT, VisitorT>,
+EventT extends AbstractLogEvent<VisitorT>,VisitorT, CloseEventT extends CloseOpenEndedDeviceMappingEvent<VisitorT>>
+extends AbstractLogAnalyzer<LogT, EventT, VisitorT, List<CloseEventT>> {
+    private final DeviceMapping<?> mapping;
+    protected final AbstractLogEventAuthor author;
+    protected final TimePoint closingTimePoint;
+
+    public OpenEndedDeviceMappingCloser(LogT log, DeviceMapping<?> mapping, AbstractLogEventAuthor author,
+            TimePoint closingTimePoint) {
+        super(log);
+        this.mapping = mapping;
+        this.author = author;
+        this.closingTimePoint = closingTimePoint;
+    }
+    
+    protected abstract CloseEventT createCloseEvent(TimePoint logicalTimePoint,
+            Serializable eventToCloseId);
+
+    @Override
+    protected List<CloseEventT> performAnalysis() {
+        List<CloseEventT> result = new ArrayList<CloseEventT>();
+
+        for (Serializable eventId : mapping.getOriginalRaceLogEventIds()) {
+            DeviceMappingEvent<?, ?> event = (DeviceMappingEvent<?, ?>) getLog().getEventById(eventId);
+            if (event.getFrom() == null || event.getTo() == null) {
+                result.add(createCloseEvent(MillisecondsTimePoint.now(), event.getId()));
+            }
+        }
+        return result;
+    }
+}
@@ -1,4 +1,4 @@
-package com.sap.sailing.domain.abstractlog.race.tracking.analyzing.impl;
+package com.sap.sailing.domain.abstractlog.shared.analyzing;

 import java.util.HashSet;
 import java.util.Set;
@@ -6,7 +6,8 @@ import java.util.Set;
 import com.sap.sailing.domain.abstractlog.race.RaceLog;
 import com.sap.sailing.domain.abstractlog.race.RaceLogEvent;
 import com.sap.sailing.domain.abstractlog.race.analyzing.impl.RaceLogAnalyzer;
-import com.sap.sailing.domain.abstractlog.race.tracking.RegisterCompetitorEvent;
+import com.sap.sailing.domain.abstractlog.race.tracking.RaceLogRegisterCompetitorEvent;
+import com.sap.sailing.domain.abstractlog.shared.events.RegisterCompetitorEvent;
 import com.sap.sailing.domain.base.Competitor;

 /**
@@ -27,7 +28,7 @@ public class RegisteredCompetitorsAnalyzer extends RaceLogAnalyzer<Set<Competito

        for (RaceLogEvent event : getLog().getUnrevokedEvents()) {
            if (event instanceof RegisterCompetitorEvent) {
-                result.add(((RegisterCompetitorEvent) event).getCompetitor());
+                result.add(((RaceLogRegisterCompetitorEvent) event).getCompetitor());
            }
        }

@@ -1,9 +1,9 @@
-package com.sap.sailing.domain.abstractlog.race.tracking;
+package com.sap.sailing.domain.abstractlog.shared.events;

 import java.io.Serializable;

+import com.sap.sailing.domain.abstractlog.AbstractLogEvent;
 import com.sap.sailing.domain.abstractlog.Revokable;
-import com.sap.sailing.domain.abstractlog.race.RaceLogEvent;
 import com.sap.sse.common.TimePoint;

 /**
@@ -12,7 +12,7 @@ import com.sap.sse.common.TimePoint;
 * @author Fredrik Teschke
 *
 */
-public interface CloseOpenEndedDeviceMappingEvent extends RaceLogEvent, Revokable {
+public interface CloseOpenEndedDeviceMappingEvent<VisitorT> extends AbstractLogEvent<VisitorT>, Revokable {
    /**
     * Returns the timepoint that shall substitute the missing one in the corresponding {@link DeviceMappingEvent}.
     */
@@ -0,0 +1,7 @@
+package com.sap.sailing.domain.abstractlog.shared.events;
+
+import com.sap.sailing.domain.base.Competitor;
+
+public interface DeviceCompetitorMappingEvent<VisitorT> extends DeviceMappingEvent<VisitorT, Competitor> {
+
+}
@@ -1,10 +1,12 @@
-package com.sap.sailing.domain.abstractlog.race.tracking;
+package com.sap.sailing.domain.abstractlog.shared.events;

+import com.sap.sailing.domain.abstractlog.AbstractLogEvent;
 import com.sap.sailing.domain.abstractlog.Revokable;
-import com.sap.sailing.domain.abstractlog.race.RaceLogEvent;
 import com.sap.sailing.domain.abstractlog.race.tracking.analyzing.impl.DefinedMarkFinder;
 import com.sap.sailing.domain.base.Competitor;
 import com.sap.sailing.domain.base.Mark;
+import com.sap.sailing.domain.racelogtracking.DeviceIdentifier;
+import com.sap.sailing.domain.racelogtracking.DeviceMapping;
 import com.sap.sse.common.TimePoint;
 import com.sap.sse.common.WithID;

@@ -20,7 +22,7 @@ import com.sap.sse.common.WithID;
 * @see DefinedMarkFinder for rules by which {@link DeviceMapping}s are derived from these events.
 * @author Fredrik Teschke
 */
-public interface DeviceMappingEvent<ItemType extends WithID> extends RaceLogEvent, Revokable {
+public interface DeviceMappingEvent<VisitorT, ItemType extends WithID> extends AbstractLogEvent<VisitorT>, Revokable {
    ItemType getMappedTo();
    DeviceIdentifier getDevice();
    
@@ -0,0 +1,8 @@
+package com.sap.sailing.domain.abstractlog.shared.events;
+
+import com.sap.sailing.domain.base.Mark;
+
+
+public interface DeviceMarkMappingEvent<VisitorT> extends DeviceMappingEvent<VisitorT, Mark> {
+
+}
@@ -1,7 +1,8 @@
-package com.sap.sailing.domain.abstractlog.race.tracking;
+package com.sap.sailing.domain.abstractlog.shared.events;

 import com.sap.sailing.domain.base.Timed;
 import com.sap.sailing.domain.common.TimeRange;
+import com.sap.sailing.domain.racelogtracking.DeviceIdentifier;

 public interface DeviceWithTimeRange extends Timed {
    DeviceIdentifier getDevice();
@@ -1,8 +1,8 @@
-package com.sap.sailing.domain.abstractlog.race.tracking;
+package com.sap.sailing.domain.abstractlog.shared.events;

+import com.sap.sailing.domain.abstractlog.AbstractLogEvent;
 import com.sap.sailing.domain.abstractlog.Revokable;
 import com.sap.sailing.domain.abstractlog.race.RaceLog;
-import com.sap.sailing.domain.abstractlog.race.RaceLogEvent;
 import com.sap.sailing.domain.base.Competitor;
 import com.sap.sse.common.IsManagedByCache;

@@ -16,6 +16,6 @@ import com.sap.sse.common.IsManagedByCache;
 * @author Fredrik Teschke
 *
 */
-public interface RegisterCompetitorEvent extends RaceLogEvent, Revokable {
+public interface RegisterCompetitorEvent<VisitorT> extends AbstractLogEvent<VisitorT>, Revokable {
    Competitor getCompetitor();
 }
@@ -1,18 +1,16 @@
-package com.sap.sailing.domain.abstractlog.race.tracking.events;
+package com.sap.sailing.domain.abstractlog.shared.events.impl;

 import java.io.Serializable;
-import java.util.Collections;

 import com.sap.sailing.domain.abstractlog.AbstractLogEventAuthor;
-import com.sap.sailing.domain.abstractlog.race.impl.RaceLogEventImpl;
-import com.sap.sailing.domain.abstractlog.race.tracking.DeviceIdentifier;
-import com.sap.sailing.domain.abstractlog.race.tracking.DeviceMappingEvent;
-import com.sap.sailing.domain.base.Competitor;
+import com.sap.sailing.domain.abstractlog.impl.AbstractLogEventImpl;
+import com.sap.sailing.domain.abstractlog.shared.events.DeviceMappingEvent;
+import com.sap.sailing.domain.racelogtracking.DeviceIdentifier;
 import com.sap.sse.common.TimePoint;
 import com.sap.sse.common.WithID;

-public abstract class AbstractDeviceMappingEventImpl<ItemType extends WithID> extends RaceLogEventImpl implements
-DeviceMappingEvent<ItemType> {
+public abstract class AbstractDeviceMappingEventImpl<VisitorT, ItemType extends WithID> extends AbstractLogEventImpl<VisitorT> implements
+DeviceMappingEvent<VisitorT, ItemType> {
    private static final long serialVersionUID = -8439653251231710356L;

    private final ItemType mappedTo;
@@ -21,9 +19,9 @@ DeviceMappingEvent<ItemType> {
    private final TimePoint to;

    public AbstractDeviceMappingEventImpl(TimePoint createdAt, AbstractLogEventAuthor author,
-            TimePoint logicalTimePoint, Serializable pId, int pPassId, ItemType mappedTo,
+            TimePoint logicalTimePoint, Serializable id, ItemType mappedTo,
            DeviceIdentifier device, TimePoint from, TimePoint to) {
-        super(createdAt, author, logicalTimePoint, pId, Collections.<Competitor>emptyList(), pPassId);
+        super(createdAt, author, logicalTimePoint, id);
        this.mappedTo = mappedTo;
        this.device = device;
        this.from = from;
@@ -0,0 +1,35 @@
+package com.sap.sailing.domain.abstractlog.shared.events.impl;
+
+import java.io.Serializable;
+
+import com.sap.sailing.domain.abstractlog.AbstractLogEventAuthor;
+import com.sap.sailing.domain.abstractlog.impl.AbstractLogEventImpl;
+import com.sap.sailing.domain.abstractlog.shared.events.CloseOpenEndedDeviceMappingEvent;
+import com.sap.sse.common.TimePoint;
+
+public abstract class BaseCloseOpenEndedDeviceMappingEventImpl<VisitorT> extends AbstractLogEventImpl<VisitorT>
+implements CloseOpenEndedDeviceMappingEvent<VisitorT> {
+    private static final long serialVersionUID = -2401732623610224918L;
+    
+    private final Serializable deviceMappingEventId;
+    private final TimePoint closingTimePoint;
+
+    public BaseCloseOpenEndedDeviceMappingEventImpl(TimePoint createdAt, AbstractLogEventAuthor author,
+            TimePoint logicalTimePoint, Serializable pId, Serializable deviceMappingEventId,
+            TimePoint closingTimePoint) {
+        super(createdAt, author, logicalTimePoint, pId);
+        this.deviceMappingEventId = deviceMappingEventId;
+        this.closingTimePoint = closingTimePoint;
+    }
+
+    @Override
+    public Serializable getDeviceMappingEventId() {
+        return deviceMappingEventId;
+    }
+
+    @Override
+    public TimePoint getClosingTimePoint() {
+        return closingTimePoint;
+    }
+
+}
@@ -0,0 +1,31 @@
+package com.sap.sailing.domain.abstractlog.shared.events.impl;
+
+import java.io.Serializable;
+
+import com.sap.sailing.domain.abstractlog.AbstractLogEventAuthor;
+import com.sap.sailing.domain.abstractlog.impl.AbstractLogEventImpl;
+import com.sap.sailing.domain.abstractlog.shared.events.RegisterCompetitorEvent;
+import com.sap.sailing.domain.base.Competitor;
+import com.sap.sse.common.TimePoint;
+
+public abstract class BaseRegisterCompetitorEventImpl<VisitorT> extends AbstractLogEventImpl<VisitorT>
+implements RegisterCompetitorEvent<VisitorT> {
+    private static final long serialVersionUID = -30864810737555657L;
+    private final Competitor competitor;
+    
+    public BaseRegisterCompetitorEventImpl(TimePoint createdAt, AbstractLogEventAuthor author, TimePoint logicalTimePoint,
+            Serializable pId, Competitor competitor) {
+        super(createdAt, author, logicalTimePoint, pId);
+        this.competitor = competitor;
+    }
+
+    @Override
+    public Competitor getCompetitor() {
+        return competitor;
+    } 
+
+    @Override
+    public String getShortInfo() {
+        return "competitor: " + getCompetitor().toString();
+    }
+}
@@ -1,4 +1,4 @@
-package com.sap.sailing.domain.abstractlog.race.tracking;
+package com.sap.sailing.domain.racelogtracking;

 import java.io.Serializable;

@@ -1,4 +1,4 @@
-package com.sap.sailing.domain.abstractlog.race.tracking;
+package com.sap.sailing.domain.racelogtracking;

 import com.sap.sailing.domain.common.racelog.tracking.TransformationException;
 import com.sap.sse.common.Util;