Merge branch 'master' into bug2563_2

java/com.sap.sailing.domain.shared.android/META-INF/MANIFEST.MF

@@ -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,

java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/abstractlog/race/RaceLogProtestStartTimeEvent.java

@@ -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();
 }

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

@@ -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;

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

@@ -1,6 +1,5 @@
 package com.sap.sailing.domain.abstractlog.race.analyzing.impl;
 
-import java.util.Arrays;
 import java.util.List;
 
 import com.sap.sailing.domain.abstractlog.race.RaceLog;
@@ -9,25 +8,19 @@ import com.sap.sailing.domain.abstractlog.race.RaceLogFlagEvent;
 import com.sap.sailing.domain.common.racelog.Flags;
 import com.sap.sailing.domain.common.racelog.RacingProcedureType;
 
-public class 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;
     }
-    
-    
-
 }

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

@@ -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();
     }
 
 }

java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/abstractlog/race/state/RaceState.java

@@ -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.

java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/abstractlog/race/state/ReadonlyRaceState.java

@@ -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>.

java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/abstractlog/race/state/impl/RaceStateEvents.java

@@ -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,

java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/abstractlog/race/state/impl/RaceStateImpl.java

@@ -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

java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/abstractlog/race/state/impl/ReadonlyRaceStateImpl.java

@@ -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);
         }
 

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

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

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

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

java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/abstractlog/race/state/racingprocedure/gate/impl/GateStartRacingProcedureImpl.java

@@ -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,

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

@@ -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() {
-        
     }
-
 }

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

@@ -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:

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

@@ -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);
+}

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

@@ -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);
+
+}

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

@@ -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();
+}

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

@@ -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();
+}

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

@@ -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();
+    }
+}

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

@@ -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);
+        }
+    }
+}

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

@@ -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();
     }
-
 }

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

@@ -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();
+    }
+}

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

@@ -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;
     }
-
 }

java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/abstractlog/race/state/racingprocedure/rrs26/RRS26ChangedListener.java

@@ -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);
-
-}

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

@@ -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);
-}

java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/abstractlog/race/state/racingprocedure/rrs26/ReadonlyRRS26RacingProcedure.java

@@ -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();
-
-}

java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/abstractlog/race/state/racingprocedure/rrs26/impl/BaseRRS26Prerequisite.java

@@ -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;
-    }
-
-}

java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/abstractlog/race/state/racingprocedure/rrs26/impl/RRS26ChangedListeners.java

@@ -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);
-        }
-    }
-
-}

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

@@ -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.

java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/base/configuration/impl/ESSConfigurationImpl.java

@@ -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;
-    }
-
 }

java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/base/configuration/impl/EmptyRegattaConfiguration.java

@@ -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());

java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/base/configuration/impl/GateStartConfigurationImpl.java

@@ -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;
     }
-    
-
 }

java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/base/configuration/impl/LeagueConfigurationImpl.java

@@ -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;
-    }
-
 }

java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/base/configuration/impl/RRS26ConfigurationImpl.java

@@ -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();
     }
 
 }

java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/base/configuration/impl/RacingProcedureConfigurationImpl.java

@@ -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) {

java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/base/configuration/impl/RacingProcedureWithConfigurableStartModeFlagConfigurationImpl.java

@@ -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;
+    }
+}

java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/base/configuration/impl/RegattaConfigurationImpl.java

@@ -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()));

java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/base/configuration/impl/SWCStartConfigurationImpl.java

@@ -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();
+    }
+}

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

@@ -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();
+}

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

@@ -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 {
+}

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

@@ -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 {
+}