merge bug3916 into origin/master

2026-10-20 19:20:04 +00:00 · 2016-12-02 18:53:20 +01:00
commit 79ae217f86
@@ -1,64 +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;
-    }
-}
@@ -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;
        }
        
@@ -9,10 +9,14 @@ public enum RaceStateEvents {
    RRS26_STARTMODE_UP,
    RRS26_STARTMODE_DOWN,

-    SWC_CLASS_OVER_OSCAR_UP,
-    SWC_STARTMODE_UP,
-    SWC_STARTMODE_DOWN,
-    SWC_CLASS_OVER_OSCAR_DOWN,
+    SWC_CLASS_AND_STARTMODE_UP,
+    SWC_CLASS_AND_STARTMODE_DOWN,
+    SWC_FIVE_UP,
+    SWC_FOUR_UP,
+    SWC_THREE_UP,
+    SWC_TWO_UP,
+    SWC_ONE_UP,
+    SWC_GREEN_UP,

    ESS_AP_DOWN,
    ESS_THREE_UP,
@@ -52,9 +52,13 @@ public interface ReadonlyRacingProcedure extends RaceStateEventProcessor, RaceSt
    void removeChangedListener(RacingProcedureChangedListener listener);

    /**
-     * Returns <code>true</code> if the start phase of this {@link ReadonlyRacingProcedure is active given the current time and start time.
-     * @param startTime start time to be used to determine whether the start phase is active or not.
-     * @param now {@link TimePoint} used as the current time on determining whether the start phase is active or not.
+     * Returns <code>true</code> if the start phase of this {@link ReadonlyRacingProcedure is active given the current
+     * time and start time.
+     * 
+     * @param startTime
+     *            start time to be used to determine whether the start phase is active or not. Must not be {@code null}
+     * @param now
+     *            {@link TimePoint} used as the current time on determining whether the start phase is active or not.
     */
    boolean isStartphaseActive(TimePoint startTime, TimePoint now);

@@ -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);
 }
@@ -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();
 }
@@ -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();
 }
@@ -3,19 +3,83 @@ 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.Duration;
+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 Duration getStartPhaseStartModeUpInterval();
+
+    @Override
+    public boolean isStartphaseActive(TimePoint startTime, TimePoint now) {
+        return now.before(startTime) && !now.before(startTime.minus(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
@@ -3,53 +3,37 @@ 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;
 import com.sap.sailing.domain.common.racelog.Flags;
 import com.sap.sailing.domain.common.racelog.RacingProcedureType;
+import com.sap.sse.common.Duration;
 import com.sap.sse.common.TimePoint;

 public class RRS26RacingProcedureImpl extends ConfigurableStartModeFlagRacingProcedureImpl implements RRS26RacingProcedure {

-    private final static long startPhaseClassUpInterval = 5 * 60 * 1000; // minutes * seconds * milliseconds
-    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;
+    private final static Duration startPhaseClassUpInterval = Duration.ONE_MINUTE.times(5);
+    private final static Duration startPhaseStartModeUpInterval = Duration.ONE_MINUTE.times(4);
+    private final static Duration startPhaseStartModeDownInterval = Duration.ONE_MINUTE;

    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 Duration getStartPhaseStartModeUpInterval() {
+        return startPhaseStartModeUpInterval;
    }

    @Override
@@ -62,7 +46,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,24 +63,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)) {
-            long timeTillStart = startTime.minus(now.asMillis()).asMillis();
-            return timeTillStart < startPhaseClassUpInterval;
-        }
-        return false;
-    }
-
    @Override
    protected Collection<RaceStateEvent> createStartStateEvents(TimePoint startTime) {
        return Arrays.<RaceStateEvent> asList(
@@ -110,7 +76,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 +139,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();
    }
-
 }
@@ -3,52 +3,41 @@ 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;
 import com.sap.sailing.domain.common.racelog.Flags;
 import com.sap.sailing.domain.common.racelog.RacingProcedureType;
+import com.sap.sse.common.Duration;
 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 Duration CLASS_AND_STARTMODE_UP_INTERVAL = Duration.ONE_MINUTE.times(6); // 6 minutes before start
+    private final static Duration CLASS_AND_STARTMODE_DOWN_INTERVAL = Duration.ONE_MINUTE; // 1 minute after start
+    private final static Duration FIVE_MINUTES_FLAG_UP_INTERVAL = Duration.ONE_MINUTE.times(5); // 5 minutes before start
+    private final static Duration FOUR_MINUTES_FLAG_UP_INTERVAL = Duration.ONE_MINUTE.times(4); // 4 minutes before start
+    private final static Duration THREE_MINUTES_FLAG_UP_INTERVAL = Duration.ONE_MINUTE.times(3); // 3 minutes before start
+    private final static Duration TWO_MINUTES_FLAG_UP_INTERVAL = Duration.ONE_MINUTE.times(2); // 2 minutes before start
+    private final static Duration ONE_MINUTE_FLAG_UP_INTERVAL = Duration.ONE_MINUTE; // 1 minutes before 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 Duration getStartPhaseStartModeUpInterval() {
+        return CLASS_AND_STARTMODE_UP_INTERVAL;
    }

    @Override
@@ -61,7 +50,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,37 +67,34 @@ 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));
-    }
-
    @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_STARTMODE_UP_INTERVAL), RaceStateEvents.SWC_CLASS_AND_STARTMODE_UP),
+                new RaceStateEventImpl(startTime.minus(FIVE_MINUTES_FLAG_UP_INTERVAL), RaceStateEvents.SWC_FIVE_UP),
+                new RaceStateEventImpl(startTime.minus(FOUR_MINUTES_FLAG_UP_INTERVAL), RaceStateEvents.SWC_FOUR_UP),
+                new RaceStateEventImpl(startTime.minus(THREE_MINUTES_FLAG_UP_INTERVAL), RaceStateEvents.SWC_THREE_UP),
+                new RaceStateEventImpl(startTime.minus(TWO_MINUTES_FLAG_UP_INTERVAL), RaceStateEvents.SWC_TWO_UP),
+                new RaceStateEventImpl(startTime.minus(ONE_MINUTE_FLAG_UP_INTERVAL), RaceStateEvents.SWC_ONE_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, RaceStateEvents.SWC_GREEN_UP),
+                new RaceStateEventImpl(startTime.plus(CLASS_AND_STARTMODE_DOWN_INTERVAL), RaceStateEvents.SWC_CLASS_AND_STARTMODE_DOWN));
    }

    @Override
    public boolean processStateEvent(RaceStateEvent event) {
        switch (event.getEventName()) {
-        case SWC_STARTMODE_UP:
-            if (!startmodeFlagHasBeenSet) {
+        case SWC_CLASS_AND_STARTMODE_UP:
+            if (!startmodeFlagHasBeenSet()) {
                setStartModeFlag(event.getTimePoint(), cachedStartmodeFlag);
            }
-        case SWC_CLASS_OVER_OSCAR_UP:
-        case SWC_STARTMODE_DOWN:
-        case SWC_CLASS_OVER_OSCAR_DOWN:
+        case SWC_CLASS_AND_STARTMODE_DOWN:
+        case SWC_FIVE_UP:
+        case SWC_FOUR_UP:
+        case SWC_THREE_UP:
+        case SWC_TWO_UP:
+        case SWC_ONE_UP:
+        case SWC_GREEN_UP:
            getChangedListeners().onActiveFlagsChanged(this);
            return true;
        default:
@@ -118,21 +104,54 @@ public class SWCRacingProcedureImpl extends ConfigurableStartModeFlagRacingProce

    @Override
    public FlagPoleState getActiveFlags(TimePoint startTime, TimePoint now) {
-        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_STARTMODE_UP_INTERVAL))) {
            return new FlagPoleState(
-                    Arrays.asList(new FlagPole(classFlag, Flags.OSCAR, false), new FlagPole(cachedStartmodeFlag, false)),
+                    Arrays.asList(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))) {
+                    Arrays.asList(new FlagPole(cachedStartmodeFlag, true)), 
+                    startTime.minus(CLASS_AND_STARTMODE_UP_INTERVAL));
+        } else if (now.before(startTime.minus(FIVE_MINUTES_FLAG_UP_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),
-                    Arrays.asList(new FlagPole(classFlag,  Flags.OSCAR, false), new FlagPole(cachedStartmodeFlag, false)), 
-                    startTime.plus(CLASS_OVER_OSCAR_AND_STARTMODE_DOWN_INTERVAL));
+                    Arrays.asList(new FlagPole(cachedStartmodeFlag, true), new FlagPole(Flags.SWC_FIVE, false)),
+                    startTime.minus(CLASS_AND_STARTMODE_UP_INTERVAL),
+                    Arrays.asList(new FlagPole(cachedStartmodeFlag, true), new FlagPole(Flags.SWC_FIVE, true)), 
+                    startTime.minus(FIVE_MINUTES_FLAG_UP_INTERVAL));
+        } else if (now.before(startTime.minus(FOUR_MINUTES_FLAG_UP_INTERVAL))) {
+            return new FlagPoleState(
+                    Arrays.asList(new FlagPole(cachedStartmodeFlag, true), new FlagPole(Flags.SWC_FIVE, true), new FlagPole(Flags.SWC_FOUR, false)),
+                    startTime.minus(FIVE_MINUTES_FLAG_UP_INTERVAL),
+                    Arrays.asList(new FlagPole(cachedStartmodeFlag, true), new FlagPole(Flags.SWC_FOUR, true), new FlagPole(Flags.SWC_THREE, false)), 
+                    startTime.minus(FOUR_MINUTES_FLAG_UP_INTERVAL));
+        } else if (now.before(startTime.minus(THREE_MINUTES_FLAG_UP_INTERVAL))) {
+            return new FlagPoleState(
+                    Arrays.asList(new FlagPole(cachedStartmodeFlag, true), new FlagPole(Flags.SWC_FOUR, true), new FlagPole(Flags.SWC_THREE, false)),
+                    startTime.minus(FOUR_MINUTES_FLAG_UP_INTERVAL),
+                    Arrays.asList(new FlagPole(cachedStartmodeFlag, true), new FlagPole(Flags.SWC_THREE, true), new FlagPole(Flags.SWC_TWO, false)), 
+                    startTime.minus(THREE_MINUTES_FLAG_UP_INTERVAL));
+        } else if (now.before(startTime.minus(TWO_MINUTES_FLAG_UP_INTERVAL))) {
+            return new FlagPoleState(
+                    Arrays.asList(new FlagPole(cachedStartmodeFlag, true), new FlagPole(Flags.SWC_THREE, true), new FlagPole(Flags.SWC_TWO, false)),
+                    startTime.minus(THREE_MINUTES_FLAG_UP_INTERVAL),
+                    Arrays.asList(new FlagPole(cachedStartmodeFlag, true), new FlagPole(Flags.SWC_TWO, true), new FlagPole(Flags.SWC_ONE, false)), 
+                    startTime.minus(TWO_MINUTES_FLAG_UP_INTERVAL));
+        } else if (now.before(startTime.minus(ONE_MINUTE_FLAG_UP_INTERVAL))) {
+            return new FlagPoleState(
+                    Arrays.asList(new FlagPole(cachedStartmodeFlag, true), new FlagPole(Flags.SWC_TWO, true), new FlagPole(Flags.SWC_ONE, false)),
+                    startTime.minus(TWO_MINUTES_FLAG_UP_INTERVAL),
+                    Arrays.asList(new FlagPole(cachedStartmodeFlag, true), new FlagPole(Flags.SWC_ONE, true), new FlagPole(Flags.SWC_ZERO, false)), 
+                    startTime.minus(ONE_MINUTE_FLAG_UP_INTERVAL));
+        } else if (now.before(startTime)) {
+            return new FlagPoleState(
+                    Arrays.asList(new FlagPole(cachedStartmodeFlag, true), new FlagPole(Flags.SWC_ONE, true), new FlagPole(Flags.SWC_ZERO, false)),
+                    startTime.minus(ONE_MINUTE_FLAG_UP_INTERVAL),
+                    Arrays.asList(new FlagPole(cachedStartmodeFlag, true), new FlagPole(Flags.SWC_ZERO, true)), 
+                    startTime);
+        } else if (now.before(startTime.plus(CLASS_AND_STARTMODE_DOWN_INTERVAL))) {
+            return new FlagPoleState(
+                    Arrays.asList(new FlagPole(cachedStartmodeFlag, true), new FlagPole(Flags.SWC_ZERO, true)),
+                    startTime,
+                    Arrays.asList(new FlagPole(cachedStartmodeFlag, false), new FlagPole(Flags.SWC_ZERO, false)), 
+                    startTime.plus(CLASS_AND_STARTMODE_DOWN_INTERVAL));
        } else {
            if (isIndividualRecallDisplayed(now)) {
                return new FlagPoleState(
@@ -151,44 +170,23 @@ public class SWCRacingProcedureImpl extends ConfigurableStartModeFlagRacingProce
                        null);
            } else {
                TimePoint recallRemoved = getIndividualRecallRemovalTime();
-                return new FlagPoleState(Collections.<FlagPole>emptyList(), recallRemoved == null ? startTime : recallRemoved);
+                return new FlagPoleState(Collections.<FlagPole>emptyList(), recallRemoved == null ? startTime.plus(CLASS_AND_STARTMODE_DOWN_INTERVAL) : recallRemoved);
            }
        }
    }
-    
-    @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();
    }
-
 }
@@ -8,5 +8,4 @@ import com.sap.sailing.domain.common.racelog.Flags;
 public interface ConfigurableStartModeFlagRacingProcedureConfiguration extends RacingProcedureConfiguration {
    
    List<Flags> getStartModeFlags();
-
 }