e4e142d936adf1b6bb6eee168b16af1a3d513a7c
java/com.sap.sailing.awssensorfixstore/src/com/sap/sailing/awssensorfixstore/impl/AwsSensorFixStore.java
| ... | ... | @@ -36,14 +36,14 @@ public class AwsSensorFixStore implements SensorFixStore { |
| 36 | 36 | } |
| 37 | 37 | |
| 38 | 38 | @Override |
| 39 | - public <FixT extends Timed> void storeFix(DeviceIdentifier device, FixT fix, boolean filterByRegattaAndEventEndDate) { |
|
| 39 | + public <FixT extends Timed> void storeFix(DeviceIdentifier device, FixT fix) { |
|
| 40 | 40 | // TODO Auto-generated method stub |
| 41 | 41 | |
| 42 | 42 | } |
| 43 | 43 | |
| 44 | 44 | @Override |
| 45 | 45 | public <FixT extends Timed> Iterable<Triple<RegattaAndRaceIdentifier, Boolean, Duration>> storeFixes( |
| 46 | - DeviceIdentifier device, Iterable<FixT> fixes, boolean returnManeuverUpdate, boolean returnLiveDelay, boolean filterByRegattaAndEventEndDate) { |
|
| 46 | + DeviceIdentifier device, Iterable<FixT> fixes, boolean returnManeuverUpdate, boolean returnLiveDelay) { |
|
| 47 | 47 | // TODO Auto-generated method stub |
| 48 | 48 | return null; |
| 49 | 49 | } |
java/com.sap.sailing.domain.persistence/src/com/sap/sailing/domain/persistence/racelog/tracking/impl/MongoSensorFixStoreImpl.java
| ... | ... | @@ -205,7 +205,7 @@ public class MongoSensorFixStoreImpl extends MongoFixHandler implements MongoSen |
| 205 | 205 | */ |
| 206 | 206 | @Override |
| 207 | 207 | public <FixT extends Timed> Iterable<Triple<RegattaAndRaceIdentifier, Boolean, Duration>> storeFixes(DeviceIdentifier device, |
| 208 | - Iterable<FixT> fixes, boolean returnManeuverChanges, boolean returnLiveDelay, boolean filterByRegattaAndEventEndDate) { |
|
| 208 | + Iterable<FixT> fixes, boolean returnManeuverChanges, boolean returnLiveDelay) { |
|
| 209 | 209 | final Set<Triple<RegattaAndRaceIdentifier, Boolean, Duration>> racesWithManeuverChangesOrLiveDelay = new HashSet<>(); |
| 210 | 210 | if (!Util.isEmpty(fixes)) { |
| 211 | 211 | try { |
| ... | ... | @@ -236,18 +236,18 @@ public class MongoSensorFixStoreImpl extends MongoFixHandler implements MongoSen |
| 236 | 236 | } catch (TransformationException e) { |
| 237 | 237 | logger.log(Level.WARNING, "Could not store fix in MongoDB", e); |
| 238 | 238 | } |
| 239 | - Util.addAll(notifyListeners(device, fixes, returnManeuverChanges, returnLiveDelay, filterByRegattaAndEventEndDate), racesWithManeuverChangesOrLiveDelay); |
|
| 239 | + Util.addAll(notifyListeners(device, fixes, returnManeuverChanges, returnLiveDelay), racesWithManeuverChangesOrLiveDelay); |
|
| 240 | 240 | } |
| 241 | 241 | return racesWithManeuverChangesOrLiveDelay; |
| 242 | 242 | } |
| 243 | 243 | |
| 244 | 244 | @Override |
| 245 | - public <FixT extends Timed> void storeFix(DeviceIdentifier device, FixT fix, boolean filterByRegattaAndEventEndDate) { |
|
| 246 | - storeFixes(device, Collections.singletonList(fix), /* returnManeuverUpdate */ false, /* returnLiveDelay */ false, /* filterByRegattaAndEventEndDate */ false); |
|
| 245 | + public <FixT extends Timed> void storeFix(DeviceIdentifier device, FixT fix) { |
|
| 246 | + storeFixes(device, Collections.singletonList(fix), /* returnManeuverUpdate */ false, /* returnLiveDelay */ false); |
|
| 247 | 247 | } |
| 248 | 248 | |
| 249 | 249 | private <FixT extends Timed> Iterable<Triple<RegattaAndRaceIdentifier, Boolean, Duration>> notifyListeners(DeviceIdentifier device, |
| 250 | - Iterable<FixT> fixes, boolean returnManeuverChanges, boolean returnLiveDelay, boolean filterByRegattaAndEventEndDate) { |
|
| 250 | + Iterable<FixT> fixes, boolean returnManeuverChanges, boolean returnLiveDelay) { |
|
| 251 | 251 | final Set<Triple<RegattaAndRaceIdentifier, Boolean, Duration>> raceWithChangedManeuver = new HashSet<>(); |
| 252 | 252 | @SuppressWarnings({ "unchecked", "rawtypes" }) |
| 253 | 253 | final Map<DeviceIdentifier, Set<FixReceivedListener<FixT>>> listenersWithFixType = (Map) listeners; |
java/com.sap.sailing.domain.queclinkadapter/src/com/sap/sailing/domain/queclinkadapter/impl/PositionRelatedReportToGPSFixConverter.java
| ... | ... | @@ -40,6 +40,6 @@ public class PositionRelatedReportToGPSFixConverter { |
| 40 | 40 | public void ingestFixesToStore(SensorFixStore store, FRIReport fixesReceived) { |
| 41 | 41 | final SmartphoneImeiIdentifier deviceIdentifier = getDeviceIdentifier(fixesReceived); |
| 42 | 42 | final Iterable<GPSFix> fixes = Util.map(Arrays.asList(fixesReceived.getPositionRelatedReports()), this::createGPSFixFromPositionRelatedReport); |
| 43 | - store.storeFixes(deviceIdentifier, fixes, /* returnManeuverUpdate */ false, /* returnLiveDelay */ false, /* filterByRegattaAndEventEndDate */ false); |
|
| 43 | + store.storeFixes(deviceIdentifier, fixes, /* returnManeuverUpdate */ false, /* returnLiveDelay */ false); |
|
| 44 | 44 | } |
| 45 | 45 | } |
| ... | ... | \ No newline at end of file |
java/com.sap.sailing.domain.racelogtrackingadapter.test/src/com/sap/sailing/domain/racelogtracking/test/impl/CreateAndTrackWithRaceLogTest.java
| ... | ... | @@ -165,9 +165,9 @@ public class CreateAndTrackWithRaceLogTest extends RaceLogTrackingTestHelper { |
| 165 | 165 | private void addFixes0(DeviceIdentifier dev1) throws TransformationException, |
| 166 | 166 | NoCorrespondingServiceRegisteredException { |
| 167 | 167 | sensorFixStore.storeFix(dev1, new GPSFixMovingImpl(new DegreePosition(0, 0), t(5), new KnotSpeedWithBearingImpl( |
| 168 | - 10, new DegreeBearingImpl(5)), /* optionalTrueHeading */ null), /* filterByRegattaAndEventEndDate */ false); |
|
| 168 | + 10, new DegreeBearingImpl(5)), /* optionalTrueHeading */ null)); |
|
| 169 | 169 | sensorFixStore.storeFix(dev1, new GPSFixMovingImpl(new DegreePosition(0, 0), t(15), new KnotSpeedWithBearingImpl( |
| 170 | - 10, new DegreeBearingImpl(5)), /* optionalTrueHeading */ null), /* filterByRegattaAndEventEndDate */ false); |
|
| 170 | + 10, new DegreeBearingImpl(5)), /* optionalTrueHeading */ null)); |
|
| 171 | 171 | } |
| 172 | 172 | |
| 173 | 173 | private void addFixes1(TrackedRace race, Competitor comp1, DeviceIdentifier dev1) throws TransformationException, |
| ... | ... | @@ -176,9 +176,9 @@ public class CreateAndTrackWithRaceLogTest extends RaceLogTrackingTestHelper { |
| 176 | 176 | testSize(race.getTrack(comp1), 1); |
| 177 | 177 | // further fix arrives in race |
| 178 | 178 | sensorFixStore.storeFix(dev1, new GPSFixMovingImpl(new DegreePosition(0, 0), t(7), new KnotSpeedWithBearingImpl( |
| 179 | - 10, new DegreeBearingImpl(5)), /* optionalTrueHeading */ null), /* filterByRegattaAndEventEndDate */ false); |
|
| 179 | + 10, new DegreeBearingImpl(5)), /* optionalTrueHeading */ null)); |
|
| 180 | 180 | sensorFixStore.storeFix(dev1, new GPSFixMovingImpl(new DegreePosition(0, 0), t(14), new KnotSpeedWithBearingImpl( |
| 181 | - 10, new DegreeBearingImpl(5)), /* optionalTrueHeading */ null), /* filterByRegattaAndEventEndDate */ false); // outside mapping range |
|
| 181 | + 10, new DegreeBearingImpl(5)), /* optionalTrueHeading */ null)); // outside mapping range |
|
| 182 | 182 | testSize(race.getTrack(comp1), 2); |
| 183 | 183 | } |
| 184 | 184 | |
| ... | ... | @@ -188,7 +188,7 @@ public class CreateAndTrackWithRaceLogTest extends RaceLogTrackingTestHelper { |
| 188 | 188 | testSize(race.getTrack(comp1), 4); |
| 189 | 189 | // add another fix in new mapping range |
| 190 | 190 | sensorFixStore.storeFix(dev1, new GPSFixMovingImpl(new DegreePosition(0, 0), t(18), new KnotSpeedWithBearingImpl( |
| 191 | - 10, new DegreeBearingImpl(5)), /* optionalTrueHeading */ null), /* filterByRegattaAndEventEndDate */ false); |
|
| 191 | + 10, new DegreeBearingImpl(5)), /* optionalTrueHeading */ null)); |
|
| 192 | 192 | testSize(race.getTrack(comp1), 5); |
| 193 | 193 | } |
| 194 | 194 | |
| ... | ... | @@ -196,7 +196,7 @@ public class CreateAndTrackWithRaceLogTest extends RaceLogTrackingTestHelper { |
| 196 | 196 | NoCorrespondingServiceRegisteredException { |
| 197 | 197 | // stop tracking, then no more fixes arrive at race |
| 198 | 198 | sensorFixStore.storeFix(dev1, new GPSFixMovingImpl(new DegreePosition(0, 0), t(8), new KnotSpeedWithBearingImpl( |
| 199 | - 10, new DegreeBearingImpl(5)), /* optionalTrueHeading */ null), /* filterByRegattaAndEventEndDate */ false); |
|
| 199 | + 10, new DegreeBearingImpl(5)), /* optionalTrueHeading */ null)); |
|
| 200 | 200 | testSize(race.getTrack(comp1), 5); |
| 201 | 201 | } |
| 202 | 202 |
java/com.sap.sailing.domain.racelogtrackingadapter.test/src/com/sap/sailing/domain/racelogtracking/test/impl/DeviceMappingsAndSensorFixStoreLockingTest.java
| ... | ... | @@ -77,7 +77,7 @@ public class DeviceMappingsAndSensorFixStoreLockingTest extends AbstractGPSFixSt |
| 77 | 77 | }; |
| 78 | 78 | }.start(); |
| 79 | 79 | |
| 80 | - store.storeFix(device, new DoubleVectorFixImpl(new MillisecondsTimePoint(1), new Double[]{0.0}), /* filterByRegattaAndEventEndDate */ false); |
|
| 80 | + store.storeFix(device, new DoubleVectorFixImpl(new MillisecondsTimePoint(1), new Double[]{0.0})); |
|
| 81 | 81 | } |
| 82 | 82 | |
| 83 | 83 | } |
java/com.sap.sailing.domain.racelogtrackingadapter.test/src/com/sap/sailing/domain/racelogtracking/test/impl/GPSFixStoreListenerTest.java
| ... | ... | @@ -54,7 +54,7 @@ public class GPSFixStoreListenerTest extends AbstractGPSFixStoreTest { |
| 54 | 54 | }; |
| 55 | 55 | thread.start(); |
| 56 | 56 | try { |
| 57 | - store.storeFix(device, createFix(100, 10, 20, 30, 40), /* filterByRegattaAndEventEndDate */ false); |
|
| 57 | + store.storeFix(device, createFix(100, 10, 20, 30, 40)); |
|
| 58 | 58 | } finally { |
| 59 | 59 | // This ensures that the thread is terminated when the test finishes |
| 60 | 60 | // JUnit may behave crazy if there are additional tests running after the test finished |
java/com.sap.sailing.domain.racelogtrackingadapter.test/src/com/sap/sailing/domain/racelogtracking/test/impl/SensorFixStoreAndLoadTest.java
| ... | ... | @@ -417,15 +417,15 @@ public class SensorFixStoreAndLoadTest { |
| 417 | 417 | } |
| 418 | 418 | |
| 419 | 419 | private void addBravoFixes() { |
| 420 | - store.storeFix(device, createBravoDoubleVectorFixWithRideHeight(FIX_TIMESTAMP, FIX_RIDE_HEIGHT.getMeters()), /* filterByRegattaAndEventEndDate */ false); |
|
| 421 | - store.storeFix(device, createBravoDoubleVectorFixWithRideHeight(FIX_TIMESTAMP2, FIX_RIDE_HEIGHT2.getMeters()), /* filterByRegattaAndEventEndDate */ false); |
|
| 422 | - store.storeFix(device, createBravoDoubleVectorFixWithRideHeight(FIX_TIMESTAMP3, FIX_RIDE_HEIGHT3.getMeters()), /* filterByRegattaAndEventEndDate */ false); |
|
| 420 | + store.storeFix(device, createBravoDoubleVectorFixWithRideHeight(FIX_TIMESTAMP, FIX_RIDE_HEIGHT.getMeters())); |
|
| 421 | + store.storeFix(device, createBravoDoubleVectorFixWithRideHeight(FIX_TIMESTAMP2, FIX_RIDE_HEIGHT2.getMeters())); |
|
| 422 | + store.storeFix(device, createBravoDoubleVectorFixWithRideHeight(FIX_TIMESTAMP3, FIX_RIDE_HEIGHT3.getMeters())); |
|
| 423 | 423 | } |
| 424 | 424 | |
| 425 | 425 | private void addMoreBravoFixes() { |
| 426 | - store.storeFix(device, createBravoDoubleVectorFixWithRideHeight(FIX_TIMESTAMP + 1, FIX_RIDE_HEIGHT.getMeters()), /* filterByRegattaAndEventEndDate */ false); |
|
| 427 | - store.storeFix(device, createBravoDoubleVectorFixWithRideHeight(FIX_TIMESTAMP2 + 1, FIX_RIDE_HEIGHT2.getMeters()), /* filterByRegattaAndEventEndDate */ false); |
|
| 428 | - store.storeFix(device, createBravoDoubleVectorFixWithRideHeight(FIX_TIMESTAMP3 + 1, FIX_RIDE_HEIGHT3.getMeters()), /* filterByRegattaAndEventEndDate */ false); |
|
| 426 | + store.storeFix(device, createBravoDoubleVectorFixWithRideHeight(FIX_TIMESTAMP + 1, FIX_RIDE_HEIGHT.getMeters())); |
|
| 427 | + store.storeFix(device, createBravoDoubleVectorFixWithRideHeight(FIX_TIMESTAMP2 + 1, FIX_RIDE_HEIGHT2.getMeters())); |
|
| 428 | + store.storeFix(device, createBravoDoubleVectorFixWithRideHeight(FIX_TIMESTAMP3 + 1, FIX_RIDE_HEIGHT3.getMeters())); |
|
| 429 | 429 | } |
| 430 | 430 | |
| 431 | 431 | private FixLoaderAndTracker createFixLoaderAndTracker() { |
| ... | ... | @@ -477,7 +477,7 @@ public class SensorFixStoreAndLoadTest { |
| 477 | 477 | } |
| 478 | 478 | |
| 479 | 479 | private void addTestFixes() { |
| 480 | - store.storeFix(deviceTest, createTestDoubleVectorFixWithTestValue(FIX_TIMESTAMP, FIX_TEST_VALUE), /* filterByRegattaAndEventEndDate */ false); |
|
| 480 | + store.storeFix(deviceTest, createTestDoubleVectorFixWithTestValue(FIX_TIMESTAMP, FIX_TEST_VALUE)); |
|
| 481 | 481 | } |
| 482 | 482 | |
| 483 | 483 | private DoubleVectorFix createTestDoubleVectorFixWithTestValue(long timestamp, double testValue) { |
java/com.sap.sailing.domain.racelogtrackingadapter.test/src/com/sap/sailing/domain/racelogtracking/test/impl/SensorFixStoreTest.java
| ... | ... | @@ -388,7 +388,7 @@ public class SensorFixStoreTest { |
| 388 | 388 | |
| 389 | 389 | private DoubleVectorFix addBravoFix(DeviceIdentifier device, long timestamp, double rideHeight) { |
| 390 | 390 | DoubleVectorFix fix = createBravoDoubleVectorFixWithRideHeight(timestamp, rideHeight); |
| 391 | - store.storeFix(device, fix, /* filterByRegattaAndEventEndDate */ false); |
|
| 391 | + store.storeFix(device, fix); |
|
| 392 | 392 | return fix; |
| 393 | 393 | } |
| 394 | 394 |
java/com.sap.sailing.domain.racelogtrackingadapter.test/src/com/sap/sailing/domain/racelogtracking/test/impl/TrackedRaceLoadsFixesTest.java
| ... | ... | @@ -77,12 +77,12 @@ public class TrackedRaceLoadsFixesTest extends AbstractGPSFixStoreTest { |
| 77 | 77 | defineMarksOnRegattaLog(mark, mark2); |
| 78 | 78 | map(comp, device, 0, 10000); |
| 79 | 79 | map(mark, markDevice, 0, 10000); |
| 80 | - store.storeFix(device, createFix(100, 10, 20, 30, 40), /* filterByRegattaAndEventEndDate */ false); // before |
|
| 81 | - store.storeFix(device, createFix(1100, 10, 20, 30, 40), /* filterByRegattaAndEventEndDate */ false); // in |
|
| 82 | - store.storeFix(device, createFix(2100, 10, 20, 30, 40), /* filterByRegattaAndEventEndDate */ false); // after |
|
| 83 | - store.storeFix(markDevice, createFix(100, 10, 20), /* filterByRegattaAndEventEndDate */ false); |
|
| 84 | - store.storeFix(markDevice, createFix(1100, 10, 20), /* filterByRegattaAndEventEndDate */ false); |
|
| 85 | - store.storeFix(markDevice, createFix(2100, 10, 20), /* filterByRegattaAndEventEndDate */ false); |
|
| 80 | + store.storeFix(device, createFix(100, 10, 20, 30, 40)); // before |
|
| 81 | + store.storeFix(device, createFix(1100, 10, 20, 30, 40)); // in |
|
| 82 | + store.storeFix(device, createFix(2100, 10, 20, 30, 40)); // after |
|
| 83 | + store.storeFix(markDevice, createFix(100, 10, 20)); |
|
| 84 | + store.storeFix(markDevice, createFix(1100, 10, 20)); |
|
| 85 | + store.storeFix(markDevice, createFix(2100, 10, 20)); |
|
| 86 | 86 | final DynamicTrackedRaceImpl trackedRace = createDynamicTrackedRace(boatClass, raceDefinition); |
| 87 | 87 | trackedRace.setStartOfTrackingReceived(new MillisecondsTimePoint(1000)); |
| 88 | 88 | trackedRace.setEndOfTrackingReceived(new MillisecondsTimePoint(2000)); |
| ... | ... | @@ -114,16 +114,16 @@ public class TrackedRaceLoadsFixesTest extends AbstractGPSFixStoreTest { |
| 114 | 114 | // reuse device for two marks |
| 115 | 115 | map(mark, device3, 0, 600); |
| 116 | 116 | map(mark2, device3, 0, 600); |
| 117 | - store.storeFix(device, createFix(100, 10, 20, 30, 40), /* filterByRegattaAndEventEndDate */ false); |
|
| 118 | - store.storeFix(device, createFix(200, 10, 20, 30, 40), /* filterByRegattaAndEventEndDate */ false); |
|
| 119 | - store.storeFix(device2, createFix(100, 10, 20, 30, 40), /* filterByRegattaAndEventEndDate */ false); |
|
| 120 | - store.storeFix(device3, createFix(100, 10, 20), /* filterByRegattaAndEventEndDate */ false); |
|
| 121 | - store.storeFix(device3, createFix(100, 10, 20), /* filterByRegattaAndEventEndDate */ false); |
|
| 117 | + store.storeFix(device, createFix(100, 10, 20, 30, 40)); |
|
| 118 | + store.storeFix(device, createFix(200, 10, 20, 30, 40)); |
|
| 119 | + store.storeFix(device2, createFix(100, 10, 20, 30, 40)); |
|
| 120 | + store.storeFix(device3, createFix(100, 10, 20)); |
|
| 121 | + store.storeFix(device3, createFix(100, 10, 20)); |
|
| 122 | 122 | final List<GPSFixMoving> fixes = new ArrayList<>(); |
| 123 | 123 | for (int i = 0; i < 10000; i++) { |
| 124 | 124 | fixes.add(createFix(i + 1000, 10, 20, 30, 40)); |
| 125 | 125 | } |
| 126 | - store.storeFixes(device, fixes, /* returnManeuverUpdate */ false, /* returnLiveDelay */ false, /* filterByRegattaAndEventEndDate */ false); |
|
| 126 | + store.storeFixes(device, fixes, /* returnManeuverUpdate */ false, /* returnLiveDelay */ false); |
|
| 127 | 127 | DynamicTrackedRace trackedRace = createDynamicTrackedRace(boatClass, raceDefinition); |
| 128 | 128 | new FixLoaderAndTracker(trackedRace, store, null, /* removeOutliersFromCompetitorTracks */ false); |
| 129 | 129 | raceLog.add(new RaceLogStartOfTrackingEventImpl(TimePoint.BeginningOfTime, author, 0)); |
| ... | ... | @@ -141,8 +141,8 @@ public class TrackedRaceLoadsFixesTest extends AbstractGPSFixStoreTest { |
| 141 | 141 | throws InterruptedException { |
| 142 | 142 | testFixes(/* start of tracking */ 200, /* end of tracking */ 300, /* mappings and fixes */ () -> { |
| 143 | 143 | map(comp, device, 0, 100); |
| 144 | - store.storeFix(device, createFix(10, 10, 20, 30, 40), /* filterByRegattaAndEventEndDate */ false); |
|
| 145 | - store.storeFix(device, createFix(20, 10, 20, 30, 40), /* filterByRegattaAndEventEndDate */ false); |
|
| 144 | + store.storeFix(device, createFix(10, 10, 20, 30, 40)); |
|
| 145 | + store.storeFix(device, createFix(20, 10, 20, 30, 40)); |
|
| 146 | 146 | }, /* tests and expectations */ trackedRace -> testNumberOfRawFixes(trackedRace.getTrack(comp), 0)); |
| 147 | 147 | } |
| 148 | 148 | |
| ... | ... | @@ -151,12 +151,12 @@ public class TrackedRaceLoadsFixesTest extends AbstractGPSFixStoreTest { |
| 151 | 151 | throws InterruptedException { |
| 152 | 152 | testFixes(/* start of tracking */ 100, /* end of tracking */ 300, /* mappings and fixes */ () -> { |
| 153 | 153 | map(comp, device, 0, 200); |
| 154 | - store.storeFix(device, createFix(50, 10, 20, 30, 40), /* filterByRegattaAndEventEndDate */ false); |
|
| 155 | - store.storeFix(device, createFix(150, 10, 20, 30, 40), /* filterByRegattaAndEventEndDate */ false); |
|
| 156 | - store.storeFix(device, createFix(250, 10, 20, 30, 40), /* filterByRegattaAndEventEndDate */ false); |
|
| 154 | + store.storeFix(device, createFix(50, 10, 20, 30, 40)); |
|
| 155 | + store.storeFix(device, createFix(150, 10, 20, 30, 40)); |
|
| 156 | + store.storeFix(device, createFix(250, 10, 20, 30, 40)); |
|
| 157 | 157 | map(comp, device, 350, 500); |
| 158 | - store.storeFix(device, createFix(400, 10, 20, 30, 40), /* filterByRegattaAndEventEndDate */ false); |
|
| 159 | - store.storeFix(device, createFix(450, 10, 20, 30, 40), /* filterByRegattaAndEventEndDate */ false); |
|
| 158 | + store.storeFix(device, createFix(400, 10, 20, 30, 40)); |
|
| 159 | + store.storeFix(device, createFix(450, 10, 20, 30, 40)); |
|
| 160 | 160 | }, /* tests and expectations */ trackedRace -> testNumberOfRawFixes(trackedRace.getTrack(comp), 1)); |
| 161 | 161 | } |
| 162 | 162 | |
| ... | ... | @@ -165,10 +165,10 @@ public class TrackedRaceLoadsFixesTest extends AbstractGPSFixStoreTest { |
| 165 | 165 | testFixes(/* start of tracking */ 10, /* end of tracking */ 500, /* mappings and fixes */ () -> { |
| 166 | 166 | map(comp, device, 0, 200); |
| 167 | 167 | map(comp, device, 300, 400); |
| 168 | - store.storeFix(device, createFix(50, 10, 20, 30, 40), /* filterByRegattaAndEventEndDate */ false); // in first mapping |
|
| 169 | - store.storeFix(device, createFix(150, 10, 20, 30, 40), /* filterByRegattaAndEventEndDate */ false); // in first mapping |
|
| 170 | - store.storeFix(device, createFix(250, 10, 20, 30, 40), /* filterByRegattaAndEventEndDate */ false); // outside both mappings |
|
| 171 | - store.storeFix(device, createFix(350, 10, 20, 30, 40), /* filterByRegattaAndEventEndDate */ false); // in second mapping |
|
| 168 | + store.storeFix(device, createFix(50, 10, 20, 30, 40)); // in first mapping |
|
| 169 | + store.storeFix(device, createFix(150, 10, 20, 30, 40)); // in first mapping |
|
| 170 | + store.storeFix(device, createFix(250, 10, 20, 30, 40)); // outside both mappings |
|
| 171 | + store.storeFix(device, createFix(350, 10, 20, 30, 40)); // in second mapping |
|
| 172 | 172 | }, /* tests and expectations */ trackedRace -> { |
| 173 | 173 | final int[] fixInsertionCount = new int[1]; |
| 174 | 174 | trackedRace.getTrack(comp).addListener(new GPSTrackListener<Competitor, GPSFixMoving>() { |
| ... | ... | @@ -207,10 +207,10 @@ public class TrackedRaceLoadsFixesTest extends AbstractGPSFixStoreTest { |
| 207 | 207 | testFixes(/* start of tracking */ 10, /* end of tracking */ 500, /* mappings and fixes */ () -> { |
| 208 | 208 | map(comp, device, 0, 200); |
| 209 | 209 | map(comp, device, 300, 400); |
| 210 | - store.storeFix(device, createFix(50, 10, 20, 30, 40), /* filterByRegattaAndEventEndDate */ false); // in first mapping |
|
| 211 | - store.storeFix(device, createFix(150, 10, 20, 30, 40), /* filterByRegattaAndEventEndDate */ false); // in first mapping |
|
| 212 | - store.storeFix(device, createFix(250, 10, 20, 30, 40), /* filterByRegattaAndEventEndDate */ false); // outside both mappings |
|
| 213 | - store.storeFix(device, createFix(350, 10, 20, 30, 40), /* filterByRegattaAndEventEndDate */ false); // in second mapping |
|
| 210 | + store.storeFix(device, createFix(50, 10, 20, 30, 40)); // in first mapping |
|
| 211 | + store.storeFix(device, createFix(150, 10, 20, 30, 40)); // in first mapping |
|
| 212 | + store.storeFix(device, createFix(250, 10, 20, 30, 40)); // outside both mappings |
|
| 213 | + store.storeFix(device, createFix(350, 10, 20, 30, 40)); // in second mapping |
|
| 214 | 214 | }, /* tests and expectations */ trackedRace -> { |
| 215 | 215 | map(comp, device, 0, 500); // covers fix at 250ms |
| 216 | 216 | try { |
| ... | ... | @@ -218,7 +218,7 @@ public class TrackedRaceLoadsFixesTest extends AbstractGPSFixStoreTest { |
| 218 | 218 | } catch (Exception e) { |
| 219 | 219 | logger.log(Level.SEVERE, "Exception waiting for loading to finish", e); |
| 220 | 220 | } |
| 221 | - store.storeFix(device, createFix(400, 10, 20, 30, 40), /* filterByRegattaAndEventEndDate */ false); // in third mapping |
|
| 221 | + store.storeFix(device, createFix(400, 10, 20, 30, 40)); // in third mapping |
|
| 222 | 222 | testNumberOfRawFixes(trackedRace.getTrack(comp), 5); |
| 223 | 223 | }); |
| 224 | 224 | } |
| ... | ... | @@ -233,8 +233,8 @@ public class TrackedRaceLoadsFixesTest extends AbstractGPSFixStoreTest { |
| 233 | 233 | final long bestFixOffset = 20; |
| 234 | 234 | testFixes(/* start of tracking */ startOfTracking, /* end of tracking */ 300, /* mappings and fixes */ () -> { |
| 235 | 235 | map(mark, device, 0, 100); |
| 236 | - store.storeFix(device, createFix(10, 10, 20), /* filterByRegattaAndEventEndDate */ false); |
|
| 237 | - store.storeFix(device, createFix(bestFixOffset, 10, 20), /* filterByRegattaAndEventEndDate */ false); |
|
| 236 | + store.storeFix(device, createFix(10, 10, 20)); |
|
| 237 | + store.storeFix(device, createFix(bestFixOffset, 10, 20)); |
|
| 238 | 238 | }, /* tests and expectations */ trackedRace -> { |
| 239 | 239 | testNumberOfRawFixes(trackedRace.getOrCreateTrack(mark), 1); |
| 240 | 240 | assertEquals(bestFixOffset, trackedRace.getOrCreateTrack(mark) |
| ... | ... | @@ -248,9 +248,9 @@ public class TrackedRaceLoadsFixesTest extends AbstractGPSFixStoreTest { |
| 248 | 248 | throws InterruptedException { |
| 249 | 249 | testFixes(/* start of tracking */ 400, /* end of tracking */ 500, /* mappings and fixes */ () -> { |
| 250 | 250 | map(mark, device, 0, 100); |
| 251 | - store.storeFix(device, createFix(50, 10, 20), /* filterByRegattaAndEventEndDate */ false); |
|
| 251 | + store.storeFix(device, createFix(50, 10, 20)); |
|
| 252 | 252 | map(mark2, device, 200, 300); |
| 253 | - store.storeFix(device, createFix(250, 10, 20), /* filterByRegattaAndEventEndDate */ false); |
|
| 253 | + store.storeFix(device, createFix(250, 10, 20)); |
|
| 254 | 254 | }, /* tests and expectations */ trackedRace -> { |
| 255 | 255 | testNumberOfRawFixes(trackedRace.getOrCreateTrack(mark), 1); |
| 256 | 256 | testNumberOfRawFixes(trackedRace.getOrCreateTrack(mark2), 1); |
| ... | ... | @@ -263,13 +263,13 @@ public class TrackedRaceLoadsFixesTest extends AbstractGPSFixStoreTest { |
| 263 | 263 | throws InterruptedException { |
| 264 | 264 | testFixes(/* start of tracking */ 100, /* end of tracking */ 300, /* mappings and fixes */ () -> { |
| 265 | 265 | map(mark, device, 0, 200); |
| 266 | - store.storeFix(device, createFix(50, 10, 20), /* filterByRegattaAndEventEndDate */ false); |
|
| 267 | - store.storeFix(device, createFix(150, 10, 20), /* filterByRegattaAndEventEndDate */ false); |
|
| 268 | - store.storeFix(device, createFix(250, 10, 20), /* filterByRegattaAndEventEndDate */ false); |
|
| 266 | + store.storeFix(device, createFix(50, 10, 20)); |
|
| 267 | + store.storeFix(device, createFix(150, 10, 20)); |
|
| 268 | + store.storeFix(device, createFix(250, 10, 20)); |
|
| 269 | 269 | |
| 270 | 270 | map(mark, device, 350, 500); |
| 271 | - store.storeFix(device, createFix(400, 10, 20), /* filterByRegattaAndEventEndDate */ false); |
|
| 272 | - store.storeFix(device, createFix(450, 10, 20), /* filterByRegattaAndEventEndDate */ false); |
|
| 271 | + store.storeFix(device, createFix(400, 10, 20)); |
|
| 272 | + store.storeFix(device, createFix(450, 10, 20)); |
|
| 273 | 273 | }, /* tests and expectations */ trackedRace -> { |
| 274 | 274 | testNumberOfRawFixes(trackedRace.getOrCreateTrack(mark), 1); |
| 275 | 275 | }); |
| ... | ... | @@ -286,12 +286,12 @@ public class TrackedRaceLoadsFixesTest extends AbstractGPSFixStoreTest { |
| 286 | 286 | public void testFixesBeforeStartOfTrackingForMarkAreLoadedWhenSettingStartOfTracking() throws InterruptedException { |
| 287 | 287 | testFixesInternal(/* start of tracking */ null, /* end of tracking */ null, /* mappings and fixes */ () -> { |
| 288 | 288 | map(mark, device, 0, 200); |
| 289 | - store.storeFix(device, createFix(50, 10, 20), /* filterByRegattaAndEventEndDate */ false); |
|
| 290 | - store.storeFix(device, createFix(150, 10, 20), /* filterByRegattaAndEventEndDate */ false); |
|
| 291 | - store.storeFix(device, createFix(250, 10, 20), /* filterByRegattaAndEventEndDate */ false); |
|
| 289 | + store.storeFix(device, createFix(50, 10, 20)); |
|
| 290 | + store.storeFix(device, createFix(150, 10, 20)); |
|
| 291 | + store.storeFix(device, createFix(250, 10, 20)); |
|
| 292 | 292 | map(mark, device, 350, 500); |
| 293 | - store.storeFix(device, createFix(400, 10, 20), /* filterByRegattaAndEventEndDate */ false); |
|
| 294 | - store.storeFix(device, createFix(450, 10, 20), /* filterByRegattaAndEventEndDate */ false); |
|
| 293 | + store.storeFix(device, createFix(400, 10, 20)); |
|
| 294 | + store.storeFix(device, createFix(450, 10, 20)); |
|
| 295 | 295 | }, /* tests track is initially empty */ trackedRace -> { |
| 296 | 296 | testNumberOfRawFixes(trackedRace.getOrCreateTrack(mark), 0); // still no start of tracking set |
| 297 | 297 | }, /* now set start of tracking */ trackedRace -> trackedRace.setStartOfTrackingReceived(new MillisecondsTimePoint(600)), |
| ... | ... | @@ -320,11 +320,11 @@ public class TrackedRaceLoadsFixesTest extends AbstractGPSFixStoreTest { |
| 320 | 320 | final long endOfTracking = 300; |
| 321 | 321 | testFixes(/* start of tracking */ startOfTracking, /* end of tracking */ endOfTracking, /* mappings and fixes */ () -> { |
| 322 | 322 | map(mark, device, 0, 200); |
| 323 | - store.storeFix(device, createFix(bestFixBeforeStartOfTrackingOffset, 10, 20), /* filterByRegattaAndEventEndDate */ false); |
|
| 324 | - store.storeFix(device, createFix(250, 10, 20), /* filterByRegattaAndEventEndDate */ false); |
|
| 323 | + store.storeFix(device, createFix(bestFixBeforeStartOfTrackingOffset, 10, 20)); |
|
| 324 | + store.storeFix(device, createFix(250, 10, 20)); |
|
| 325 | 325 | map(mark, device, 350, 500); |
| 326 | - store.storeFix(device, createFix(bestFixAfterEndOfTrackingOffset, 10, 20), /* filterByRegattaAndEventEndDate */ false); |
|
| 327 | - store.storeFix(device, createFix(450, 10, 20), /* filterByRegattaAndEventEndDate */ false); |
|
| 326 | + store.storeFix(device, createFix(bestFixAfterEndOfTrackingOffset, 10, 20)); |
|
| 327 | + store.storeFix(device, createFix(450, 10, 20)); |
|
| 328 | 328 | }, /* tests and expectations */ trackedRace -> { |
| 329 | 329 | testNumberOfRawFixes(trackedRace.getOrCreateTrack(mark), 2); |
| 330 | 330 | assertEquals(bestFixBeforeStartOfTrackingOffset, trackedRace.getOrCreateTrack(mark) |
| ... | ... | @@ -344,19 +344,19 @@ public class TrackedRaceLoadsFixesTest extends AbstractGPSFixStoreTest { |
| 344 | 344 | final long endOfTracking = 300; |
| 345 | 345 | testFixes(/* start of tracking */ startOfTracking, /* end of tracking */ endOfTracking, /* mappings and fixes */ () -> { |
| 346 | 346 | map(mark, device, 0, 80); |
| 347 | - store.storeFix(device, createFix(50, 10, 20), /* filterByRegattaAndEventEndDate */ false); |
|
| 348 | - store.storeFix(device, createFix(70, 10, 20), /* filterByRegattaAndEventEndDate */ false); |
|
| 347 | + store.storeFix(device, createFix(50, 10, 20)); |
|
| 348 | + store.storeFix(device, createFix(70, 10, 20)); |
|
| 349 | 349 | map(mark, device, 100, 150); |
| 350 | - store.storeFix(device, createFix(120, 10, 20), /* filterByRegattaAndEventEndDate */ false); |
|
| 351 | - store.storeFix(device, createFix(bestFixBeforeStartOfTrackingOffset, 10, 20), /* filterByRegattaAndEventEndDate */ false); |
|
| 350 | + store.storeFix(device, createFix(120, 10, 20)); |
|
| 351 | + store.storeFix(device, createFix(bestFixBeforeStartOfTrackingOffset, 10, 20)); |
|
| 352 | 352 | |
| 353 | 353 | map(mark, device, 400, 500); |
| 354 | - store.storeFix(device, createFix(420, 10, 20), /* filterByRegattaAndEventEndDate */ false); |
|
| 355 | - store.storeFix(device, createFix(450, 10, 20), /* filterByRegattaAndEventEndDate */ false); |
|
| 356 | - store.storeFix(device, createFix(480, 10, 20), /* filterByRegattaAndEventEndDate */ false); |
|
| 354 | + store.storeFix(device, createFix(420, 10, 20)); |
|
| 355 | + store.storeFix(device, createFix(450, 10, 20)); |
|
| 356 | + store.storeFix(device, createFix(480, 10, 20)); |
|
| 357 | 357 | map(mark, device, 350, 390); |
| 358 | - store.storeFix(device, createFix(bestFixAfterEndOfTrackingOffset, 10, 20), /* filterByRegattaAndEventEndDate */ false); |
|
| 359 | - store.storeFix(device, createFix(380, 10, 20), /* filterByRegattaAndEventEndDate */ false); |
|
| 358 | + store.storeFix(device, createFix(bestFixAfterEndOfTrackingOffset, 10, 20)); |
|
| 359 | + store.storeFix(device, createFix(380, 10, 20)); |
|
| 360 | 360 | }, /* tests and expectations */ trackedRace -> { |
| 361 | 361 | testNumberOfRawFixes(trackedRace.getOrCreateTrack(mark), 2); |
| 362 | 362 | assertEquals(bestFixBeforeStartOfTrackingOffset, trackedRace.getOrCreateTrack(mark) |
| ... | ... | @@ -376,14 +376,14 @@ public class TrackedRaceLoadsFixesTest extends AbstractGPSFixStoreTest { |
| 376 | 376 | final long endOfTracking = 300; |
| 377 | 377 | testFixes(/* start of tracking */ startOfTracking, /* end of tracking */ endOfTracking, /* mappings and fixes */ () -> { |
| 378 | 378 | map(mark, device, bestFix1 - 20, bestFix1 + 10); |
| 379 | - store.storeFix(device, createFix(bestFix1 - 10, 10, 20), /* filterByRegattaAndEventEndDate */ false); |
|
| 380 | - store.storeFix(device, createFix(bestFix1, 10, 20), /* filterByRegattaAndEventEndDate */ false); |
|
| 379 | + store.storeFix(device, createFix(bestFix1 - 10, 10, 20)); |
|
| 380 | + store.storeFix(device, createFix(bestFix1, 10, 20)); |
|
| 381 | 381 | }, /* tests and expectations */ trackedRace -> { |
| 382 | 382 | testNumberOfRawFixes(trackedRace.getOrCreateTrack(mark), 1); |
| 383 | 383 | assertEquals(bestFix1, trackedRace.getOrCreateTrack(mark) |
| 384 | 384 | .getLastFixBefore(new MillisecondsTimePoint(startOfTracking)).getTimePoint().asMillis()); |
| 385 | - store.storeFix(device, createFix(bestFix2 - 10, 10, 20), /* filterByRegattaAndEventEndDate */ false); |
|
| 386 | - store.storeFix(device, createFix(bestFix2, 10, 20), /* filterByRegattaAndEventEndDate */ false); |
|
| 385 | + store.storeFix(device, createFix(bestFix2 - 10, 10, 20)); |
|
| 386 | + store.storeFix(device, createFix(bestFix2, 10, 20)); |
|
| 387 | 387 | map(mark, device, bestFix2 - 20, bestFix2 + 10); |
| 388 | 388 | }, /* tests and expectations */ trackedRace -> { |
| 389 | 389 | testNumberOfRawFixes(trackedRace.getOrCreateTrack(mark), 2); |
| ... | ... | @@ -404,17 +404,17 @@ public class TrackedRaceLoadsFixesTest extends AbstractGPSFixStoreTest { |
| 404 | 404 | final long endOfTracking = 300; |
| 405 | 405 | testFixes(/* start of tracking */ startOfTracking, /* end of tracking */ endOfTracking, /* mappings and fixes */ () -> { |
| 406 | 406 | map(mark, device, bestFix1 - 10, bestFix1 + 10); |
| 407 | - store.storeFix(device, createFix(bestFix1, 10, 20), /* filterByRegattaAndEventEndDate */ false); |
|
| 407 | + store.storeFix(device, createFix(bestFix1, 10, 20)); |
|
| 408 | 408 | }, /* tests and expectations */ trackedRace -> { |
| 409 | 409 | testNumberOfRawFixes(trackedRace.getOrCreateTrack(mark), 1); |
| 410 | 410 | assertEquals(bestFix1, trackedRace.getOrCreateTrack(mark) |
| 411 | 411 | .getLastFixBefore(new MillisecondsTimePoint(startOfTracking)).getTimePoint().asMillis()); |
| 412 | - store.storeFix(device, createFix(startOfTracking + 10, 10, 20), /* filterByRegattaAndEventEndDate */ false); |
|
| 412 | + store.storeFix(device, createFix(startOfTracking + 10, 10, 20)); |
|
| 413 | 413 | map(mark, device, startOfTracking, startOfTracking + 20); |
| 414 | 414 | }, /* tests and expectations */ trackedRace -> { |
| 415 | 415 | testNumberOfRawFixes(trackedRace.getOrCreateTrack(mark), 2); |
| 416 | 416 | // would be the new best fix if there wasn't a fix in the tracking interval |
| 417 | - store.storeFix(device, createFix(bestFix2, 10, 20), /* filterByRegattaAndEventEndDate */ false); |
|
| 417 | + store.storeFix(device, createFix(bestFix2, 10, 20)); |
|
| 418 | 418 | map(mark, device, bestFix2 - 10, bestFix2 + 10); |
| 419 | 419 | }, /* tests and expectations */ trackedRace -> { |
| 420 | 420 | testNumberOfRawFixes(trackedRace.getOrCreateTrack(mark), 2); |
| ... | ... | @@ -428,7 +428,7 @@ public class TrackedRaceLoadsFixesTest extends AbstractGPSFixStoreTest { |
| 428 | 428 | throws TransformationException, NoCorrespondingServiceRegisteredException, InterruptedException { |
| 429 | 429 | testFixes(/* start of tracking */ 100, /* end of tracking */ 300, /* mappings */ () -> map(mark, device, 0, 200), |
| 430 | 430 | /* fixes and tests/expectations */ trackedRace -> { |
| 431 | - store.storeFix(device, createFix(50, 10, 20), /* filterByRegattaAndEventEndDate */ false); |
|
| 431 | + store.storeFix(device, createFix(50, 10, 20)); |
|
| 432 | 432 | testNumberOfRawFixes(trackedRace.getOrCreateTrack(mark), 1); |
| 433 | 433 | }); |
| 434 | 434 | } |
| ... | ... | @@ -437,7 +437,7 @@ public class TrackedRaceLoadsFixesTest extends AbstractGPSFixStoreTest { |
| 437 | 437 | public void testFixForMarkIsAddedIfAfterTrackingIntervalAndNoOtherFixExists() |
| 438 | 438 | throws TransformationException, NoCorrespondingServiceRegisteredException, InterruptedException { |
| 439 | 439 | testFixes(/* start of tracking */ 100, /* end of tracking */ 300, /* mappings */ () -> map(mark, device, 0, 400), /* fixes and tests/expectations */ trackedRace -> { |
| 440 | - store.storeFix(device, createFix(350, 10, 20), /* filterByRegattaAndEventEndDate */ false); |
|
| 440 | + store.storeFix(device, createFix(350, 10, 20)); |
|
| 441 | 441 | testNumberOfRawFixes(trackedRace.getOrCreateTrack(mark), 1); |
| 442 | 442 | }); |
| 443 | 443 | } |
| ... | ... | @@ -447,8 +447,8 @@ public class TrackedRaceLoadsFixesTest extends AbstractGPSFixStoreTest { |
| 447 | 447 | throws TransformationException, NoCorrespondingServiceRegisteredException, InterruptedException { |
| 448 | 448 | testFixes(/* start of tracking */ 100, /* end of tracking */ 300, /* mappings */ () -> map(mark, device, 0, 400), |
| 449 | 449 | /* fixes and tests/expectations */ trackedRace -> { |
| 450 | - store.storeFix(device, createFix(50, 10, 20), /* filterByRegattaAndEventEndDate */ false); |
|
| 451 | - store.storeFix(device, createFix(75, 10, 20), /* filterByRegattaAndEventEndDate */ false); |
|
| 450 | + store.storeFix(device, createFix(50, 10, 20)); |
|
| 451 | + store.storeFix(device, createFix(75, 10, 20)); |
|
| 452 | 452 | testNumberOfRawFixes(trackedRace.getOrCreateTrack(mark), 2); |
| 453 | 453 | }); |
| 454 | 454 | } |
| ... | ... | @@ -458,8 +458,8 @@ public class TrackedRaceLoadsFixesTest extends AbstractGPSFixStoreTest { |
| 458 | 458 | throws TransformationException, NoCorrespondingServiceRegisteredException, InterruptedException { |
| 459 | 459 | testFixes(/* start of tracking */ 100, /* end of tracking */ 300, /* mappings */ () -> map(mark, device, 0, 400), |
| 460 | 460 | /* fixes and tests/expectations */ trackedRace -> { |
| 461 | - store.storeFix(device, createFix(75, 10, 20), /* filterByRegattaAndEventEndDate */ false); |
|
| 462 | - store.storeFix(device, createFix(50, 10, 20), /* filterByRegattaAndEventEndDate */ false); |
|
| 461 | + store.storeFix(device, createFix(75, 10, 20)); |
|
| 462 | + store.storeFix(device, createFix(50, 10, 20)); |
|
| 463 | 463 | testNumberOfRawFixes(trackedRace.getOrCreateTrack(mark), 1); |
| 464 | 464 | }); |
| 465 | 465 | } |
| ... | ... | @@ -469,8 +469,8 @@ public class TrackedRaceLoadsFixesTest extends AbstractGPSFixStoreTest { |
| 469 | 469 | throws TransformationException, NoCorrespondingServiceRegisteredException, InterruptedException { |
| 470 | 470 | testFixes(/* start of tracking */ 100, /* end of tracking */ 300, /* mappings */ () -> map(mark, device, 0, 400), |
| 471 | 471 | /* fixes and tests/expectations */ trackedRace -> { |
| 472 | - store.storeFix(device, createFix(375, 10, 20), /* filterByRegattaAndEventEndDate */ false); |
|
| 473 | - store.storeFix(device, createFix(350, 10, 20), /* filterByRegattaAndEventEndDate */ false); |
|
| 472 | + store.storeFix(device, createFix(375, 10, 20)); |
|
| 473 | + store.storeFix(device, createFix(350, 10, 20)); |
|
| 474 | 474 | testNumberOfRawFixes(trackedRace.getOrCreateTrack(mark), 2); |
| 475 | 475 | }); |
| 476 | 476 | } |
| ... | ... | @@ -480,8 +480,8 @@ public class TrackedRaceLoadsFixesTest extends AbstractGPSFixStoreTest { |
| 480 | 480 | throws TransformationException, NoCorrespondingServiceRegisteredException, InterruptedException { |
| 481 | 481 | testFixes(/* start of tracking */ 100, /* end of tracking */ 300, /* mappings */ () -> map(mark, device, 0, 400), |
| 482 | 482 | /* fixes and tests/expectations */ trackedRace -> { |
| 483 | - store.storeFix(device, createFix(350, 10, 20), /* filterByRegattaAndEventEndDate */ false); |
|
| 484 | - store.storeFix(device, createFix(375, 10, 20), /* filterByRegattaAndEventEndDate */ false); |
|
| 483 | + store.storeFix(device, createFix(350, 10, 20)); |
|
| 484 | + store.storeFix(device, createFix(375, 10, 20)); |
|
| 485 | 485 | testNumberOfRawFixes(trackedRace.getOrCreateTrack(mark), 1); |
| 486 | 486 | }); |
| 487 | 487 | } |
| ... | ... | @@ -491,9 +491,9 @@ public class TrackedRaceLoadsFixesTest extends AbstractGPSFixStoreTest { |
| 491 | 491 | throws TransformationException, NoCorrespondingServiceRegisteredException, InterruptedException { |
| 492 | 492 | testFixes(/* start of tracking */ 100, /* end of tracking */ 300, /* mappings */ () -> map(mark, device, 0, 400), |
| 493 | 493 | /* fixes and tests/expectations */ trackedRace -> { |
| 494 | - store.storeFix(device, createFix(200, 10, 20), /* filterByRegattaAndEventEndDate */ false); |
|
| 495 | - store.storeFix(device, createFix(50, 10, 20), /* filterByRegattaAndEventEndDate */ false); |
|
| 496 | - store.storeFix(device, createFix(350, 10, 20), /* filterByRegattaAndEventEndDate */ false); |
|
| 494 | + store.storeFix(device, createFix(200, 10, 20)); |
|
| 495 | + store.storeFix(device, createFix(50, 10, 20)); |
|
| 496 | + store.storeFix(device, createFix(350, 10, 20)); |
|
| 497 | 497 | testNumberOfRawFixes(trackedRace.getOrCreateTrack(mark), 1); |
| 498 | 498 | }); |
| 499 | 499 | } |
| ... | ... | @@ -530,8 +530,8 @@ public class TrackedRaceLoadsFixesTest extends AbstractGPSFixStoreTest { |
| 530 | 530 | assertEquals(0, store.getNumberOfFixes(device)); |
| 531 | 531 | assertEquals(null, store.getTimeRangeCoveredByFixes(device)); |
| 532 | 532 | map(comp, device, 0, 600); |
| 533 | - store.storeFix(device, createFix(100, 10, 20, 30, 40), /* filterByRegattaAndEventEndDate */ false); |
|
| 534 | - store.storeFix(device, createFix(200, 10, 20, 30, 40), /* filterByRegattaAndEventEndDate */ false); |
|
| 533 | + store.storeFix(device, createFix(100, 10, 20, 30, 40)); |
|
| 534 | + store.storeFix(device, createFix(200, 10, 20, 30, 40)); |
|
| 535 | 535 | assertEquals(2, store.getNumberOfFixes(device)); |
| 536 | 536 | assertEquals(TimeRangeImpl.create(100, 200, /* toIsInclusive */ true), store.getTimeRangeCoveredByFixes(device)); |
| 537 | 537 | assertEquals(new DegreePosition(10, 20), ((GPSFix) store.getFixLastReceived(Collections.singleton(device)).get(device)).getPosition()); |
| ... | ... | @@ -539,26 +539,26 @@ public class TrackedRaceLoadsFixesTest extends AbstractGPSFixStoreTest { |
| 539 | 539 | |
| 540 | 540 | @Test |
| 541 | 541 | public void testFindLatestFixForMapping() throws TransformationException, NoCorrespondingServiceRegisteredException { |
| 542 | - store.storeFix(device, createFix(100, 10, 20, 30, 40), /* filterByRegattaAndEventEndDate */ false); |
|
| 543 | - store.storeFix(device, createFix(1100, 10, 20, 30, 40), /* filterByRegattaAndEventEndDate */ false); |
|
| 544 | - store.storeFix(device, createFix(2100, 10, 20, 30, 40), /* filterByRegattaAndEventEndDate */ false); |
|
| 542 | + store.storeFix(device, createFix(100, 10, 20, 30, 40)); |
|
| 543 | + store.storeFix(device, createFix(1100, 10, 20, 30, 40)); |
|
| 544 | + store.storeFix(device, createFix(2100, 10, 20, 30, 40)); |
|
| 545 | 545 | final Map<DeviceIdentifier, Timed> lastFixes = store.getFixLastReceived(Collections.singleton(device)); |
| 546 | 546 | assertEquals(1, lastFixes.size()); |
| 547 | 547 | Timed lastFix = lastFixes.get(device); |
| 548 | 548 | assertEquals(2100, lastFix.getTimePoint().asMillis()); |
| 549 | - store.storeFix(device, createFix(2000, 10, 20, 30, 40), /* filterByRegattaAndEventEndDate */ false); |
|
| 549 | + store.storeFix(device, createFix(2000, 10, 20, 30, 40)); |
|
| 550 | 550 | final Map<DeviceIdentifier, Timed> lastFixes2 = store.getFixLastReceived(Collections.singleton(device)); |
| 551 | 551 | assertEquals(1, lastFixes2.size()); |
| 552 | 552 | Timed lastFix2 = lastFixes2.get(device); |
| 553 | 553 | assertEquals(2000, lastFix2.getTimePoint().asMillis()); // not the fix with the latest time point but the fix that was last received by the store |
| 554 | - store.storeFix(device, createFix(2200, 10, 20, 30, 40), /* filterByRegattaAndEventEndDate */ false); |
|
| 554 | + store.storeFix(device, createFix(2200, 10, 20, 30, 40)); |
|
| 555 | 555 | final Map<DeviceIdentifier, Timed> lastFixes3 = store.getFixLastReceived(Collections.singleton(device)); |
| 556 | 556 | assertEquals(1, lastFixes3.size()); |
| 557 | 557 | Timed lastFix3 = lastFixes3.get(device); |
| 558 | 558 | assertEquals(2200, lastFix3.getTimePoint().asMillis()); |
| 559 | 559 | final DeviceIdentifier device2 = new SmartphoneImeiIdentifierImpl("b"); |
| 560 | - store.storeFix(device2, createFix(1200, 10, 20, 30, 40), /* filterByRegattaAndEventEndDate */ false); |
|
| 561 | - store.storeFix(device2, createFix(1100, 10, 20, 30, 40), /* filterByRegattaAndEventEndDate */ false); |
|
| 560 | + store.storeFix(device2, createFix(1200, 10, 20, 30, 40)); |
|
| 561 | + store.storeFix(device2, createFix(1100, 10, 20, 30, 40)); |
|
| 562 | 562 | final Map<DeviceIdentifier, Timed> lastFixes4 = store.getFixLastReceived(Arrays.asList(device, device2)); |
| 563 | 563 | assertEquals(2, lastFixes4.size()); |
| 564 | 564 | Timed lastFix4 = lastFixes4.get(device); |
java/com.sap.sailing.domain.racelogtrackingadapter/src/com/sap/sailing/domain/racelogtracking/impl/RaceLogTrackingAdapterImpl.java
| ... | ... | @@ -283,7 +283,7 @@ public class RaceLogTrackingAdapterImpl implements RaceLogTrackingAdapter { |
| 283 | 283 | UUID.randomUUID(), mark, device, timePoint, timePoint); |
| 284 | 284 | log.add(mapping); |
| 285 | 285 | try { |
| 286 | - service.getSensorFixStore().storeFix(device, gpsFix, /* filterByRegattaAndEventEndDate */ false); |
|
| 286 | + service.getSensorFixStore().storeFix(device, gpsFix); |
|
| 287 | 287 | } catch (NoCorrespondingServiceRegisteredException e) { |
| 288 | 288 | logger.log(Level.WARNING, "Could not ping mark " + mark); |
| 289 | 289 | } |
java/com.sap.sailing.domain/src/com/sap/sailing/domain/racelog/tracking/EmptySensorFixStore.java
| ... | ... | @@ -54,12 +54,12 @@ public enum EmptySensorFixStore implements SensorFixStore { |
| 54 | 54 | } |
| 55 | 55 | |
| 56 | 56 | @Override |
| 57 | - public <FixT extends Timed> void storeFix(DeviceIdentifier device, FixT fix, boolean filterByRegattaAndEventEndDate) { |
|
| 57 | + public <FixT extends Timed> void storeFix(DeviceIdentifier device, FixT fix) { |
|
| 58 | 58 | } |
| 59 | 59 | |
| 60 | 60 | @Override |
| 61 | 61 | public <FixT extends Timed> Iterable<Triple<RegattaAndRaceIdentifier, Boolean, Duration>> storeFixes(DeviceIdentifier device, |
| 62 | - Iterable<FixT> fixes, boolean returnManeuverUpdate, boolean returnLiveDelay, boolean filterByRegattaAndEventEndDate) { |
|
| 62 | + Iterable<FixT> fixes, boolean returnManeuverUpdate, boolean returnLiveDelay) { |
|
| 63 | 63 | return Collections.emptySet(); |
| 64 | 64 | } |
| 65 | 65 |
java/com.sap.sailing.domain/src/com/sap/sailing/domain/racelog/tracking/SensorFixStore.java
| ... | ... | @@ -65,15 +65,8 @@ public interface SensorFixStore { |
| 65 | 65 | * the device to store the fix for. Must not be <code>null</code>. |
| 66 | 66 | * @param fix |
| 67 | 67 | * The fix to store. Must not be <code>null</code>. |
| 68 | - * @param filterByRegattaAndEventEndDate |
|
| 69 | - * if {@code true}, then when forwarding this fix to this store's |
|
| 70 | - * {@link #addListener(FixReceivedListener, DeviceIdentifier) listeners}, this parameter is passed on to |
|
| 71 | - * {@link FixReceivedListener#fixReceived(DeviceIdentifier, Timed, boolean, boolean)}. It leads |
|
| 72 | - * to the fix's {@link Timed#getTimePoint() time point} being matched against the end date of any regatta |
|
| 73 | - * and event that this listener is responsible for; then, fixes that are newer than these end dates are |
|
| 74 | - * dropped and not recorded |
|
| 75 | 68 | */ |
| 76 | - <FixT extends Timed> void storeFix(DeviceIdentifier device, FixT fix, boolean filterByRegattaAndEventEndDate); |
|
| 69 | + <FixT extends Timed> void storeFix(DeviceIdentifier device, FixT fix); |
|
| 77 | 70 | |
| 78 | 71 | /** |
| 79 | 72 | * Saves a batch of fixes for the given device and informs all registered listeners about the new fix. |
| ... | ... | @@ -92,13 +85,6 @@ public interface SensorFixStore { |
| 92 | 85 | * if {@code true} then all listeners to which the fix is forwarded shall check to which races the fix |
| 93 | 86 | * maps and report the live delay for all those races as the third component of the resulting |
| 94 | 87 | * {@link Triple}s. |
| 95 | - * @param filterByRegattaAndEventEndDate |
|
| 96 | - * if {@code true}, then when forwarding this fix to this store's |
|
| 97 | - * {@link #addListener(FixReceivedListener, DeviceIdentifier) listeners}, this parameter is passed on to |
|
| 98 | - * {@link FixReceivedListener#fixReceived(DeviceIdentifier, Timed, boolean, boolean)}. It leads |
|
| 99 | - * to the fix's {@link Timed#getTimePoint() time point} being matched against the end date of any regatta |
|
| 100 | - * and event that this listener is responsible for; then, fixes that are newer than these end dates are |
|
| 101 | - * dropped and not recorded |
|
| 102 | 88 | * @return An {@link Iterable} with {@link RegattaAndRaceIdentifier}s in their first component is returned that will |
| 103 | 89 | * contain races with new maneuvers which were not available at the last time the given device stored a fix |
| 104 | 90 | * in case the {@code returnManeuverUpdate} parameter was set to {@code true}, and all races with their live |
| ... | ... | @@ -107,11 +93,11 @@ public interface SensorFixStore { |
| 107 | 93 | * identifiers if the device mapping is currently ambiguous. |
| 108 | 94 | */ |
| 109 | 95 | <FixT extends Timed> Iterable<Triple<RegattaAndRaceIdentifier, Boolean, Duration>> storeFixes( |
| 110 | - DeviceIdentifier device, Iterable<FixT> fixes, boolean returnManeuverUpdate, boolean returnLiveDelay, boolean filterByRegattaAndEventEndDate); |
|
| 96 | + DeviceIdentifier device, Iterable<FixT> fixes, boolean returnManeuverUpdate, boolean returnLiveDelay); |
|
| 111 | 97 | |
| 112 | 98 | /** |
| 113 | 99 | * Listeners are notified, whenever a {@link GPSFix} submitted by the {@code device} |
| 114 | - * is stored through the {@link #storeFix(DeviceIdentifier, GPSFix, boolean)} method. |
|
| 100 | + * is stored through the {@link #storeFix(DeviceIdentifier, GPSFix)} method. |
|
| 115 | 101 | */ |
| 116 | 102 | void addListener(FixReceivedListener<? extends Timed> listener, DeviceIdentifier device); |
| 117 | 103 |
java/com.sap.sailing.expeditionconnector.test/src/com/sap/sailing/expeditionconnector/test/UDPExpeditionReceiverTest.java
| ... | ... | @@ -144,7 +144,7 @@ public class UDPExpeditionReceiverTest { |
| 144 | 144 | } |
| 145 | 145 | |
| 146 | 146 | @Override |
| 147 | - public <FixT extends Timed> void storeFix(DeviceIdentifier device, FixT fix, boolean filterByRegattaAndEventEndDate) { |
|
| 147 | + public <FixT extends Timed> void storeFix(DeviceIdentifier device, FixT fix) { |
|
| 148 | 148 | List<Timed> fixesReceivedFromDevice = fixesReceived.get(device); |
| 149 | 149 | if (fixesReceivedFromDevice == null) { |
| 150 | 150 | fixesReceivedFromDevice = new ArrayList<>(); |
| ... | ... | @@ -155,9 +155,9 @@ public class UDPExpeditionReceiverTest { |
| 155 | 155 | |
| 156 | 156 | @Override |
| 157 | 157 | public <FixT extends Timed> Iterable<Triple<RegattaAndRaceIdentifier, Boolean, Duration>> storeFixes(DeviceIdentifier device, |
| 158 | - Iterable<FixT> fixes, boolean returnManeuverUpdate, boolean returnLiveDelay, boolean filterByRegattaAndEventEndDate) { |
|
| 158 | + Iterable<FixT> fixes, boolean returnManeuverUpdate, boolean returnLiveDelay) { |
|
| 159 | 159 | for (final FixT fix : fixes) { |
| 160 | - storeFix(device, fix, /* filterByRegattaAndEventEndDate */ false); |
|
| 160 | + storeFix(device, fix); |
|
| 161 | 161 | } |
| 162 | 162 | return Collections.emptySet(); |
| 163 | 163 | } |
java/com.sap.sailing.expeditionconnector/src/com/sap/sailing/expeditionconnector/UDPExpeditionReceiver.java
| ... | ... | @@ -131,7 +131,7 @@ public class UDPExpeditionReceiver extends UDPReceiver<ExpeditionMessage, Expedi |
| 131 | 131 | } |
| 132 | 132 | final DoubleVectorFix fix = new DoubleVectorFixImpl(msg.getTimePoint(), vector); |
| 133 | 133 | if (fix.hasValidData()) { |
| 134 | - deviceRegistry.getSensorFixStore().storeFix(sensorDeviceIdentifier, fix, /* filterByRegattaAndEventEndDate */ false); |
|
| 134 | + deviceRegistry.getSensorFixStore().storeFix(sensorDeviceIdentifier, fix); |
|
| 135 | 135 | } |
| 136 | 136 | } |
| 137 | 137 | |
| ... | ... | @@ -142,7 +142,7 @@ public class UDPExpeditionReceiver extends UDPReceiver<ExpeditionMessage, Expedi |
| 142 | 142 | private void tryToProduceAndStoreGpsFix(ExpeditionMessage msg, ExpeditionGpsDeviceIdentifier gpsDeviceIdentifier) { |
| 143 | 143 | final GPSFixMoving fix = msg.getGPSFixMoving(); |
| 144 | 144 | if (fix != null) { |
| 145 | - deviceRegistry.getSensorFixStore().storeFix(gpsDeviceIdentifier, fix, /* filterByRegattaAndEventEndDate */ false); |
|
| 145 | + deviceRegistry.getSensorFixStore().storeFix(gpsDeviceIdentifier, fix); |
|
| 146 | 146 | } |
| 147 | 147 | } |
| 148 | 148 |
java/com.sap.sailing.server.gateway/src/com/sap/sailing/server/gateway/jaxrs/api/GPSFixesResource.java
| ... | ... | @@ -64,7 +64,7 @@ public class GPSFixesResource extends AbstractSailingServerResource { |
| 64 | 64 | List<GPSFixMoving> fixes = data.getB(); |
| 65 | 65 | JSONObject answer = new JSONObject(); |
| 66 | 66 | try { |
| 67 | - Iterable<Triple<RegattaAndRaceIdentifier, Boolean, Duration>> racesWithManeuverChangedAndLiveDelay = getService().getSensorFixStore().storeFixes(device, fixes, returnManeuverUpdate, returnLiveDelay, /* filterByRegattaAndEventEndDate */ false); |
|
| 67 | + Iterable<Triple<RegattaAndRaceIdentifier, Boolean, Duration>> racesWithManeuverChangedAndLiveDelay = getService().getSensorFixStore().storeFixes(device, fixes, returnManeuverUpdate, returnLiveDelay); |
|
| 68 | 68 | if (!Util.isEmpty(racesWithManeuverChangedAndLiveDelay)) { |
| 69 | 69 | JSONArray changed = new JSONArray(); |
| 70 | 70 | answer.put("maneuverchanged", changed); |
java/com.sap.sailing.server.gateway/src/com/sap/sailing/server/gateway/trackfiles/impl/SensorDataImporter.java
| ... | ... | @@ -98,7 +98,7 @@ public class SensorDataImporter { |
| 98 | 98 | |
| 99 | 99 | private void storeFixes(Iterable<DoubleVectorFix> fixes, DeviceIdentifier deviceIdentifier) { |
| 100 | 100 | try { |
| 101 | - service.getSensorFixStore().storeFixes(deviceIdentifier, fixes, /* returnManeuverUpdate */ false, /* returnLiveDelay */ false, /* filterByRegattaAndEventEndDate */ true); |
|
| 101 | + service.getSensorFixStore().storeFixes(deviceIdentifier, fixes, /* returnManeuverUpdate */ false, /* returnLiveDelay */ false); |
|
| 102 | 102 | } catch (NoCorrespondingServiceRegisteredException e) { |
| 103 | 103 | logger.log(Level.WARNING, "Could not store fix for " + deviceIdentifier); |
| 104 | 104 | } |
java/com.sap.sailing.server.gateway/src/com/sap/sailing/server/gateway/trackfiles/impl/TrackFilesImporter.java
| ... | ... | @@ -131,7 +131,7 @@ public class TrackFilesImporter { |
| 131 | 131 | |
| 132 | 132 | void storeFix(GPSFix fix, DeviceIdentifier deviceIdentifier) { |
| 133 | 133 | try { |
| 134 | - service.getSensorFixStore().storeFix(deviceIdentifier, fix, /* filterByRegattaAndEventEndDate */ true); |
|
| 134 | + service.getSensorFixStore().storeFix(deviceIdentifier, fix); |
|
| 135 | 135 | } catch (NoCorrespondingServiceRegisteredException e) { |
| 136 | 136 | logger.log(Level.WARNING, "Could not store fix for " + deviceIdentifier); |
| 137 | 137 | } |
| ... | ... | @@ -139,7 +139,7 @@ public class TrackFilesImporter { |
| 139 | 139 | |
| 140 | 140 | <FixT extends Timed> void storeFixes(Iterable<FixT> fixes, DeviceIdentifier deviceIdentifier) { |
| 141 | 141 | try { |
| 142 | - service.getSensorFixStore().storeFixes(deviceIdentifier, fixes, /* returnManeuverUpdate */ false, /* returnLiveDelay */ false, /* filterByRegattaAndEventEndDate */ true); |
|
| 142 | + service.getSensorFixStore().storeFixes(deviceIdentifier, fixes, /* returnManeuverUpdate */ false, /* returnLiveDelay */ false); |
|
| 143 | 143 | } catch (NoCorrespondingServiceRegisteredException e) { |
| 144 | 144 | logger.log(Level.WARNING, "Could not store fix for " + deviceIdentifier); |
| 145 | 145 | } |
java/com.sap.sailing.server.interface/src/com/sap/sailing/server/operationaltransformation/ImportMasterDataOperation.java
| ... | ... | @@ -547,7 +547,7 @@ public class ImportMasterDataOperation extends |
| 547 | 547 | |
| 548 | 548 | private void storeFixes(SensorFixStore store, DeviceIdentifier device, final Collection<Timed> fixesToAddAsBatch) { |
| 549 | 549 | try { |
| 550 | - store.storeFixes(device, fixesToAddAsBatch, /* returnManeuverUpdate */ false, /* returnLiveDelay */ false, /* filterByRegattaAndEventEndDate */ true); |
|
| 550 | + store.storeFixes(device, fixesToAddAsBatch, /* returnManeuverUpdate */ false, /* returnLiveDelay */ false); |
|
| 551 | 551 | fixesToAddAsBatch.clear(); |
| 552 | 552 | } catch (NoCorrespondingServiceRegisteredException e) { |
| 553 | 553 | logger.severe("Failed to store race log tracking fixes while importing."); |
java/com.sap.sailing.server.test/src/com/sap/sailing/server/test/MasterDataImportTest.java
| ... | ... | @@ -372,7 +372,7 @@ public class MasterDataImportTest { |
| 372 | 372 | regatta.getRegattaLog().add(mappingEvent); |
| 373 | 373 | GPSFix gpsFix = new GPSFixMovingImpl(new DegreePosition(54.333, 10.133), logTimePoint2, |
| 374 | 374 | new KnotSpeedWithBearingImpl(10, new DegreeBearingImpl(90)), /* optionalTrueHeading */ null); |
| 375 | - sourceService.getSensorFixStore().storeFix(deviceIdentifier, gpsFix, /* filterByRegattaAndEventEndDate */ false); |
|
| 375 | + sourceService.getSensorFixStore().storeFix(deviceIdentifier, gpsFix); |
|
| 376 | 376 | // test to check that batch-import of fixes works as intended |
| 377 | 377 | DeviceIdentifier deviceBatch1 = addDeviceMappingWithFixes(sourceService, regatta, competitor, logTimePoint, logTimePoint3, logTimePoint4, "x", 4999); |
| 378 | 378 | DeviceIdentifier deviceBatch2 = addDeviceMappingWithFixes(sourceService, regatta, competitor, logTimePoint, logTimePoint3, logTimePoint4, "y", 5000); |
| ... | ... | @@ -388,7 +388,7 @@ public class MasterDataImportTest { |
| 388 | 388 | fixData[BravoSensorDataMetadata.RIDE_HEIGHT_PORT_HULL.getColumnIndex()] = rideHeightValue; |
| 389 | 389 | fixData[BravoSensorDataMetadata.RIDE_HEIGHT_STBD_HULL.getColumnIndex()] = rideHeightValue; |
| 390 | 390 | DoubleVectorFixImpl doubleVectorFix = new DoubleVectorFixImpl(logTimePoint2, fixData); |
| 391 | - sourceService.getSensorFixStore().storeFix(deviceIdentifier2, doubleVectorFix, /* filterByRegattaAndEventEndDate */ false); |
|
| 391 | + sourceService.getSensorFixStore().storeFix(deviceIdentifier2, doubleVectorFix); |
|
| 392 | 392 | // Set score correction |
| 393 | 393 | double scoreCorrection = 12.0; |
| 394 | 394 | leaderboard.getScoreCorrection().correctScore(competitor, raceColumn, scoreCorrection); |
| ... | ... | @@ -537,8 +537,7 @@ public class MasterDataImportTest { |
| 537 | 537 | fixesToSave.add(new GPSFixMovingImpl(new DegreePosition(54.333, 10.133), logTimePoint.plus(i), |
| 538 | 538 | new KnotSpeedWithBearingImpl(10, new DegreeBearingImpl(90)), /* optionalTrueHeading */ null)); |
| 539 | 539 | } |
| 540 | - sourceService.getSensorFixStore().storeFixes(deviceIdentifier, fixesToSave, /* returnManeuverUpdate */ false, /* returnLiveDelay */ false, |
|
| 541 | - /* filterByRegattaAndEventEndDate */ true); |
|
| 540 | + sourceService.getSensorFixStore().storeFixes(deviceIdentifier, fixesToSave, /* returnManeuverUpdate */ false, /* returnLiveDelay */ false); |
|
| 542 | 541 | return deviceIdentifier; |
| 543 | 542 | } |
| 544 | 543 |
java/com.sap.sailing.server/src/com/sap/sailing/server/impl/CourseAndMarkConfigurationFactoryImpl.java
| ... | ... | @@ -553,7 +553,7 @@ public class CourseAndMarkConfigurationFactoryImpl implements CourseAndMarkConfi |
| 553 | 553 | // TODO check if we can use com.sap.sailing.domain.racelogtracking.impl.RaceLogTrackingAdapterImpl.pingMark(RegattaLog, Mark, GPSFix, RacingEventService) |
| 554 | 554 | final PingDeviceIdentifierImpl pingIdentifier = new PingDeviceIdentifierImpl(UUID.randomUUID()); |
| 555 | 555 | sensorFixStore.storeFix(pingIdentifier, |
| 556 | - new GPSFixImpl(position[0], timePointForDefinitionOfMarksAndDeviceMappings), /* filterByRegattaAndEventEndDate */ false); |
|
| 556 | + new GPSFixImpl(position[0], timePointForDefinitionOfMarksAndDeviceMappings)); |
|
| 557 | 557 | regatta.getRegattaLog() |
| 558 | 558 | .add(new RegattaLogDeviceMarkMappingEventImpl( |
| 559 | 559 | timePointForDefinitionOfMarksAndDeviceMappings, author, mark, pingIdentifier, |