initial code contribution for a SWCRacingProcedure

java/com.sap.sailing.domain.common/src/com/sap/sailing/domain/common/racelog/RacingProcedureType.java

@@ -11,6 +11,7 @@ import java.util.List;
 public enum RacingProcedureType {
     UNKNOWN("Unknown"),
     RRS26("Fix Line Start (RRS26)"),
+    SWC("Sailing World Cup Start"),
     GateStart("Gate Start"),
     ESS("\"Extreme Sailing Series\"-Start"),
     BASIC("Basic Countdown Start"),

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

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

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

@@ -8,7 +8,11 @@ public enum RaceStateEvents {
     RRS26_CLASS_UP,
     RRS26_STARTMODE_UP,
     RRS26_STARTMODE_DOWN,
-    
+
+    SWC_CLASS_UP,
+    SWC_STARTMODE_UP,
+    SWC_STARTMODE_DOWN,
+
     ESS_AP_DOWN,
     ESS_THREE_UP,
     ESS_TWO_UP,

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

@@ -2,7 +2,8 @@ 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.rrs26.impl.RRS26StartmodePrerequisite;
+import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.swc.impl.SWCStartmodePrerequisite;
 
 /**
  * Something that has to be fulfilled before the race can start (e.g. decide which start mode flag is shown).
@@ -24,7 +25,9 @@ public interface RacingProcedurePrerequisite {
 
         void fulfill(GateLaunchTimePrerequisite prerequisite);
 
-        void fulfill(StartmodePrerequisite prerequisite);
+        void fulfill(RRS26StartmodePrerequisite prerequisite);
+
+        void fulfill(SWCStartmodePrerequisite prerequisite);
     }
 
     /**

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

@@ -4,7 +4,8 @@ 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.rrs26.impl.RRS26StartmodePrerequisite;
+import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.swc.impl.SWCStartmodePrerequisite;
 
 /**
  * Always calls {@link RacingProcedurePrerequisite#fulfillWithDefault()}.
@@ -22,7 +23,12 @@ public class RacingProcedurePrerequisiteAutoResolver implements Resolver {
     }
 
     @Override
-    public void fulfill(StartmodePrerequisite prerequisite) {
+    public void fulfill(RRS26StartmodePrerequisite prerequisite) {
+        prerequisite.fulfillWithDefault();
+    }
+
+    @Override
+    public void fulfill(SWCStartmodePrerequisite prerequisite) {
         prerequisite.fulfillWithDefault();
     }
 

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

@@ -13,6 +13,7 @@ import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.ess.impl.ES
 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.swc.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.getSWCConfiguration(), 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/rrs26/impl/RRS26RacingProcedureImpl.java

@@ -87,7 +87,7 @@ public class RRS26RacingProcedureImpl extends BaseRacingProcedure implements RRS
     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 RRS26StartmodePrerequisite(function, this, now, startTime);
         }
         return new NoMorePrerequisite(function);
     }

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

@@ -5,9 +5,9 @@ import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.rrs26.RRS26
 import com.sap.sailing.domain.common.racelog.Flags;
 import com.sap.sse.common.TimePoint;
 
-public class StartmodePrerequisite extends BaseRRS26Prerequisite implements RacingProcedurePrerequisite {
+public class RRS26StartmodePrerequisite extends BaseRRS26Prerequisite implements RacingProcedurePrerequisite {
 
-    public StartmodePrerequisite(FulfillmentFunction function, RRS26RacingProcedure procedure, TimePoint originalNow,
+    public RRS26StartmodePrerequisite(FulfillmentFunction function, RRS26RacingProcedure procedure, TimePoint originalNow,
             TimePoint originalStartTime) {
         super(function, procedure, originalNow, originalStartTime);
     }

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

@@ -0,0 +1,17 @@
+package com.sap.sailing.domain.abstractlog.race.state.racingprocedure.swc;
+
+import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.ReadonlyRacingProcedure;
+import com.sap.sailing.domain.base.configuration.procedures.SWCConfiguration;
+import com.sap.sailing.domain.common.racelog.Flags;
+
+public interface ReadonlySWCRacingProcedure extends ReadonlyRacingProcedure {
+    
+    public final static Flags DefaultStartMode = Flags.UNIFORM;
+    
+    void addChangedListener(SWCChangedListener listener);
+    
+    SWCConfiguration getConfiguration();
+    
+    Flags getStartModeFlag();
+
+}

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

@@ -0,0 +1,9 @@
+package com.sap.sailing.domain.abstractlog.race.state.racingprocedure.swc;
+
+import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.RacingProcedureChangedListener;
+
+public interface SWCChangedListener extends RacingProcedureChangedListener {
+    
+    void onStartmodeChanged(ReadonlySWCRacingProcedure racingProcedure);
+
+}

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

@@ -0,0 +1,10 @@
+package com.sap.sailing.domain.abstractlog.race.state.racingprocedure.swc;
+
+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 SWCRacingProcedure extends ReadonlySWCRacingProcedure, RacingProcedure  {
+
+    void setStartModeFlag(TimePoint timePoint, Flags startMode);
+}

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

@@ -0,0 +1,22 @@
+package com.sap.sailing.domain.abstractlog.race.state.racingprocedure.swc.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.swc.SWCRacingProcedure;
+import com.sap.sse.common.TimePoint;
+
+/**
+ * Easy access to the {@link SWCRacingProcedure}.
+ */
+public abstract class BaseSWCPrerequisite extends BaseRacingProcedurePrerequisite implements RacingProcedurePrerequisite {
+
+    public BaseSWCPrerequisite(FulfillmentFunction function, SWCRacingProcedure procedure, TimePoint originalNow,
+            TimePoint originalStartTime) {
+        super(function, procedure, originalNow, originalStartTime);
+    }
+
+    protected SWCRacingProcedure getProcedure() {
+        return (SWCRacingProcedure) procedure;
+    }
+
+}

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

@@ -0,0 +1,17 @@
+package com.sap.sailing.domain.abstractlog.race.state.racingprocedure.swc.impl;
+
+import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.impl.RacingProcedureChangedListeners;
+import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.swc.ReadonlySWCRacingProcedure;
+import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.swc.SWCChangedListener;
+
+public class SWCChangedListeners extends RacingProcedureChangedListeners<SWCChangedListener> implements
+        SWCChangedListener {
+
+    @Override
+    public void onStartmodeChanged(ReadonlySWCRacingProcedure racingProcedure) {
+        for (SWCChangedListener listener : getListeners()) {
+            listener.onStartmodeChanged(racingProcedure);
+        }
+    }
+
+}

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

@@ -0,0 +1,223 @@
+package com.sap.sailing.domain.abstractlog.race.state.racingprocedure.swc.impl;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+
+import com.sap.sailing.domain.abstractlog.AbstractLogEventAuthor;
+import com.sap.sailing.domain.abstractlog.race.RaceLog;
+import com.sap.sailing.domain.abstractlog.race.analyzing.impl.RaceLogResolver;
+import com.sap.sailing.domain.abstractlog.race.analyzing.impl.RacingProcedureTypeAnalyzer;
+import com.sap.sailing.domain.abstractlog.race.analyzing.impl.SWCStartModeFlagFinder;
+import com.sap.sailing.domain.abstractlog.race.impl.RaceLogFlagEventImpl;
+import com.sap.sailing.domain.abstractlog.race.state.RaceStateEvent;
+import com.sap.sailing.domain.abstractlog.race.state.impl.RaceStateEventImpl;
+import com.sap.sailing.domain.abstractlog.race.state.impl.RaceStateEvents;
+import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.FlagPoleState;
+import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.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.RRS26RacingProcedure;
+import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.swc.SWCChangedListener;
+import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.swc.SWCRacingProcedure;
+import com.sap.sailing.domain.base.configuration.procedures.SWCConfiguration;
+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.TimePoint;
+
+public class SWCRacingProcedureImpl extends BaseRacingProcedure implements SWCRacingProcedure {
+
+    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 SWCStartModeFlagFinder startModeFlagAnalyzer;
+    
+    private Flags cachedStartmodeFlag;
+    private boolean startmodeFlagHasBeenSet;
+
+    public SWCRacingProcedureImpl(RaceLog raceLog, AbstractLogEventAuthor author, 
+             SWCConfiguration configuration, RaceLogResolver raceLogResolver) {
+        super(raceLog, author, configuration, raceLogResolver);
+        
+        RacingProcedureTypeAnalyzer procedureAnalyzer = new RacingProcedureTypeAnalyzer(raceLog);
+        if (configuration.getStartModeFlags() != null) {
+            this.startModeFlagAnalyzer = new SWCStartModeFlagFinder(procedureAnalyzer, raceLog, configuration.getStartModeFlags());
+        } else {
+            this.startModeFlagAnalyzer = new SWCStartModeFlagFinder(procedureAnalyzer, raceLog);
+        }
+        
+        this.cachedStartmodeFlag = RRS26RacingProcedure.DefaultStartMode;
+        this.startmodeFlagHasBeenSet = false;
+        
+        update();
+    }
+
+    @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
+    public RacingProcedurePrerequisite checkPrerequisitesForStart(TimePoint now, TimePoint startTime,
+            FulfillmentFunction function) {
+        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(
+                new RaceStateEventImpl(startTime.minus(startPhaseClassUpInterval), RaceStateEvents.SWC_CLASS_UP),
+                new RaceStateEventImpl(startTime.minus(startPhaseStartModeUpInterval), RaceStateEvents.SWC_STARTMODE_UP),
+                new RaceStateEventImpl(startTime.minus(startPhaseStartModeDownInterval), RaceStateEvents.SWC_STARTMODE_DOWN), 
+                new RaceStateEventImpl(startTime, RaceStateEvents.START));
+    }
+
+    @Override
+    public boolean processStateEvent(RaceStateEvent event) {
+        switch (event.getEventName()) {
+        case SWC_STARTMODE_UP:
+            if (!startmodeFlagHasBeenSet) {
+                setStartModeFlag(event.getTimePoint(), cachedStartmodeFlag);
+            }
+        case SWC_CLASS_UP:
+        case SWC_STARTMODE_DOWN:
+            getChangedListeners().onActiveFlagsChanged(this);
+            return true;
+        default:
+            return super.processStateEvent(event);
+        }
+    }
+
+    @Override
+    public FlagPoleState getActiveFlags(TimePoint startTime, TimePoint now) {
+        Flags classFlag = getConfiguration().getClassFlag() != null ?
+            getConfiguration().getClassFlag() : Flags.CLASS;
+        if (now.before(startTime.minus(startPhaseClassUpInterval))) {
+            return new FlagPoleState(
+                    Arrays.asList(new FlagPole(classFlag, false), new FlagPole(cachedStartmodeFlag, false)),
+                    null,
+                    Arrays.asList(new FlagPole(classFlag, true), new FlagPole(cachedStartmodeFlag, false)), 
+                    startTime.minus(startPhaseClassUpInterval));
+        } else if (now.before(startTime.minus(startPhaseStartModeUpInterval))) {
+            return new FlagPoleState(
+                    Arrays.asList(new FlagPole(classFlag, true), new FlagPole(cachedStartmodeFlag, false)),
+                    startTime.minus(startPhaseClassUpInterval),
+                    Arrays.asList(new FlagPole(classFlag, true), new FlagPole(cachedStartmodeFlag, true)), 
+                    startTime.minus(startPhaseStartModeUpInterval));
+        } else if (now.before(startTime.minus(startPhaseStartModeDownInterval))) {
+            return new FlagPoleState(
+                    Arrays.asList(new FlagPole(classFlag, true), new FlagPole(cachedStartmodeFlag, true)),
+                    startTime.minus(startPhaseStartModeUpInterval),
+                    Arrays.asList(new FlagPole(classFlag, true), new FlagPole(cachedStartmodeFlag, false)), 
+                    startTime.minus(startPhaseStartModeDownInterval));
+        } else if (now.before(startTime)) {
+            return new FlagPoleState(
+                    Arrays.asList(new FlagPole(classFlag, true), new FlagPole(cachedStartmodeFlag, false)),
+                    startTime.minus(startPhaseStartModeDownInterval),
+                    Arrays.asList(new FlagPole(classFlag, false), new FlagPole(cachedStartmodeFlag, false)), 
+                    startTime);
+        } 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 : recallRemoved);
+            }
+        }
+    }
+    
+    @Override
+    protected RacingProcedureChangedListeners<? extends RacingProcedureChangedListener> createChangedListenerContainer() {
+        return new SWCChangedListeners();
+    }
+    
+    @Override
+    protected SWCChangedListeners getChangedListeners() {
+        return (SWCChangedListeners) super.getChangedListeners();
+    }
+
+    @Override
+    public void addChangedListener(SWCChangedListener listener) {
+        getChangedListeners().add(listener);
+    }
+
+    @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 SWCConfiguration getConfiguration() {
+        return (SWCConfiguration) super.getConfiguration();
+    }
+
+}

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

@@ -0,0 +1,30 @@
+package com.sap.sailing.domain.abstractlog.race.state.racingprocedure.swc.impl;
+
+import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.RacingProcedurePrerequisite;
+import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.swc.SWCRacingProcedure;
+import com.sap.sailing.domain.common.racelog.Flags;
+import com.sap.sse.common.TimePoint;
+
+public class SWCStartmodePrerequisite extends BaseSWCPrerequisite implements RacingProcedurePrerequisite {
+
+    public SWCStartmodePrerequisite(FulfillmentFunction function, SWCRacingProcedure procedure, TimePoint originalNow,
+            TimePoint originalStartTime) {
+        super(function, procedure, originalNow, originalStartTime);
+    }
+
+    @Override
+    protected void resolveOn(Resolver resolver) {
+        resolver.fulfill(this);
+    }
+    
+    public void fulfill(Flags startmodeFlag) {
+        getProcedure().setStartModeFlag(originalNow, startmodeFlag);
+        super.fulfilled();
+    }
+    
+    @Override
+    public void fulfillWithDefault() {
+        fulfill(SWCRacingProcedure.DefaultStartMode);
+    }
+
+}

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.SWCConfiguration;
 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.
+     */
+    SWCConfiguration getSWCConfiguration();
+
     /**
      * 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/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.SWCConfiguration;
 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 SWCConfiguration swcConfiguration;
     private GateStartConfiguration gateStartConfiguration;
     private ESSConfiguration essConfiguration;
     private LeagueConfiguration leagueConfiguration;
@@ -49,6 +51,15 @@ public class RegattaConfigurationImpl implements RegattaConfiguration {
         this.rrs26Configuration = rrs26Configuration;
     }
 
+    @Override
+    public SWCConfiguration getSWCConfiguration() {
+        return swcConfiguration;
+    }
+
+    public void setSWCConfiguration(SWCConfiguration swcConfiguration) {
+        this.swcConfiguration = swcConfiguration;
+    }
+
     @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.setSWCConfiguration(swcConfiguration);
         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.getSWCConfiguration() != null) {
+            target.setSWCConfiguration(
+                    (SWCConfiguration) target.getSWCConfiguration().merge(update.getSWCConfiguration()));
+        }
         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/SWCConfigurationImpl.java

@@ -0,0 +1,41 @@
+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.SWCConfiguration;
+import com.sap.sailing.domain.common.racelog.Flags;
+
+public class SWCConfigurationImpl extends RacingProcedureConfigurationImpl implements
+    SWCConfiguration {
+
+    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) {
+        SWCConfiguration update = (SWCConfiguration) value;
+        SWCConfigurationImpl target = (SWCConfigurationImpl) super.merge(update);
+        if (update.getStartModeFlags() != null) {
+            target.setStartModeFlags(update.getStartModeFlags());
+        }
+        return target;
+    }
+
+    protected SWCConfiguration copy() {
+        SWCConfigurationImpl copy = (SWCConfigurationImpl) super.copy(new SWCConfigurationImpl());
+        copy.setStartModeFlags(startModeFlags);
+        return copy;
+    }
+
+}

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

@@ -0,0 +1,17 @@
+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;
+
+/**
+ * Start procedure for the Sailing World Cup
+ * @author Frank
+ *
+ */
+public interface SWCConfiguration extends RacingProcedureConfiguration {
+    
+    List<Flags> getStartModeFlags();
+
+}

mobile/com.sap.sailing.racecommittee.app/src/com/sap/sailing/racecommittee/app/AppPreferences.java

@@ -223,6 +223,8 @@ public class AppPreferences {
         switch (type) {
             case RRS26:
                 return key(R.string.preference_racing_procedure_rrs26_classflag_key);
+            case SWC:
+                return key(R.string.preference_racing_procedure_swc_classflag_key);
             case GateStart:
                 return key(R.string.preference_racing_procedure_gatestart_classflag_key);
             case ESS:
@@ -245,6 +247,8 @@ public class AppPreferences {
         switch (type) {
             case RRS26:
                 return key(R.string.preference_racing_procedure_rrs26_hasxray_key);
+            case SWC:
+                return key(R.string.preference_racing_procedure_swc_hasxray_key);
             case GateStart:
                 return key(R.string.preference_racing_procedure_gatestart_hasxray_key);
             case ESS:
@@ -267,6 +271,8 @@ public class AppPreferences {
         switch (type) {
         case RRS26:
             return key(R.string.preference_racing_procedure_rrs26_resultentryenabled_key);
+        case SWC:
+            return key(R.string.preference_racing_procedure_swc_resultentryenabled_key);
         case GateStart:
             return key(R.string.preference_racing_procedure_gatestart_resultentryenabled_key);
         case ESS:
@@ -289,6 +295,15 @@ public class AppPreferences {
         return flags;
     }
 
+    public Set<Flags> getSWCStartmodeFlags() {
+        Set<String> flagNames = helper.getStringSet(key(R.string.preference_racing_procedure_swc_startmode_flags_key), new HashSet<String>());
+        Set<Flags> flags = new HashSet<>();
+        for (String flagName : flagNames) {
+            flags.add(Flags.valueOf(flagName));
+        }
+        return flags;
+    }
+
     public String getServerBaseURL() {
         return helper.getString(key(R.string.preference_server_url_key), null);
     }
@@ -423,6 +438,14 @@ public class AppPreferences {
         helper.getEditor().putStringSet(key(R.string.preference_racing_procedure_rrs26_startmode_flags_key), flagNames).commit();
     }
 
+    public void setSWCStartmodeFlags(Set<Flags> flags) {
+        Set<String> flagNames = new HashSet<>();
+        for (Flags flag : flags) {
+            flagNames.add(flag.name());
+        }
+        helper.getEditor().putStringSet(key(R.string.preference_racing_procedure_swc_startmode_flags_key), flagNames).commit();
+    }
+
     public void setSendingActive(boolean activate) {
         ExLog.i(context, this.getClass().toString(), "setSendingActive: " + activate);
         helper.getEditor().putBoolean(context.getResources().getString(R.string.preference_isSendingActive_key), activate).commit();

mobile/com.sap.sailing.racecommittee.app/src/com/sap/sailing/racecommittee/app/domain/configuration/impl/PreferencesRegattaConfigurationLoader.java

@@ -13,10 +13,12 @@ import com.sap.sailing.domain.base.configuration.impl.LeagueConfigurationImpl;
 import com.sap.sailing.domain.base.configuration.impl.RRS26ConfigurationImpl;
 import com.sap.sailing.domain.base.configuration.impl.RacingProcedureConfigurationImpl;
 import com.sap.sailing.domain.base.configuration.impl.RegattaConfigurationImpl;
+import com.sap.sailing.domain.base.configuration.impl.SWCConfigurationImpl;
 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.SWCConfiguration;
 import com.sap.sailing.domain.common.racelog.Flags;
 import com.sap.sailing.domain.common.racelog.RacingProcedureType;
 import com.sap.sailing.racecommittee.app.AppPreferences;
@@ -55,6 +57,13 @@ public class PreferencesRegattaConfigurationLoader implements ConfigurationLoade
         rrs26.setStartModeFlags(new ArrayList<Flags>(preferences.getRRS26StartmodeFlags()));
         configuration.setRRS26Configuration(rrs26);
 
+        SWCConfigurationImpl swcStart = new SWCConfigurationImpl();
+        swcStart.setClassFlag(preferences.getRacingProcedureClassFlag(RacingProcedureType.SWC));
+        swcStart.setHasIndividualRecall(preferences.getRacingProcedureHasIndividualRecall(RacingProcedureType.SWC));
+        swcStart.setResultEntryEnabled(preferences.getRacingProcedureIsResultEntryEnabled(RacingProcedureType.SWC));
+        swcStart.setStartModeFlags(new ArrayList<Flags>(preferences.getSWCStartmodeFlags()));
+        configuration.setSWCConfiguration(swcStart);
+
         GateStartConfigurationImpl gateStart = new GateStartConfigurationImpl();
         gateStart.setClassFlag(preferences.getRacingProcedureClassFlag(RacingProcedureType.GateStart));
         gateStart.setHasIndividualRecall(preferences.getRacingProcedureHasIndividualRecall(RacingProcedureType.GateStart));
@@ -103,6 +112,14 @@ public class PreferencesRegattaConfigurationLoader implements ConfigurationLoade
                 preferences.setRRS26StartmodeFlags(new HashSet<Flags>(config.getStartModeFlags()));
             }
         }
+        if (configuration.getSWCConfiguration() != null) {
+            SWCConfiguration config = configuration.getSWCConfiguration();
+            storeRacingProcedureConfiguration(RacingProcedureType.SWC, config);
+            if (config.getStartModeFlags() != null) {
+                preferences.setSWCStartmodeFlags(new HashSet<Flags>(config.getStartModeFlags()));
+            }
+        }
+
         if (configuration.getGateStartConfiguration() != null) {
             GateStartConfiguration config = configuration.getGateStartConfiguration();
             storeRacingProcedureConfiguration(RacingProcedureType.GateStart, config);