Merge branch 'master' into bug3246; this merge temporarily kills the addition of the competitor import bundle to the launch configs

Conflicts: java/com.sap.sailing.server/SailingServer (No Proxy OSX).launch java/com.sap.sailing.server/SailingServer (No Proxy).launch java/com.sap.sailing.server/SailingServer (No Proxy, Cached MTB).launch java/com.sap.sailing.server/SailingServer (No Proxy, Jetty on 8889).launch java/com.sap.sailing.server/SailingServer (No Proxy, Jetty on 8889, Cached MTB).launch java/com.sap.sailing.server/SailingServer (No Proxy, Jetty on 8889, auto-replicate dev).launch java/com.sap.sailing.server/SailingServer (No Proxy, Jetty on 8889, auto-replicate).launch java/com.sap.sailing.server/SailingServer (No Proxy, Jetty on 8890).launch java/com.sap.sailing.server/SailingServer (No Proxy, Remote Debug SAP VM).launch java/com.sap.sailing.server/SailingServer (No Proxy, winddbTest).launch java/com.sap.sailing.server/SailingServer (Proxy).launch java/com.sap.sailing.server/SailingServer (Proxy, Jetty on 8889).launch java/com.sap.sailing.server/SailingServer (Proxy, Remote Debug SAP VM).launch java/com.sap.sailing.server/SailingServer (Proxy, SwissTiming Live Simulation).launch java/com.sap.sailing.server/SailingServer (Proxy, winddbTest).launch Change-Id: I88164350550d862bf9feed4d127a2d773d064add
2026-10-20 19:20:04 +00:00 · 2016-12-07 17:47:05 +01:00
commit 8ee18e9ae5
@@ -26,8 +26,10 @@ Export-Package: com.sap.sailing.domain.abstractlog,
 com.sap.sailing.domain.abstractlog.race.state.racingprocedure.gate,
 com.sap.sailing.domain.abstractlog.race.state.racingprocedure.gate.impl,
 com.sap.sailing.domain.abstractlog.race.state.racingprocedure.impl,
- com.sap.sailing.domain.abstractlog.race.state.racingprocedure.rrs26,
- com.sap.sailing.domain.abstractlog.race.state.racingprocedure.rrs26.impl,
+ com.sap.sailing.domain.abstractlog.race.state.racingprocedure.league,
+ com.sap.sailing.domain.abstractlog.race.state.racingprocedure.league.impl,
+ com.sap.sailing.domain.abstractlog.race.state.racingprocedure.line,
+ com.sap.sailing.domain.abstractlog.race.state.racingprocedure.line.impl,
 com.sap.sailing.domain.abstractlog.race.tracking,
 com.sap.sailing.domain.abstractlog.race.tracking.analyzing.impl,
 com.sap.sailing.domain.abstractlog.race.tracking.impl,
@@ -1,6 +1,6 @@
 package com.sap.sailing.domain.abstractlog.race;

-import com.sap.sse.common.TimePoint;
+import com.sap.sse.common.TimeRange;

 /**
 * Indicates that the protest start time for the related race has changed.
@@ -9,7 +9,9 @@ import com.sap.sse.common.TimePoint;
 public interface RaceLogProtestStartTimeEvent extends RaceLogEvent {

    /**
-     * Returns the start time of the race's protest time.
+     * Returns the time range of the race's protest time. The result is never {@code null}
+     * and the {@link TimeRange} returned always has a valid {@link TimeRange#from() start}
+     * and {@link TimeRange#to() end}.
     */
-    TimePoint getProtestStartTime();
+    TimeRange getProtestTime();
 }
@@ -3,19 +3,20 @@ package com.sap.sailing.domain.abstractlog.race.analyzing.impl;
 import com.sap.sailing.domain.abstractlog.race.RaceLog;
 import com.sap.sailing.domain.abstractlog.race.RaceLogEvent;
 import com.sap.sailing.domain.abstractlog.race.RaceLogProtestStartTimeEvent;
-import com.sap.sse.common.TimePoint;
+import com.sap.sse.common.TimeRange;

-public class ProtestStartTimeFinder extends RaceLogAnalyzer<TimePoint> {
+public class ProtestTimeFinder extends RaceLogAnalyzer<TimeRange> {

-    public ProtestStartTimeFinder(RaceLog raceLog) {
+    public ProtestTimeFinder(RaceLog raceLog) {
        super(raceLog);
    }

    @Override
-    protected TimePoint performAnalysis() {
+    protected TimeRange performAnalysis() {
        for (RaceLogEvent event : getPassEventsDescending()) {
            if (event instanceof RaceLogProtestStartTimeEvent) {
-                return ((RaceLogProtestStartTimeEvent) event).getProtestStartTime();
+                RaceLogProtestStartTimeEvent protestEvent = (RaceLogProtestStartTimeEvent) event;
+                return protestEvent.getProtestTime();
            }
        }
        return null;
@@ -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 RRS26StartModeFlagFinder extends RaceLogAnalyzer<Flags> {
+public class StartModeFlagFinder 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.
+     * Searches for the start mode flags.
     * 
     * @param procedureAnalyzer
-     *            to be used to ensure a RRS26 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 RRS26StartModeFlagFinder(RacingProcedureTypeAnalyzer procedureAnalyzer, RaceLog raceLog) {
-        this(procedureAnalyzer, raceLog, defaultStartModeFlags);
-    }
-    
-    public RRS26StartModeFlagFinder(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 RRS26StartModeFlagFinder extends RaceLogAnalyzer<Flags> {
    @Override
    protected Flags performAnalysis() {
        RacingProcedureType type = procedureAnalyzer.analyze();
-        if (!RacingProcedureType.RRS26.equals(type)) {
+        if (!(RacingProcedureType.RRS26.equals(type) || RacingProcedureType.SWC.equals(type))) {
            return null;
        }
        
@@ -61,7 +54,4 @@ public class RRS26StartModeFlagFinder extends RaceLogAnalyzer<Flags> {
        }
        return false;
    }
-    
-    
-
 }
@@ -6,21 +6,23 @@ import com.sap.sailing.domain.abstractlog.AbstractLogEventAuthor;
 import com.sap.sailing.domain.abstractlog.race.RaceLogEventVisitor;
 import com.sap.sailing.domain.abstractlog.race.RaceLogProtestStartTimeEvent;
 import com.sap.sse.common.TimePoint;
+import com.sap.sse.common.TimeRange;

 public class RaceLogProtestStartTimeEventImpl extends RaceLogEventImpl implements RaceLogProtestStartTimeEvent {
    private static final long serialVersionUID = -1800827552916395996L;

-    private final TimePoint protestStartTime;
-
+    private final TimeRange protestTime;
+    
    public RaceLogProtestStartTimeEventImpl(TimePoint createdAt, TimePoint pTimePoint, AbstractLogEventAuthor author,
-            Serializable pId, int pPassId, TimePoint protestStartTime) {
+            Serializable pId, int pPassId, TimeRange protestTime) {
        super(createdAt, pTimePoint, author, pId, pPassId);
-        this.protestStartTime = protestStartTime;
+        assert protestTime != null && protestTime.from() != null && protestTime.to() != null;
+        this.protestTime = protestTime;
    }

    public RaceLogProtestStartTimeEventImpl(TimePoint logicalTimePoint, AbstractLogEventAuthor author, int pPassId,
-            TimePoint protestStartTime) {
-        this(now(), logicalTimePoint, author, randId(), pPassId, protestStartTime);
+            TimeRange protestTime) {
+        this(now(), logicalTimePoint, author, randId(), pPassId, protestTime);
    }

    @Override
@@ -29,13 +31,13 @@ public class RaceLogProtestStartTimeEventImpl extends RaceLogEventImpl implement
    }

    @Override
-    public TimePoint getProtestStartTime() {
-        return protestStartTime;
+    public TimeRange getProtestTime() {
+        return protestTime;
    }

    @Override
    public String getShortInfo() {
-        return "protestStartTime=" + protestStartTime;
+        return "protestStartTime=" + protestTime.from() + ", protestEndTime=" + protestTime.to();
    }

 }
@@ -19,6 +19,7 @@ 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;
+import com.sap.sse.common.TimeRange;

 /**
 * Extension to the {@link ReadonlyRaceState} allowing write-access to the state of a race.
@@ -142,9 +143,9 @@ public interface RaceState extends ReadonlyRaceState {
    void setFinishedTime(TimePoint now);

    /**
-     * Sets the protest (start) time.
+     * Sets the protest time.
     */
-    void setProtestTime(TimePoint now, TimePoint protestStartTime);
+    void setProtestTime(TimePoint now, TimeRange protestTime);

    /**
     * Signals the abort of this race.
@@ -14,6 +14,7 @@ import com.sap.sailing.domain.base.configuration.RegattaConfiguration;
 import com.sap.sailing.domain.common.Wind;
 import com.sap.sailing.domain.common.racelog.RaceLogRaceStatus;
 import com.sap.sse.common.TimePoint;
+import com.sap.sse.common.TimeRange;

 /**
 * This interface gives you reading access to the state of a race. You can query various properties of the race
@@ -134,7 +135,7 @@ public interface ReadonlyRaceState extends RaceStateEventProcessor {
    /**
     * If there is a protest time set, returns the most recent one. Otherwise <code>null</code>.
     */
-    TimePoint getProtestTime();
+    TimeRange getProtestTime();

    /**
     * If there is a course set, returns the most recent one. Otherwise <code>null</code>.
@@ -8,7 +8,16 @@ public enum RaceStateEvents {
    RRS26_CLASS_UP,
    RRS26_STARTMODE_UP,
    RRS26_STARTMODE_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,
    ESS_TWO_UP,
@@ -45,6 +45,7 @@ import com.sap.sailing.domain.common.racelog.RaceLogRaceStatus;
 import com.sap.sailing.domain.common.racelog.RacingProcedureType;
 import com.sap.sse.common.Duration;
 import com.sap.sse.common.TimePoint;
+import com.sap.sse.common.TimeRange;

 /**
 * Write-enabled {@link RaceState}.
@@ -169,8 +170,9 @@ public class RaceStateImpl extends ReadonlyRaceStateImpl implements RaceState {
    }

    @Override
-    public void setProtestTime(TimePoint now, TimePoint timePoint) {
-        raceLog.add(new RaceLogProtestStartTimeEventImpl(now, author, raceLog.getCurrentPassId(), timePoint));
+    public void setProtestTime(TimePoint now, TimeRange protestTime) {
+        assert protestTime != null && protestTime.from() != null && protestTime.to() != null;
+        raceLog.add(new RaceLogProtestStartTimeEventImpl(now, author, raceLog.getCurrentPassId(), protestTime));
    }

    @Override
@@ -18,7 +18,7 @@ import com.sap.sailing.domain.abstractlog.race.analyzing.impl.FinishedTimeFinder
 import com.sap.sailing.domain.abstractlog.race.analyzing.impl.FinishingTimeFinder;
 import com.sap.sailing.domain.abstractlog.race.analyzing.impl.LastPublishedCourseDesignFinder;
 import com.sap.sailing.domain.abstractlog.race.analyzing.impl.LastWindFixFinder;
-import com.sap.sailing.domain.abstractlog.race.analyzing.impl.ProtestStartTimeFinder;
+import com.sap.sailing.domain.abstractlog.race.analyzing.impl.ProtestTimeFinder;
 import com.sap.sailing.domain.abstractlog.race.analyzing.impl.RaceLogResolver;
 import com.sap.sailing.domain.abstractlog.race.analyzing.impl.RaceStatusAnalyzer;
 import com.sap.sailing.domain.abstractlog.race.analyzing.impl.RaceStatusAnalyzer.Clock;
@@ -42,6 +42,7 @@ import com.sap.sailing.domain.common.Wind;
 import com.sap.sailing.domain.common.racelog.RaceLogRaceStatus;
 import com.sap.sailing.domain.common.racelog.RacingProcedureType;
 import com.sap.sse.common.TimePoint;
+import com.sap.sse.common.TimeRange;
 import com.sap.sse.common.Util;

 /**
@@ -116,7 +117,7 @@ public class ReadonlyRaceStateImpl implements ReadonlyRaceState, RaceLogChangedL
    private final StartTimeFinder startTimeAnalyzer;
    private final FinishingTimeFinder finishingTimeAnalyzer;
    private final FinishedTimeFinder finishedTimeAnalyzer;
-    private final ProtestStartTimeFinder protestTimeAnalyzer;
+    private final ProtestTimeFinder protestTimeAnalyzer;

    private final FinishPositioningListFinder finishPositioningListAnalyzer;
    private final ConfirmedFinishPositioningListFinder confirmedFinishPositioningListAnalyzer;
@@ -141,7 +142,7 @@ public class ReadonlyRaceStateImpl implements ReadonlyRaceState, RaceLogChangedL
    private StartTimeFinderResult cachedStartTimeFinderResult;
    private TimePoint cachedFinishingTime;
    private TimePoint cachedFinishedTime;
-    private TimePoint cachedProtestTime;
+    private TimeRange cachedProtest;
    private CompetitorResults cachedPositionedCompetitors;
    private CompetitorResults cachedConfirmedPositionedCompetitors;
    private CourseBase cachedCourseDesign;
@@ -184,7 +185,7 @@ public class ReadonlyRaceStateImpl implements ReadonlyRaceState, RaceLogChangedL
        this.startTimeAnalyzer = new StartTimeFinder(raceLogResolver, raceLog);
        this.finishingTimeAnalyzer = new FinishingTimeFinder(raceLog);
        this.finishedTimeAnalyzer = new FinishedTimeFinder(raceLog);
-        this.protestTimeAnalyzer = new ProtestStartTimeFinder(raceLog);
+        this.protestTimeAnalyzer = new ProtestTimeFinder(raceLog);
        this.finishPositioningListAnalyzer = new FinishPositioningListFinder(raceLog);
        this.confirmedFinishPositioningListAnalyzer = new ConfirmedFinishPositioningListFinder(raceLog);
        this.courseDesignerAnalyzer = new LastPublishedCourseDesignFinder(raceLog, /* onlyCoursesWithValidWaypointList */ false);
@@ -318,8 +319,8 @@ public class ReadonlyRaceStateImpl implements ReadonlyRaceState, RaceLogChangedL
    }

    @Override
-    public TimePoint getProtestTime() {
-        return cachedProtestTime;
+    public TimeRange getProtestTime() {
+        return cachedProtest;
    }

    @Override
@@ -459,9 +460,9 @@ public class ReadonlyRaceStateImpl implements ReadonlyRaceState, RaceLogChangedL
            changedListeners.onFinishedTimeChanged(this);
        }

-        TimePoint protestTime = protestTimeAnalyzer.analyze();
-        if (!Util.equalsWithNull(cachedProtestTime, protestTime)) {
-            cachedProtestTime = protestTime;
+        TimeRange protest = protestTimeAnalyzer.analyze();
+        if (!Util.equalsWithNull(cachedProtest, protest)) {
+            cachedProtest = protest;
            changedListeners.onProtestTimeChanged(this);
        }

@@ -2,7 +2,7 @@ package com.sap.sailing.domain.abstractlog.race.state.racingprocedure;

 import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.gate.impl.GateLaunchTimePrerequisite;
 import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.gate.impl.PathfinderPrerequisite;
-import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.rrs26.impl.StartmodePrerequisite;
+import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.line.impl.StartModePrerequisite;

 /**
 * Something that has to be fulfilled before the race can start (e.g. decide which start mode flag is shown).
@@ -11,7 +11,7 @@ public interface RacingProcedurePrerequisite {

    /**
     * In charge of fulfilling all {@link RacingProcedurePrerequisite}. Implementations must call the
-     * {@link RacingProcedurePrerequisite} "fulfill" (or {@link RacingProcedurePrerequisite#fulfillWithDefault()}
+     * {@link RacingProcedurePrerequisite#resolve(Resolver)} or {@link RacingProcedurePrerequisite#fulfillWithDefault()}
     * methods to let the framework decide whether there are more prerequisites or the race can start.
     */
    public interface Resolver {
@@ -24,7 +24,7 @@ public interface RacingProcedurePrerequisite {

        void fulfill(GateLaunchTimePrerequisite prerequisite);

-        void fulfill(StartmodePrerequisite prerequisite);
+        void fulfill(StartModePrerequisite prerequisite);
    }

    /**
@@ -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);

@@ -33,7 +33,7 @@ import com.sap.sse.common.Util;

 public class GateStartRacingProcedureImpl extends BaseRacingProcedure implements GateStartRacingProcedure {

-    private final static long startPhaseClassOverGolfUpIntervall = 8 * 60 * 1000; // minutes * seconds * milliseconds
+    private final static long startPhaseClassOverGolfUpInterval = 8 * 60 * 1000; // minutes * seconds * milliseconds
    private final static long startPhasePapaUpInterval = 4 * 60 * 1000; // minutes * seconds * milliseconds
    private final static long startPhasePapaDownInterval = 1 * 60 * 1000; // minutes * seconds * milliseconds

@@ -99,7 +99,7 @@ public class GateStartRacingProcedureImpl extends BaseRacingProcedure implements
    public boolean isStartphaseActive(TimePoint startTime, TimePoint now) {
        if (now.before(startTime)) {
            long timeTillStart = startTime.minus(now.asMillis()).asMillis();
-            return timeTillStart < startPhaseClassOverGolfUpIntervall;
+            return timeTillStart < startPhaseClassOverGolfUpInterval;
        }
        return false;
    }
@@ -121,7 +121,7 @@ public class GateStartRacingProcedureImpl extends BaseRacingProcedure implements
    @Override
    protected Collection<RaceStateEvent> createStartStateEvents(TimePoint startTime) {
        return Arrays.<RaceStateEvent> asList(
-                new RaceStateEventImpl(startTime.minus(startPhaseClassOverGolfUpIntervall),
+                new RaceStateEventImpl(startTime.minus(startPhaseClassOverGolfUpInterval),
                        RaceStateEvents.GATE_CLASS_OVER_GOLF_UP),
                new RaceStateEventImpl(startTime.minus(startPhasePapaUpInterval), RaceStateEvents.GATE_PAPA_UP),
                new RaceStateEventImpl(startTime.minus(startPhasePapaDownInterval), RaceStateEvents.GATE_PAPA_DOWN),
@@ -153,13 +153,13 @@ public class GateStartRacingProcedureImpl extends BaseRacingProcedure implements
    public FlagPoleState getActiveFlags(TimePoint startTime, TimePoint now) {
        Flags classFlag = getConfiguration().getClassFlag() != null ? getConfiguration().getClassFlag() : Flags.CLASS;
        TimePoint gateShutdownTime = getGateShutdownTimePoint(startTime);
-        if (now.before(startTime.minus(startPhaseClassOverGolfUpIntervall))) {
+        if (now.before(startTime.minus(startPhaseClassOverGolfUpInterval))) {
            return new FlagPoleState(Arrays.asList(new FlagPole(classFlag, Flags.GOLF, false), new FlagPole(Flags.PAPA,
                    false)), null, Arrays.asList(new FlagPole(classFlag, Flags.GOLF, true), new FlagPole(Flags.PAPA,
-                    false)), startTime.minus(startPhaseClassOverGolfUpIntervall));
+                    false)), startTime.minus(startPhaseClassOverGolfUpInterval));
        } else if (now.before(startTime.minus(startPhasePapaUpInterval))) {
            return new FlagPoleState(Arrays.asList(new FlagPole(classFlag, Flags.GOLF, true), new FlagPole(Flags.PAPA,
-                    false)), startTime.minus(startPhaseClassOverGolfUpIntervall), Arrays.asList(new FlagPole(classFlag,
+                    false)), startTime.minus(startPhaseClassOverGolfUpInterval), Arrays.asList(new FlagPole(classFlag,
                    Flags.GOLF, true), new FlagPole(Flags.PAPA, true)), startTime.minus(startPhasePapaUpInterval));
        } else if (now.before(startTime.minus(startPhasePapaDownInterval))) {
            return new FlagPoleState(Arrays.asList(new FlagPole(classFlag, Flags.GOLF, true), new FlagPole(Flags.PAPA,
@@ -4,7 +4,7 @@ import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.RacingProce
 import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.RacingProcedurePrerequisite.Resolver;
 import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.gate.impl.GateLaunchTimePrerequisite;
 import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.gate.impl.PathfinderPrerequisite;
-import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.rrs26.impl.StartmodePrerequisite;
+import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.line.impl.StartModePrerequisite;

 /**
 * Always calls {@link RacingProcedurePrerequisite#fulfillWithDefault()}.
@@ -22,13 +22,11 @@ public class RacingProcedurePrerequisiteAutoResolver implements Resolver {
    }

    @Override
-    public void fulfill(StartmodePrerequisite prerequisite) {
+    public void fulfill(StartModePrerequisite prerequisite) {
        prerequisite.fulfillWithDefault();
    }

    @Override
    public void onFulfilled() {
-        
    }
-
 }
@@ -12,7 +12,8 @@ import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.basic.impl.
 import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.ess.impl.ESSRacingProcedureImpl;
 import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.gate.impl.GateStartRacingProcedureImpl;
 import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.league.impl.LeagueRacingProcedureImpl;
-import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.rrs26.impl.RRS26RacingProcedureImpl;
+import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.line.impl.RRS26RacingProcedureImpl;
+import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.line.impl.SWCRacingProcedureImpl;
 import com.sap.sailing.domain.base.configuration.ConfigurationLoader;
 import com.sap.sailing.domain.base.configuration.RegattaConfiguration;
 import com.sap.sailing.domain.common.racelog.RacingProcedureType;
@@ -47,6 +48,8 @@ public class ReadonlyRacingProcedureFactory implements RacingProcedureFactory {
                    loadedConfiguration.getGateStartConfiguration(), raceLogResolver);
        case RRS26:
            return new RRS26RacingProcedureImpl(raceLog, author, loadedConfiguration.getRRS26Configuration(), raceLogResolver);
+        case SWC:
+            return new SWCRacingProcedureImpl(raceLog, author, loadedConfiguration.getSWCStartConfiguration(), raceLogResolver);
        case BASIC:
            return new BasicRacingProcedureImpl(raceLog, author, loadedConfiguration.getBasicConfiguration(), raceLogResolver);
        case LEAGUE:
@@ -0,0 +1,29 @@
+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;
+import com.sap.sse.common.TimePoint;
+
+/**
+ * A racing procedure for the typical line start as described in the 'Racing Rules of Sailing' (RRS)
+ * published by the World Sailing association.
+ * @author Frank
+ *
+ */
+public interface ConfigurableStartModeFlagRacingProcedure extends RacingProcedure  {
+
+    void addChangedListener(LineStartChangedListener listener);
+    
+    ConfigurableStartModeFlagRacingProcedureConfiguration getConfiguration();
+    
+    Flags getStartModeFlag();
+    
+    Flags getDefaultStartMode();
+    
+    List<Flags> getDefaultStartModeFlags();
+    
+    void setStartModeFlag(TimePoint timePoint, Flags startMode);
+}
@@ -0,0 +1,9 @@
+package com.sap.sailing.domain.abstractlog.race.state.racingprocedure.line;
+
+import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.RacingProcedureChangedListener;
+
+public interface LineStartChangedListener extends RacingProcedureChangedListener {
+    
+    void onStartModeChanged(ConfigurableStartModeFlagRacingProcedure racingProcedure);
+
+}
@@ -0,0 +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 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();
+}
@@ -0,0 +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 DEFAULT_START_MODE = Flags.UNIFORM;
+    public final static List<Flags> DEFAULT_START_MODE_FLAGS = Arrays.asList(Flags.BLACK, Flags.UNIFORM);
+    
+    SWCStartConfiguration getConfiguration();
+}
@@ -0,0 +1,105 @@
+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.ConfigurableStartModeFlagRacingProcedure;
+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,
+            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);
+        }
+        super.update();
+    }
+
+    @Override
+    protected RacingProcedureChangedListeners<? extends RacingProcedureChangedListener> createChangedListenerContainer() {
+        return new LineStartChangedListeners();
+    }
+    
+    @Override
+    protected LineStartChangedListeners getChangedListeners() {
+        return (LineStartChangedListeners) super.getChangedListeners();
+    }
+
+    @Override
+    public void addChangedListener(LineStartChangedListener listener) {
+        getChangedListeners().add(listener);
+    }
+    
+    @Override
+    public ConfigurableStartModeFlagRacingProcedureConfiguration getConfiguration() {
+        return (ConfigurableStartModeFlagRacingProcedureConfiguration) super.getConfiguration();
+    }
+}
@@ -0,0 +1,16 @@
+package com.sap.sailing.domain.abstractlog.race.state.racingprocedure.line.impl;
+
+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;
+
+public class LineStartChangedListeners extends RacingProcedureChangedListeners<LineStartChangedListener> implements
+        LineStartChangedListener {
+
+    @Override
+    public void onStartModeChanged(ConfigurableStartModeFlagRacingProcedure racingProcedure) {
+        for (LineStartChangedListener listener : getListeners()) {
+            listener.onStartModeChanged(racingProcedure);
+        }
+    }
+}
@@ -1,59 +1,39 @@
-package com.sap.sailing.domain.abstractlog.race.state.racingprocedure.rrs26.impl;
+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.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.rrs26.RRS26ChangedListener;
-import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.rrs26.RRS26RacingProcedure;
+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 BaseRacingProcedure implements RRS26RacingProcedure {
+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
@@ -66,7 +46,7 @@ public class RRS26RacingProcedureImpl extends BaseRacingProcedure implements RRS
        boolean hasRecall = super.hasIndividualRecall();
        if (!hasRecall) {
            return false;
-        } else if (startmodeFlagHasBeenSet) {
+        } else if (startmodeFlagHasBeenSet()) {
            return cachedStartmodeFlag != Flags.BLACK;
        } else {
            return hasRecall;
@@ -83,24 +63,6 @@ public class RRS26RacingProcedureImpl extends BaseRacingProcedure implements RRS
        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(
@@ -114,7 +76,7 @@ public class RRS26RacingProcedureImpl extends BaseRacingProcedure implements RRS
    public boolean processStateEvent(RaceStateEvent event) {
        switch (event.getEventName()) {
        case RRS26_STARTMODE_UP:
-            if (!startmodeFlagHasBeenSet) {
+            if (!startmodeFlagHasBeenSet()) {
                setStartModeFlag(event.getTimePoint(), cachedStartmodeFlag);
            }
        case RRS26_CLASS_UP:
@@ -178,48 +140,17 @@ public class RRS26RacingProcedureImpl extends BaseRacingProcedure implements RRS
    }
    
    @Override
-    protected RacingProcedureChangedListeners<? extends RacingProcedureChangedListener> createChangedListenerContainer() {
-        return new RRS26ChangedListeners();
-    }
-    
-    @Override
-    protected RRS26ChangedListeners getChangedListeners() {
-        return (RRS26ChangedListeners) super.getChangedListeners();
+    public Flags getDefaultStartMode() {
+        return RRS26RacingProcedure.DEFAULT_START_MODE;
    }

    @Override
-    public void addChangedListener(RRS26ChangedListener listener) {
-        getChangedListeners().add(listener);
+    public List<Flags> getDefaultStartModeFlags() {
+        return RRS26RacingProcedure.DEFAULT_START_MODE_FLAGS;
    }

-    @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;
-    }
-    
-    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();
-    }
-    
    @Override
    public RRS26Configuration getConfiguration() {
        return (RRS26Configuration) super.getConfiguration();
    }
-
 }
@@ -0,0 +1,192 @@
+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.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.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 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);
+    }
+
+    @Override
+    protected Duration getStartPhaseStartModeUpInterval() {
+        return CLASS_AND_STARTMODE_UP_INTERVAL;
+    }
+
+    @Override
+    public RacingProcedureType getType() {
+        return RacingProcedureType.SWC;
+    }
+    
+    @Override
+    public boolean hasIndividualRecall() {
+        boolean hasRecall = super.hasIndividualRecall();
+        if (!hasRecall) {
+            return false;
+        } else if (startmodeFlagHasBeenSet()) {
+            return cachedStartmodeFlag != Flags.BLACK;
+        } else {
+            return hasRecall;
+        }
+    }
+    
+    @Override
+    protected boolean hasIndividualRecallByDefault() {
+        return true;
+    }
+    
+    @Override
+    protected Boolean isResultEntryEnabledByDefault() {
+        return false;
+    }
+
+    @Override
+    protected Collection<RaceStateEvent> createStartStateEvents(TimePoint startTime) {
+        return Arrays.<RaceStateEvent> asList(
+                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, 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_CLASS_AND_STARTMODE_UP:
+            if (!startmodeFlagHasBeenSet()) {
+                setStartModeFlag(event.getTimePoint(), cachedStartmodeFlag);
+            }
+        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:
+            return super.processStateEvent(event);
+        }
+    }
+
+    @Override
+    public FlagPoleState getActiveFlags(TimePoint startTime, TimePoint now) {
+        if (now.before(startTime.minus(CLASS_AND_STARTMODE_UP_INTERVAL))) {
+            return new FlagPoleState(
+                    Arrays.asList(new FlagPole(cachedStartmodeFlag, false)),
+                    null,
+                    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(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(
+                        Arrays.asList(new FlagPole(Flags.XRAY, true)),
+                        getIndividualRecallDisplayedTime(),
+                        Arrays.asList(new FlagPole(Flags.XRAY, false)),
+                        getIndividualRecallRemovalTime());
+            } else if (isFinished(now)) {
+                return new FlagPoleState(
+                        Arrays.asList(new FlagPole(Flags.BLUE, false)), getFinishedTime());
+            } else if (isInFinishingPhase(now)) {
+                return new FlagPoleState(
+                        Arrays.asList(new FlagPole(Flags.BLUE, true)),
+                        getFinishingTime(),
+                        Arrays.asList(new FlagPole(Flags.BLUE, false)),
+                        null);
+            } else {
+                TimePoint recallRemoved = getIndividualRecallRemovalTime();
+                return new FlagPoleState(Collections.<FlagPole>emptyList(), recallRemoved == null ? startTime.plus(CLASS_AND_STARTMODE_DOWN_INTERVAL) : recallRemoved);
+            }
+        }
+    }
+
+    @Override
+    public Flags getDefaultStartMode() {
+        return SWCRacingProcedure.DEFAULT_START_MODE;
+    }
+
+    @Override
+    public List<Flags> getDefaultStartModeFlags() {
+        return SWCRacingProcedure.DEFAULT_START_MODE_FLAGS;
+    }
+
+    @Override
+    public SWCStartConfiguration getConfiguration() {
+        return (SWCStartConfiguration) super.getConfiguration();
+    }
+}
@@ -1,14 +1,15 @@
-package com.sap.sailing.domain.abstractlog.race.state.racingprocedure.rrs26.impl;
+package com.sap.sailing.domain.abstractlog.race.state.racingprocedure.line.impl;

 import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.RacingProcedurePrerequisite;
-import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.rrs26.RRS26RacingProcedure;
+import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.impl.BaseRacingProcedurePrerequisite;
+import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.line.ConfigurableStartModeFlagRacingProcedure;
 import com.sap.sailing.domain.common.racelog.Flags;
 import com.sap.sse.common.TimePoint;

-public class StartmodePrerequisite extends BaseRRS26Prerequisite implements RacingProcedurePrerequisite {
+public class StartModePrerequisite extends BaseRacingProcedurePrerequisite implements RacingProcedurePrerequisite {

-    public StartmodePrerequisite(FulfillmentFunction function, RRS26RacingProcedure procedure, TimePoint originalNow,
-            TimePoint originalStartTime) {
+    public StartModePrerequisite(FulfillmentFunction function, ConfigurableStartModeFlagRacingProcedure procedure,
+            TimePoint originalNow, TimePoint originalStartTime) {
        super(function, procedure, originalNow, originalStartTime);
    }

@@ -24,7 +25,10 @@ public class StartmodePrerequisite extends BaseRRS26Prerequisite implements Raci
    
    @Override
    public void fulfillWithDefault() {
-        fulfill(RRS26RacingProcedure.DefaultStartMode);
+        fulfill(getProcedure().getDefaultStartMode());
+    }
+    
+    protected ConfigurableStartModeFlagRacingProcedure getProcedure() {
+        return (ConfigurableStartModeFlagRacingProcedure) procedure;
    }
-
 }
@@ -1,9 +0,0 @@
-package com.sap.sailing.domain.abstractlog.race.state.racingprocedure.rrs26;
-
-import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.RacingProcedureChangedListener;
-
-public interface RRS26ChangedListener extends RacingProcedureChangedListener {
-    
-    void onStartmodeChanged(ReadonlyRRS26RacingProcedure racingProcedure);
-
-}
@@ -1,10 +0,0 @@
-package com.sap.sailing.domain.abstractlog.race.state.racingprocedure.rrs26;
-
-import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.RacingProcedure;
-import com.sap.sailing.domain.common.racelog.Flags;
-import com.sap.sse.common.TimePoint;
-
-public interface RRS26RacingProcedure extends ReadonlyRRS26RacingProcedure, RacingProcedure  {
-
-    void setStartModeFlag(TimePoint timePoint, Flags startMode);
-}
@@ -1,17 +0,0 @@
-package com.sap.sailing.domain.abstractlog.race.state.racingprocedure.rrs26;
-
-import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.ReadonlyRacingProcedure;
-import com.sap.sailing.domain.base.configuration.procedures.RRS26Configuration;
-import com.sap.sailing.domain.common.racelog.Flags;
-
-public interface ReadonlyRRS26RacingProcedure extends ReadonlyRacingProcedure {
-    
-    public final static Flags DefaultStartMode = Flags.PAPA;
-    
-    void addChangedListener(RRS26ChangedListener listener);
-    
-    RRS26Configuration getConfiguration();
-    
-    Flags getStartModeFlag();
-
-}
@@ -1,22 +0,0 @@
-package com.sap.sailing.domain.abstractlog.race.state.racingprocedure.rrs26.impl;
-
-import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.RacingProcedurePrerequisite;
-import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.impl.BaseRacingProcedurePrerequisite;
-import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.rrs26.RRS26RacingProcedure;
-import com.sap.sse.common.TimePoint;
-
-/**
- * Easy access to the {@link RRS26RacingProcedure}.
- */
-public abstract class BaseRRS26Prerequisite extends BaseRacingProcedurePrerequisite implements RacingProcedurePrerequisite {
-
-    public BaseRRS26Prerequisite(FulfillmentFunction function, RRS26RacingProcedure procedure, TimePoint originalNow,
-            TimePoint originalStartTime) {
-        super(function, procedure, originalNow, originalStartTime);
-    }
-
-    protected RRS26RacingProcedure getProcedure() {
-        return (RRS26RacingProcedure) procedure;
-    }
-
-}
@@ -1,17 +0,0 @@
-package com.sap.sailing.domain.abstractlog.race.state.racingprocedure.rrs26.impl;
-
-import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.impl.RacingProcedureChangedListeners;
-import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.rrs26.RRS26ChangedListener;
-import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.rrs26.ReadonlyRRS26RacingProcedure;
-
-public class RRS26ChangedListeners extends RacingProcedureChangedListeners<RRS26ChangedListener> implements
-        RRS26ChangedListener {
-
-    @Override
-    public void onStartmodeChanged(ReadonlyRRS26RacingProcedure racingProcedure) {
-        for (RRS26ChangedListener listener : getListeners()) {
-            listener.onStartmodeChanged(racingProcedure);
-        }
-    }
-
-}
@@ -7,6 +7,7 @@ import com.sap.sailing.domain.base.configuration.procedures.ESSConfiguration;
 import com.sap.sailing.domain.base.configuration.procedures.GateStartConfiguration;
 import com.sap.sailing.domain.base.configuration.procedures.LeagueConfiguration;
 import com.sap.sailing.domain.base.configuration.procedures.RRS26Configuration;
+import com.sap.sailing.domain.base.configuration.procedures.SWCStartConfiguration;
 import com.sap.sailing.domain.common.CourseDesignerMode;
 import com.sap.sailing.domain.common.racelog.RacingProcedureType;

@@ -31,7 +32,13 @@ public interface RegattaConfiguration extends Serializable, Cloneable {
     * @return <code>null</code> if there is no configuration.
     */
    RRS26Configuration getRRS26Configuration();
-    
+
+    /**
+     * Gets the configuration for SWC races.
+     * @return <code>null</code> if there is no configuration.
+     */
+    SWCStartConfiguration getSWCStartConfiguration();
+
    /**
     * Gets the configuration for Gate Start races.
     * @return <code>null</code> if there is no configuration.
@@ -1,21 +1,12 @@
 package com.sap.sailing.domain.base.configuration.impl;

-import com.sap.sailing.domain.base.configuration.RacingProcedureConfiguration;
 import com.sap.sailing.domain.base.configuration.procedures.ESSConfiguration;

 public class ESSConfigurationImpl extends RacingProcedureConfigurationImpl implements ESSConfiguration {

    private static final long serialVersionUID = 5406098147408723197L;

-    protected ESSConfiguration copy() {
-        ESSConfigurationImpl copy = (ESSConfigurationImpl) super.copy(new ESSConfigurationImpl());
-        return copy;
+    protected ESSConfigurationImpl newInstance() {
+        return new ESSConfigurationImpl();
    }
-    
-    @Override
-    public RacingProcedureConfiguration merge(RacingProcedureConfiguration update) {
-        ESSConfigurationImpl target = (ESSConfigurationImpl) super.merge(update);
-        return target;
-    }
-
 }
@@ -18,6 +18,7 @@ public class EmptyRegattaConfiguration extends RegattaConfigurationImpl implemen
        setDefaultRacingProcedureType(RacingProcedureType.UNKNOWN);
        setDefaultCourseDesignerMode(CourseDesignerMode.UNKNOWN);
        setRRS26Configuration(new RRS26ConfigurationImpl());
+        setSWCStartConfiguration(new SWCStartConfigurationImpl());
        setGateStartConfiguration(new GateStartConfigurationImpl());
        setESSConfiguration(new ESSConfigurationImpl());
        setBasicConfiguration(new RacingProcedureConfigurationImpl());
@@ -41,12 +41,16 @@ public class GateStartConfigurationImpl extends RacingProcedureConfigurationImpl
        return target;
    }
    
+    
+    @Override
+    protected GateStartConfigurationImpl newInstance() {
+        return new GateStartConfigurationImpl();
+    }
+
    protected GateStartConfiguration copy() {
-        GateStartConfigurationImpl copy = (GateStartConfigurationImpl) super.copy(new GateStartConfigurationImpl());
+        GateStartConfigurationImpl copy = (GateStartConfigurationImpl) super.copy();
        copy.setHasPathfinder(hasPathfinder);
        copy.setHasAdditionalGolfDownTime(hasAdditionalGolfDownTime);
        return copy;
    }
-    
-
 }
@@ -1,20 +1,11 @@
 package com.sap.sailing.domain.base.configuration.impl;

-import com.sap.sailing.domain.base.configuration.RacingProcedureConfiguration;
 import com.sap.sailing.domain.base.configuration.procedures.LeagueConfiguration;

 public class LeagueConfigurationImpl extends RacingProcedureConfigurationImpl implements LeagueConfiguration {
    private static final long serialVersionUID = 3625803505541394766L;

-    protected LeagueConfigurationImpl copy() {
-        LeagueConfigurationImpl copy = (LeagueConfigurationImpl) super.copy(new LeagueConfigurationImpl());
-        return copy;
+    protected LeagueConfigurationImpl newInstance() {
+        return new LeagueConfigurationImpl();
    }
-    
-    @Override
-    public RacingProcedureConfiguration merge(RacingProcedureConfiguration update) {
-        LeagueConfigurationImpl target = (LeagueConfigurationImpl) super.merge(update);
-        return target;
-    }
-
 }
@@ -1,27 +1,13 @@
 package com.sap.sailing.domain.base.configuration.impl;

-import java.util.List;
-
 import com.sap.sailing.domain.base.configuration.RacingProcedureConfiguration;
 import com.sap.sailing.domain.base.configuration.procedures.RRS26Configuration;
-import com.sap.sailing.domain.common.racelog.Flags;

-public class RRS26ConfigurationImpl extends RacingProcedureConfigurationImpl implements
-        RRS26Configuration {
+public class RRS26ConfigurationImpl extends RacingProcedureWithConfigurableStartModeFlagConfigurationImpl
+        implements RRS26Configuration {

    private static final long serialVersionUID = 260941807346644026L;
    
-    private List<Flags> startModeFlags;
-
-    @Override
-    public List<Flags> getStartModeFlags() {
-        return startModeFlags;
-    }
-    
-    public void setStartModeFlags(List<Flags> flags) {
-        this.startModeFlags = flags;
-    }
-    
    @Override
    public RacingProcedureConfiguration merge(RacingProcedureConfiguration value) {
        RRS26Configuration update = (RRS26Configuration) value;
@@ -32,10 +18,8 @@ public class RRS26ConfigurationImpl extends RacingProcedureConfigurationImpl imp
        return target;
    }

-    protected RRS26Configuration copy() {
-        RRS26ConfigurationImpl copy = (RRS26ConfigurationImpl) super.copy(new RRS26ConfigurationImpl());
-        copy.setStartModeFlags(startModeFlags);
-        return copy;
+    protected RRS26ConfigurationImpl newInstance() {
+        return new RRS26ConfigurationImpl();
    }

 }
@@ -49,8 +49,12 @@ public class RacingProcedureConfigurationImpl implements RacingProcedureConfigur
        this.isResultEntryEnabled = isResultEntryEnabled;
    }

+    protected RacingProcedureConfigurationImpl newInstance() {
+        return new RacingProcedureConfigurationImpl();
+    }
+    
    protected RacingProcedureConfiguration copy() {
-        return copy(new RacingProcedureConfigurationImpl());
+        return copy(newInstance());
    }
    
    protected RacingProcedureConfiguration copy(RacingProcedureConfigurationImpl target) {
@@ -0,0 +1,39 @@
+package com.sap.sailing.domain.base.configuration.impl;
+
+import java.util.List;
+
+import com.sap.sailing.domain.base.configuration.RacingProcedureConfiguration;
+import com.sap.sailing.domain.base.configuration.procedures.ConfigurableStartModeFlagRacingProcedureConfiguration;
+import com.sap.sailing.domain.common.racelog.Flags;
+
+public abstract class RacingProcedureWithConfigurableStartModeFlagConfigurationImpl extends RacingProcedureConfigurationImpl implements ConfigurableStartModeFlagRacingProcedureConfiguration {
+
+    private static final long serialVersionUID = 5141617199229598965L;
+
+    private List<Flags> startModeFlags;
+
+    @Override
+    public List<Flags> getStartModeFlags() {
+        return startModeFlags;
+    }
+    
+    public void setStartModeFlags(List<Flags> flags) {
+        this.startModeFlags = flags;
+    }
+    
+    @Override
+    public RacingProcedureConfiguration merge(RacingProcedureConfiguration value) {
+        ConfigurableStartModeFlagRacingProcedureConfiguration update = (ConfigurableStartModeFlagRacingProcedureConfiguration) value;
+        RacingProcedureWithConfigurableStartModeFlagConfigurationImpl target = (RacingProcedureWithConfigurableStartModeFlagConfigurationImpl) super.merge(update);
+        if (update.getStartModeFlags() != null) {
+            target.setStartModeFlags(update.getStartModeFlags());
+        }
+        return target;
+    }
+
+    protected ConfigurableStartModeFlagRacingProcedureConfiguration copy() {
+        RacingProcedureWithConfigurableStartModeFlagConfigurationImpl copy = (RacingProcedureWithConfigurableStartModeFlagConfigurationImpl) super.copy();
+        copy.setStartModeFlags(startModeFlags);
+        return copy;
+    }
+}
@@ -6,6 +6,7 @@ import com.sap.sailing.domain.base.configuration.procedures.ESSConfiguration;
 import com.sap.sailing.domain.base.configuration.procedures.GateStartConfiguration;
 import com.sap.sailing.domain.base.configuration.procedures.LeagueConfiguration;
 import com.sap.sailing.domain.base.configuration.procedures.RRS26Configuration;
+import com.sap.sailing.domain.base.configuration.procedures.SWCStartConfiguration;
 import com.sap.sailing.domain.common.CourseDesignerMode;
 import com.sap.sailing.domain.common.racelog.RacingProcedureType;

@@ -17,6 +18,7 @@ public class RegattaConfigurationImpl implements RegattaConfiguration {
    private CourseDesignerMode defaultCourseDesignerMode;
    
    private RRS26Configuration rrs26Configuration;
+    private SWCStartConfiguration swcStartConfiguration;
    private GateStartConfiguration gateStartConfiguration;
    private ESSConfiguration essConfiguration;
    private LeagueConfiguration leagueConfiguration;
@@ -49,6 +51,15 @@ public class RegattaConfigurationImpl implements RegattaConfiguration {
        this.rrs26Configuration = rrs26Configuration;
    }

+    @Override
+    public SWCStartConfiguration getSWCStartConfiguration() {
+        return swcStartConfiguration;
+    }
+
+    public void setSWCStartConfiguration(SWCStartConfiguration swcStartConfiguration) {
+        this.swcStartConfiguration = swcStartConfiguration;
+    }
+
    @Override
    public GateStartConfiguration getGateStartConfiguration() {
        return gateStartConfiguration;
@@ -91,6 +102,7 @@ public class RegattaConfigurationImpl implements RegattaConfiguration {
        copy.setDefaultRacingProcedureType(defaultRacingProcedureType);
        copy.setDefaultCourseDesignerMode(defaultCourseDesignerMode);
        copy.setRRS26Configuration(rrs26Configuration);
+        copy.setSWCStartConfiguration(swcStartConfiguration);
        copy.setGateStartConfiguration(gateStartConfiguration);
        copy.setESSConfiguration(essConfiguration);
        copy.setBasicConfiguration(basicConfiguration);
@@ -112,6 +124,10 @@ public class RegattaConfigurationImpl implements RegattaConfiguration {
            target.setRRS26Configuration(
                    (RRS26Configuration) target.getRRS26Configuration().merge(update.getRRS26Configuration()));
        }
+        if (update.getSWCStartConfiguration() != null) {
+            target.setSWCStartConfiguration(
+                    (SWCStartConfiguration) target.getSWCStartConfiguration().merge(update.getSWCStartConfiguration()));
+        }
        if (update.getGateStartConfiguration() != null) {
            target.setGateStartConfiguration(
                    (GateStartConfiguration) target.getGateStartConfiguration().merge(update.getGateStartConfiguration()));
@@ -0,0 +1,24 @@
+package com.sap.sailing.domain.base.configuration.impl;
+
+import com.sap.sailing.domain.base.configuration.RacingProcedureConfiguration;
+import com.sap.sailing.domain.base.configuration.procedures.SWCStartConfiguration;
+
+public class SWCStartConfigurationImpl extends RacingProcedureWithConfigurableStartModeFlagConfigurationImpl
+        implements SWCStartConfiguration {
+
+    private static final long serialVersionUID = 5141617199229598965L;
+
+    @Override
+    public RacingProcedureConfiguration merge(RacingProcedureConfiguration value) {
+        SWCStartConfiguration update = (SWCStartConfiguration) value;
+        SWCStartConfigurationImpl target = (SWCStartConfigurationImpl) super.merge(update);
+        if (update.getStartModeFlags() != null) {
+            target.setStartModeFlags(update.getStartModeFlags());
+        }
+        return target;
+    }
+    
+    protected SWCStartConfigurationImpl newInstance() {
+        return new SWCStartConfigurationImpl();
+    }
+}
@@ -0,0 +1,11 @@
+package com.sap.sailing.domain.base.configuration.procedures;
+
+import java.util.List;
+
+import com.sap.sailing.domain.base.configuration.RacingProcedureConfiguration;
+import com.sap.sailing.domain.common.racelog.Flags;
+
+public interface ConfigurableStartModeFlagRacingProcedureConfiguration extends RacingProcedureConfiguration {
+    
+    List<Flags> getStartModeFlags();
+}
@@ -1,12 +1,4 @@
-package com.sap.sailing.domain.base.configuration.procedures;
-
-import java.util.List;
-
-import com.sap.sailing.domain.base.configuration.RacingProcedureConfiguration;
-import com.sap.sailing.domain.common.racelog.Flags;
-
-public interface RRS26Configuration extends RacingProcedureConfiguration {
-    
-    List<Flags> getStartModeFlags();
-
-}
+package com.sap.sailing.domain.base.configuration.procedures;
+
+public interface RRS26Configuration extends ConfigurableStartModeFlagRacingProcedureConfiguration {
+}
@@ -0,0 +1,10 @@
+package com.sap.sailing.domain.base.configuration.procedures;
+
+
+/**
+ * Start procedure for the Sailing World Cup
+ * @author Frank
+ *
+ */
+public interface SWCStartConfiguration extends ConfigurableStartModeFlagRacingProcedureConfiguration {
+}