further refactoring of RRS26 and SWC start procedure code to shared ConfigurableStartModeFlagRacingProcedure

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

@@ -1,67 +0,0 @@
-package com.sap.sailing.domain.abstractlog.race.analyzing.impl;
-
-import java.util.Arrays;
-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.RaceLogFlagEvent;
-import com.sap.sailing.domain.common.racelog.Flags;
-import com.sap.sailing.domain.common.racelog.RacingProcedureType;
-
-public class RRS26StartModeFlagFinder extends RaceLogAnalyzer<Flags> {
-
-    private final static List<Flags> defaultStartModeFlags = Arrays.asList(Flags.PAPA, Flags.ZULU, Flags.BLACK, Flags.INDIA, Flags.UNIFORM, Flags.INDIA_ZULU);
-    
-    private final RacingProcedureTypeAnalyzer procedureAnalyzer;
-    private final List<Flags> startModeFlags;
-
-    /**
-     * Searches for the start mode flag of a RRS26 race.
-     * 
-     * @param procedureAnalyzer
-     *            to be used to ensure a RRS26 race. Must operate on the same race log. Otherwise a
-     *            {@link IllegalArgumentException} is thrown.
-     */
-    public RRS26StartModeFlagFinder(RacingProcedureTypeAnalyzer procedureAnalyzer, RaceLog raceLog) {
-        this(procedureAnalyzer, raceLog, defaultStartModeFlags);
-    }
-    
-    public RRS26StartModeFlagFinder(RacingProcedureTypeAnalyzer procedureAnalyzer, RaceLog raceLog, List<Flags> startModeFlags) {
-        super(raceLog);
-        if (raceLog != procedureAnalyzer.getLog()) {
-            throw new IllegalArgumentException("Both analyzers must operate on the same race log.");
-        }
-        this.procedureAnalyzer = procedureAnalyzer;
-        this.startModeFlags = startModeFlags;
-    }
-
-    @Override
-    protected Flags performAnalysis() {
-        RacingProcedureType type = procedureAnalyzer.analyze();
-        if (!RacingProcedureType.RRS26.equals(type)) {
-            return null;
-        }
-        
-        for (RaceLogEvent event : getPassEventsDescending()) {
-            if (event instanceof RaceLogFlagEvent) {
-                RaceLogFlagEvent flagEvent = (RaceLogFlagEvent) event;
-                if (isStartModeFlagEvent(flagEvent)) {
-                    return flagEvent.getUpperFlag();
-                }
-            }
-        }
-        return null;
-    }
-    
-    private boolean isStartModeFlagEvent(RaceLogFlagEvent event) {
-        // no matter if displayed or removed
-        if (event.getLowerFlag().equals(Flags.NONE)) {
-            return startModeFlags.contains(event.getUpperFlag());
-        }
-        return false;
-    }
-    
-    
-
-}

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

@@ -1,6 +1,5 @@
 package com.sap.sailing.domain.abstractlog.race.analyzing.impl;
 
-import java.util.Arrays;
 import java.util.List;
 
 import com.sap.sailing.domain.abstractlog.race.RaceLog;
@@ -9,25 +8,19 @@ import com.sap.sailing.domain.abstractlog.race.RaceLogFlagEvent;
 import com.sap.sailing.domain.common.racelog.Flags;
 import com.sap.sailing.domain.common.racelog.RacingProcedureType;
 
-public class SWCStartModeFlagFinder extends RaceLogAnalyzer<Flags> {
+public class StartModeFlagFinder extends RaceLogAnalyzer<Flags> {
 
-    private final static List<Flags> defaultStartModeFlags = Arrays.asList(Flags.BLACK, Flags.UNIFORM);
-    
     private final RacingProcedureTypeAnalyzer procedureAnalyzer;
     private final List<Flags> startModeFlags;
 
     /**
-     * Searches for the start mode flag of a SWC race.
+     * Searches for the start mode flags.
      * 
      * @param procedureAnalyzer
-     *            to be used to ensure a SWC race. Must operate on the same race log. Otherwise a
+     *            to be used to ensure a racing procedure with start mode flags. Must operate on the same race log. Otherwise a
      *            {@link IllegalArgumentException} is thrown.
      */
-    public SWCStartModeFlagFinder(RacingProcedureTypeAnalyzer procedureAnalyzer, RaceLog raceLog) {
-        this(procedureAnalyzer, raceLog, defaultStartModeFlags);
-    }
-    
-    public SWCStartModeFlagFinder(RacingProcedureTypeAnalyzer procedureAnalyzer, RaceLog raceLog, List<Flags> startModeFlags) {
+    public StartModeFlagFinder(RacingProcedureTypeAnalyzer procedureAnalyzer, RaceLog raceLog, List<Flags> startModeFlags) {
         super(raceLog);
         if (raceLog != procedureAnalyzer.getLog()) {
             throw new IllegalArgumentException("Both analyzers must operate on the same race log.");
@@ -39,7 +32,7 @@ public class SWCStartModeFlagFinder extends RaceLogAnalyzer<Flags> {
     @Override
     protected Flags performAnalysis() {
         RacingProcedureType type = procedureAnalyzer.analyze();
-        if (!RacingProcedureType.SWC.equals(type)) {
+        if (!(RacingProcedureType.RRS26.equals(type) || RacingProcedureType.SWC.equals(type))) {
             return null;
         }
         

java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/abstractlog/race/state/racingprocedure/line/ConfigurableStartModeFlagRacingProcedure.java

@@ -1,5 +1,7 @@
 package com.sap.sailing.domain.abstractlog.race.state.racingprocedure.line;
 
+import java.util.List;
+
 import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.RacingProcedure;
 import com.sap.sailing.domain.base.configuration.procedures.ConfigurableStartModeFlagRacingProcedureConfiguration;
 import com.sap.sailing.domain.common.racelog.Flags;
@@ -21,5 +23,7 @@ public interface ConfigurableStartModeFlagRacingProcedure extends RacingProcedur
     
     Flags getDefaultStartMode();
     
+    List<Flags> getDefaultStartModeFlags();
+    
     void setStartModeFlag(TimePoint timePoint, Flags startMode);
 }

java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/abstractlog/race/state/racingprocedure/line/RRS26RacingProcedure.java

@@ -1,10 +1,14 @@
 package com.sap.sailing.domain.abstractlog.race.state.racingprocedure.line;
 
+import java.util.Arrays;
+import java.util.List;
+
 import com.sap.sailing.domain.base.configuration.procedures.RRS26Configuration;
 import com.sap.sailing.domain.common.racelog.Flags;
 
 public interface RRS26RacingProcedure extends ConfigurableStartModeFlagRacingProcedure {
-    public final static Flags DefaultStartMode = Flags.PAPA;
-    
+    public final static Flags DEFAULT_START_MODE = Flags.PAPA;
+    public final static List<Flags> DEFAULT_START_MODE_FLAGS = Arrays.asList(Flags.PAPA, Flags.ZULU, Flags.BLACK, Flags.INDIA, Flags.UNIFORM, Flags.INDIA_ZULU);
+
     RRS26Configuration getConfiguration();
 }

java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/abstractlog/race/state/racingprocedure/line/SWCRacingProcedure.java

@@ -1,11 +1,15 @@
 package com.sap.sailing.domain.abstractlog.race.state.racingprocedure.line;
 
+import java.util.Arrays;
+import java.util.List;
+
 import com.sap.sailing.domain.base.configuration.procedures.SWCStartConfiguration;
 import com.sap.sailing.domain.common.racelog.Flags;
 
 public interface SWCRacingProcedure extends ConfigurableStartModeFlagRacingProcedure {
 
-    public final static Flags DefaultStartMode = Flags.UNIFORM;
+    public final static Flags DEFAULT_START_MODE = Flags.UNIFORM;
+    public final static List<Flags> DEFAULT_START_MODE_FLAGS = Arrays.asList(Flags.BLACK, Flags.UNIFORM);
     
     SWCStartConfiguration getConfiguration();
 }

java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/abstractlog/race/state/racingprocedure/line/impl/ConfigurableStartModeFlagRacingProcedureImpl.java

@@ -3,19 +3,77 @@ package com.sap.sailing.domain.abstractlog.race.state.racingprocedure.line.impl;
 import com.sap.sailing.domain.abstractlog.AbstractLogEventAuthor;
 import com.sap.sailing.domain.abstractlog.race.RaceLog;
 import com.sap.sailing.domain.abstractlog.race.analyzing.impl.RaceLogResolver;
+import com.sap.sailing.domain.abstractlog.race.analyzing.impl.RacingProcedureTypeAnalyzer;
+import com.sap.sailing.domain.abstractlog.race.analyzing.impl.StartModeFlagFinder;
+import com.sap.sailing.domain.abstractlog.race.impl.RaceLogFlagEventImpl;
 import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.RacingProcedureChangedListener;
+import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.RacingProcedurePrerequisite;
+import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.RacingProcedurePrerequisite.FulfillmentFunction;
 import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.impl.BaseRacingProcedure;
+import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.impl.NoMorePrerequisite;
 import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.impl.RacingProcedureChangedListeners;
-import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.line.LineStartChangedListener;
 import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.line.ConfigurableStartModeFlagRacingProcedure;
-import com.sap.sailing.domain.base.configuration.RacingProcedureConfiguration;
+import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.line.LineStartChangedListener;
 import com.sap.sailing.domain.base.configuration.procedures.ConfigurableStartModeFlagRacingProcedureConfiguration;
+import com.sap.sailing.domain.common.racelog.Flags;
+import com.sap.sse.common.TimePoint;
 
 public abstract class ConfigurableStartModeFlagRacingProcedureImpl extends BaseRacingProcedure implements ConfigurableStartModeFlagRacingProcedure {
     
+    protected Flags cachedStartmodeFlag;
+    private boolean startmodeFlagHasBeenSet;
+    private StartModeFlagFinder startModeFlagAnalyzer;
+
     public ConfigurableStartModeFlagRacingProcedureImpl(RaceLog raceLog, AbstractLogEventAuthor author,
-            RacingProcedureConfiguration configuration, RaceLogResolver raceLogResolver) {
+            ConfigurableStartModeFlagRacingProcedureConfiguration configuration, RaceLogResolver raceLogResolver) {
         super(raceLog, author, configuration, raceLogResolver);
+        
+        RacingProcedureTypeAnalyzer procedureAnalyzer = new RacingProcedureTypeAnalyzer(raceLog);
+        if (configuration.getStartModeFlags() != null) {
+            this.startModeFlagAnalyzer = new StartModeFlagFinder(procedureAnalyzer, raceLog, configuration.getStartModeFlags());
+        } else {
+            this.startModeFlagAnalyzer = new StartModeFlagFinder(procedureAnalyzer, raceLog, getDefaultStartModeFlags());
+        }
+        
+        this.cachedStartmodeFlag = getDefaultStartMode();
+        this.startmodeFlagHasBeenSet = false;
+        
+        update();
+    }
+
+    abstract protected long getStartPhaseStartModeUpInterval();
+
+    @Override
+    public RacingProcedurePrerequisite checkPrerequisitesForStart(TimePoint now, TimePoint startTime,
+            FulfillmentFunction function) {
+        if (startTime.minus(getStartPhaseStartModeUpInterval()).before(now) && !startmodeFlagHasBeenSet()) {
+            return new StartModePrerequisite(function, this, now, startTime);
+        }
+        return new NoMorePrerequisite(function);
+    }
+
+    public boolean startmodeFlagHasBeenSet() {
+        return startmodeFlagHasBeenSet;
+    }
+
+    @Override
+    public void setStartModeFlag(TimePoint timePoint, Flags startMode) {
+        raceLog.add(new RaceLogFlagEventImpl(timePoint, author, raceLog.getCurrentPassId(), startMode, Flags.NONE, true));
+    }
+
+    @Override
+    public Flags getStartModeFlag() {
+        return cachedStartmodeFlag;
+    }
+
+    @Override
+    protected void update() {
+        Flags startmodeFlag = startModeFlagAnalyzer.analyze();
+        if (startmodeFlag != null && (!startmodeFlag.equals(cachedStartmodeFlag) || !startmodeFlagHasBeenSet)) {
+            cachedStartmodeFlag = startmodeFlag;
+            startmodeFlagHasBeenSet = true;
+            getChangedListeners().onStartModeChanged(this);
+        }
     }
 
     @Override

java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/abstractlog/race/state/racingprocedure/line/impl/RRS26RacingProcedureImpl.java

@@ -3,20 +3,15 @@ package com.sap.sailing.domain.abstractlog.race.state.racingprocedure.line.impl;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
+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.analyzing.impl.RRS26StartModeFlagFinder;
 import com.sap.sailing.domain.abstractlog.race.analyzing.impl.RaceLogResolver;
-import com.sap.sailing.domain.abstractlog.race.analyzing.impl.RacingProcedureTypeAnalyzer;
-import com.sap.sailing.domain.abstractlog.race.impl.RaceLogFlagEventImpl;
 import com.sap.sailing.domain.abstractlog.race.state.RaceStateEvent;
 import com.sap.sailing.domain.abstractlog.race.state.impl.RaceStateEventImpl;
 import com.sap.sailing.domain.abstractlog.race.state.impl.RaceStateEvents;
 import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.FlagPoleState;
-import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.RacingProcedurePrerequisite;
-import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.RacingProcedurePrerequisite.FulfillmentFunction;
-import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.impl.NoMorePrerequisite;
 import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.line.RRS26RacingProcedure;
 import com.sap.sailing.domain.base.configuration.procedures.RRS26Configuration;
 import com.sap.sailing.domain.common.racelog.FlagPole;
@@ -30,26 +25,14 @@ public class RRS26RacingProcedureImpl extends ConfigurableStartModeFlagRacingPro
     private final static long startPhaseStartModeUpInterval = 4 * 60 * 1000; // minutes * seconds * milliseconds
     private final static long startPhaseStartModeDownInterval = 1 * 60 * 1000; // minutes * seconds * milliseconds
 
-    private final RRS26StartModeFlagFinder startModeFlagAnalyzer;
-    
-    private Flags cachedStartmodeFlag;
-    private boolean startmodeFlagHasBeenSet;
-
     public RRS26RacingProcedureImpl(RaceLog raceLog, AbstractLogEventAuthor author, 
              RRS26Configuration configuration, RaceLogResolver raceLogResolver) {
         super(raceLog, author, configuration, raceLogResolver);
-        
-        RacingProcedureTypeAnalyzer procedureAnalyzer = new RacingProcedureTypeAnalyzer(raceLog);
-        if (configuration.getStartModeFlags() != null) {
-            this.startModeFlagAnalyzer = new RRS26StartModeFlagFinder(procedureAnalyzer, raceLog, configuration.getStartModeFlags());
-        } else {
-            this.startModeFlagAnalyzer = new RRS26StartModeFlagFinder(procedureAnalyzer, raceLog);
-        }
-        
-        this.cachedStartmodeFlag = RRS26RacingProcedure.DefaultStartMode;
-        this.startmodeFlagHasBeenSet = false;
-        
-        update();
+    }
+
+    @Override
+    protected long getStartPhaseStartModeUpInterval() {
+        return startPhaseStartModeUpInterval;
     }
 
     @Override
@@ -62,7 +45,7 @@ public class RRS26RacingProcedureImpl extends ConfigurableStartModeFlagRacingPro
         boolean hasRecall = super.hasIndividualRecall();
         if (!hasRecall) {
             return false;
-        } else if (startmodeFlagHasBeenSet) {
+        } else if (startmodeFlagHasBeenSet()) {
             return cachedStartmodeFlag != Flags.BLACK;
         } else {
             return hasRecall;
@@ -79,15 +62,6 @@ public class RRS26RacingProcedureImpl extends ConfigurableStartModeFlagRacingPro
         return false;
     }
 
-    @Override
-    public RacingProcedurePrerequisite checkPrerequisitesForStart(TimePoint now, TimePoint startTime,
-            FulfillmentFunction function) {
-        if (startTime.minus(startPhaseStartModeUpInterval).before(now) && !startmodeFlagHasBeenSet) {
-            return new StartModePrerequisite(function, this, now, startTime);
-        }
-        return new NoMorePrerequisite(function);
-    }
-
     @Override
     public boolean isStartphaseActive(TimePoint startTime, TimePoint now) {
         if (now.before(startTime)) {
@@ -110,7 +84,7 @@ public class RRS26RacingProcedureImpl extends ConfigurableStartModeFlagRacingPro
     public boolean processStateEvent(RaceStateEvent event) {
         switch (event.getEventName()) {
         case RRS26_STARTMODE_UP:
-            if (!startmodeFlagHasBeenSet) {
+            if (!startmodeFlagHasBeenSet()) {
                 setStartModeFlag(event.getTimePoint(), cachedStartmodeFlag);
             }
         case RRS26_CLASS_UP:
@@ -173,39 +147,18 @@ public class RRS26RacingProcedureImpl extends ConfigurableStartModeFlagRacingPro
         }
     }
     
-    @Override
-    public void setStartModeFlag(TimePoint timePoint, Flags startMode) {
-        raceLog.add(new RaceLogFlagEventImpl(timePoint, author, raceLog.getCurrentPassId(), startMode, Flags.NONE, true));
-    }
-
-    @Override
-    public Flags getStartModeFlag() {
-        return cachedStartmodeFlag;
-    }
-
     @Override
     public Flags getDefaultStartMode() {
-        return RRS26RacingProcedure.DefaultStartMode;
+        return RRS26RacingProcedure.DEFAULT_START_MODE;
     }
 
-    public boolean startmodeFlagHasBeenSet() {
-        return startmodeFlagHasBeenSet;
-    }
-    
     @Override
-    protected void update() {
-        Flags startmodeFlag = startModeFlagAnalyzer.analyze();
-        if (startmodeFlag != null && (!startmodeFlag.equals(cachedStartmodeFlag) || !startmodeFlagHasBeenSet)) {
-            cachedStartmodeFlag = startmodeFlag;
-            startmodeFlagHasBeenSet = true;
-            getChangedListeners().onStartModeChanged(this);
-        }
-        super.update();
+    public List<Flags> getDefaultStartModeFlags() {
+        return RRS26RacingProcedure.DEFAULT_START_MODE_FLAGS;
     }
-    
+
     @Override
     public RRS26Configuration getConfiguration() {
         return (RRS26Configuration) super.getConfiguration();
     }
-
 }

java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/abstractlog/race/state/racingprocedure/line/impl/SWCRacingProcedureImpl.java

@@ -3,20 +3,15 @@ package com.sap.sailing.domain.abstractlog.race.state.racingprocedure.line.impl;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
+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.analyzing.impl.RaceLogResolver;
-import com.sap.sailing.domain.abstractlog.race.analyzing.impl.RacingProcedureTypeAnalyzer;
-import com.sap.sailing.domain.abstractlog.race.analyzing.impl.SWCStartModeFlagFinder;
-import com.sap.sailing.domain.abstractlog.race.impl.RaceLogFlagEventImpl;
 import com.sap.sailing.domain.abstractlog.race.state.RaceStateEvent;
 import com.sap.sailing.domain.abstractlog.race.state.impl.RaceStateEventImpl;
 import com.sap.sailing.domain.abstractlog.race.state.impl.RaceStateEvents;
 import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.FlagPoleState;
-import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.RacingProcedurePrerequisite;
-import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.RacingProcedurePrerequisite.FulfillmentFunction;
-import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.impl.NoMorePrerequisite;
 import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.line.SWCRacingProcedure;
 import com.sap.sailing.domain.base.configuration.procedures.SWCStartConfiguration;
 import com.sap.sailing.domain.common.racelog.FlagPole;
@@ -26,29 +21,17 @@ import com.sap.sse.common.TimePoint;
 
 public class SWCRacingProcedureImpl extends ConfigurableStartModeFlagRacingProcedureImpl implements SWCRacingProcedure {
 
-    private final static long CLASS_OVER_OSCAR_AND_STARTMODE_UP_INTERVAL = 6 * 60 * 1000; // 6 minutes before start
-    private final static long CLASS_OVER_OSCAR_AND_STARTMODE_DOWN_INTERVAL = 1 * 60 * 1000; // 1 minute after start
-
-    private final SWCStartModeFlagFinder startModeFlagAnalyzer;
-    
-    private Flags cachedStartmodeFlag;
-    private boolean startmodeFlagHasBeenSet;
+    private final static long CLASS_AND_OSCAR_AND_STARTMODE_UP_INTERVAL = 6 * 60 * 1000; // 6 minutes before start
+    private final static long CLASS_AND_OSCAR_AND_STARTMODE_DOWN_INTERVAL = 1 * 60 * 1000; // 1 minute after start
 
     public SWCRacingProcedureImpl(RaceLog raceLog, AbstractLogEventAuthor author, 
              SWCStartConfiguration configuration, RaceLogResolver raceLogResolver) {
         super(raceLog, author, configuration, raceLogResolver);
-        
-        RacingProcedureTypeAnalyzer procedureAnalyzer = new RacingProcedureTypeAnalyzer(raceLog);
-        if (configuration.getStartModeFlags() != null) {
-            this.startModeFlagAnalyzer = new SWCStartModeFlagFinder(procedureAnalyzer, raceLog, configuration.getStartModeFlags());
-        } else {
-            this.startModeFlagAnalyzer = new SWCStartModeFlagFinder(procedureAnalyzer, raceLog);
-        }
-        
-        this.cachedStartmodeFlag = SWCRacingProcedure.DefaultStartMode;
-        this.startmodeFlagHasBeenSet = false;
-        
-        update();
+    }
+
+    @Override
+    protected long getStartPhaseStartModeUpInterval() {
+        return CLASS_AND_OSCAR_AND_STARTMODE_UP_INTERVAL;
     }
 
     @Override
@@ -61,7 +44,7 @@ public class SWCRacingProcedureImpl extends ConfigurableStartModeFlagRacingProce
         boolean hasRecall = super.hasIndividualRecall();
         if (!hasRecall) {
             return false;
-        } else if (startmodeFlagHasBeenSet) {
+        } else if (startmodeFlagHasBeenSet()) {
             return cachedStartmodeFlag != Flags.BLACK;
         } else {
             return hasRecall;
@@ -78,32 +61,26 @@ public class SWCRacingProcedureImpl extends ConfigurableStartModeFlagRacingProce
         return false;
     }
 
-    @Override
-    public RacingProcedurePrerequisite checkPrerequisitesForStart(TimePoint now, TimePoint startTime,
-            FulfillmentFunction function) {
-        return new NoMorePrerequisite(function);
-    }
-
     @Override
     public boolean isStartphaseActive(TimePoint startTime, TimePoint now) {
-        return now.before(startTime.minus(CLASS_OVER_OSCAR_AND_STARTMODE_UP_INTERVAL));
+        return now.before(startTime.minus(CLASS_AND_OSCAR_AND_STARTMODE_UP_INTERVAL));
     }
 
     @Override
     protected Collection<RaceStateEvent> createStartStateEvents(TimePoint startTime) {
         return Arrays.<RaceStateEvent> asList(
-                new RaceStateEventImpl(startTime.minus(CLASS_OVER_OSCAR_AND_STARTMODE_UP_INTERVAL), RaceStateEvents.SWC_CLASS_OVER_OSCAR_UP),
-                new RaceStateEventImpl(startTime.minus(CLASS_OVER_OSCAR_AND_STARTMODE_UP_INTERVAL), RaceStateEvents.SWC_STARTMODE_UP),
+                new RaceStateEventImpl(startTime.minus(CLASS_AND_OSCAR_AND_STARTMODE_UP_INTERVAL), RaceStateEvents.SWC_CLASS_OVER_OSCAR_UP),
+                new RaceStateEventImpl(startTime.minus(CLASS_AND_OSCAR_AND_STARTMODE_UP_INTERVAL), RaceStateEvents.SWC_STARTMODE_UP),
                 new RaceStateEventImpl(startTime, RaceStateEvents.START),
-                new RaceStateEventImpl(startTime.plus(CLASS_OVER_OSCAR_AND_STARTMODE_DOWN_INTERVAL), RaceStateEvents.SWC_STARTMODE_DOWN), 
-                new RaceStateEventImpl(startTime.plus(CLASS_OVER_OSCAR_AND_STARTMODE_DOWN_INTERVAL), RaceStateEvents.SWC_CLASS_OVER_OSCAR_DOWN));
+                new RaceStateEventImpl(startTime.plus(CLASS_AND_OSCAR_AND_STARTMODE_DOWN_INTERVAL), RaceStateEvents.SWC_STARTMODE_DOWN), 
+                new RaceStateEventImpl(startTime.plus(CLASS_AND_OSCAR_AND_STARTMODE_DOWN_INTERVAL), RaceStateEvents.SWC_CLASS_OVER_OSCAR_DOWN));
     }
 
     @Override
     public boolean processStateEvent(RaceStateEvent event) {
         switch (event.getEventName()) {
         case SWC_STARTMODE_UP:
-            if (!startmodeFlagHasBeenSet) {
+            if (!startmodeFlagHasBeenSet()) {
                 setStartModeFlag(event.getTimePoint(), cachedStartmodeFlag);
             }
         case SWC_CLASS_OVER_OSCAR_UP:
@@ -121,18 +98,18 @@ public class SWCRacingProcedureImpl extends ConfigurableStartModeFlagRacingProce
         Flags classFlag = getConfiguration().getClassFlag() != null ?
             getConfiguration().getClassFlag() : Flags.CLASS;
             
-        if (now.before(startTime.minus(CLASS_OVER_OSCAR_AND_STARTMODE_UP_INTERVAL))) {
+        if (now.before(startTime.minus(CLASS_AND_OSCAR_AND_STARTMODE_UP_INTERVAL))) {
             return new FlagPoleState(
                     Arrays.asList(new FlagPole(classFlag, Flags.OSCAR, false), new FlagPole(cachedStartmodeFlag, false)),
                     null,
                     Arrays.asList(new FlagPole(classFlag, Flags.OSCAR, true), new FlagPole(cachedStartmodeFlag, true)), 
-                    startTime.minus(CLASS_OVER_OSCAR_AND_STARTMODE_UP_INTERVAL));
-        } else if (now.before(startTime.plus(CLASS_OVER_OSCAR_AND_STARTMODE_DOWN_INTERVAL))) {
+                    startTime.minus(CLASS_AND_OSCAR_AND_STARTMODE_UP_INTERVAL));
+        } else if (now.before(startTime.plus(CLASS_AND_OSCAR_AND_STARTMODE_DOWN_INTERVAL))) {
             return new FlagPoleState(
                     Arrays.asList(new FlagPole(classFlag,  Flags.OSCAR, true), new FlagPole(cachedStartmodeFlag, true)),
-                    startTime.minus(CLASS_OVER_OSCAR_AND_STARTMODE_UP_INTERVAL),
+                    startTime.minus(CLASS_AND_OSCAR_AND_STARTMODE_UP_INTERVAL),
                     Arrays.asList(new FlagPole(classFlag,  Flags.OSCAR, false), new FlagPole(cachedStartmodeFlag, false)), 
-                    startTime.plus(CLASS_OVER_OSCAR_AND_STARTMODE_DOWN_INTERVAL));
+                    startTime.plus(CLASS_AND_OSCAR_AND_STARTMODE_DOWN_INTERVAL));
         } else {
             if (isIndividualRecallDisplayed(now)) {
                 return new FlagPoleState(
@@ -155,40 +132,19 @@ public class SWCRacingProcedureImpl extends ConfigurableStartModeFlagRacingProce
             }
         }
     }
-    
-    @Override
-    public void setStartModeFlag(TimePoint timePoint, Flags startMode) {
-        raceLog.add(new RaceLogFlagEventImpl(timePoint, author, raceLog.getCurrentPassId(), startMode, Flags.NONE, true));
-    }
-
-    @Override
-    public Flags getStartModeFlag() {
-        return cachedStartmodeFlag;
-    }
 
     @Override
     public Flags getDefaultStartMode() {
-        return SWCRacingProcedure.DefaultStartMode;
+        return SWCRacingProcedure.DEFAULT_START_MODE;
     }
 
-    public boolean startmodeFlagHasBeenSet() {
-        return startmodeFlagHasBeenSet;
-    }
-    
     @Override
-    protected void update() {
-        Flags startmodeFlag = startModeFlagAnalyzer.analyze();
-        if (startmodeFlag != null && (!startmodeFlag.equals(cachedStartmodeFlag) || !startmodeFlagHasBeenSet)) {
-            cachedStartmodeFlag = startmodeFlag;
-            startmodeFlagHasBeenSet = true;
-            getChangedListeners().onStartModeChanged(this);
-        }
-        super.update();
+    public List<Flags> getDefaultStartModeFlags() {
+        return SWCRacingProcedure.DEFAULT_START_MODE_FLAGS;
     }
-    
+
     @Override
     public SWCStartConfiguration getConfiguration() {
         return (SWCStartConfiguration) super.getConfiguration();
     }
-
 }

java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/base/configuration/procedures/ConfigurableStartModeFlagRacingProcedureConfiguration.java

@@ -8,5 +8,4 @@ import com.sap.sailing.domain.common.racelog.Flags;
 public interface ConfigurableStartModeFlagRacingProcedureConfiguration extends RacingProcedureConfiguration {
     
     List<Flags> getStartModeFlags();
-
 }