001package jmri;
002
003import java.beans.PropertyChangeEvent;
004import java.beans.PropertyChangeListener;
005import java.util.List;
006import java.util.ArrayList;
007import java.util.Arrays;
008import java.util.Collections;
009import java.util.Set;
010import java.util.HashSet;
011import java.util.ResourceBundle;
012import javax.annotation.Nonnull;
013
014/**
015 * A Conditional is layout control logic, consisting of a logical expression and
016 * an action.
017 * <p>
018 * A Conditional does not exist on its own, but is part of a Logix. The system
019 * name of each Conditional is set automatically when the conditional is
020 * created. It begins with the system name of its parent Logix. There is no
021 * Conditional Table. Conditionals are created, editted, and deleted via the
022 * Logix Table.
023 * <p>
024 * A Conditional has a "state", which changes depending on whether its logical
025 * expression calculates to TRUE or FALSE. The "state" may not be changed by the
026 * user. It only changes in response to changes in the "state variables" used in
027 * its logical expression.
028 * <p>
029 * Listeners may be set to monitor a change in the state of a conditional.
030 *
031 * <hr>
032 * This file is part of JMRI.
033 * <p>
034 * JMRI is free software; you can redistribute it and/or modify it under the
035 * terms of version 2 of the GNU General Public License as published by the Free
036 * Software Foundation. See the "COPYING" file for a copy of this license.
037 * <p>
038 * JMRI is distributed in the hope that it will be useful, but WITHOUT ANY
039 * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
040 * A PARTICULAR PURPOSE. See the GNU General Public License for more details.
041 *
042 * @author Dave Duchamp Copyright (C) 2007, 2008
043 * @author Pete Cressman Copyright (C) 2009, 2010, 2011
044 * @author Matthew Harris copyright (c) 2009
045 */
046public interface Conditional extends NamedBean {
047
048    static final ResourceBundle rbx = ResourceBundle.getBundle("jmri.jmrit.conditional.ConditionalBundle");
049    static final ResourceBundle rbxWarrant = ResourceBundle.getBundle("jmri.jmrit.logix.WarrantBundle");
050
051    // states
052    enum State {
053        UNKNOWN(NamedBean.UNKNOWN, "StateUnknown"),
054        FALSE(Conditional.FALSE, "StateFalse"),
055        TRUE(Conditional.TRUE, "StateTrue");
056
057        private final int _state;
058        private final String _bundleKey;
059
060        private State(int state, String bundleKey) {
061            _state = state;
062            _bundleKey = bundleKey;
063        }
064
065        public int getIntValue() {
066            return _state;
067        }
068
069        public static State getOperatorFromIntValue(int stateInt) {
070            for (State state : State.values()) {
071                if (state.getIntValue() == stateInt) {
072                    return state;
073                }
074            }
075
076            throw new IllegalArgumentException("State is unknown");
077        }
078
079        @Override
080        public String toString() {
081            return Bundle.getMessage(_bundleKey);
082        }
083    }
084
085    public static final int FALSE = 0x02;
086    public static final int TRUE = 0x04;
087
088    public enum AntecedentOperator {
089        ALL_AND(Conditional.ALL_AND, Bundle.getMessage("LogicAND")),
090        ALL_OR(Conditional.ALL_OR, Bundle.getMessage("LogicOR")),
091        MIXED(Conditional.MIXED, Bundle.getMessage("LogicMixed"));
092
093        private final int _value;
094        private final String _string;
095
096        private AntecedentOperator(int value, String string) {
097            _value = value;
098            _string = string;
099        }
100
101        public int getIntValue() {
102            return _value;
103        }
104
105        public static AntecedentOperator getOperatorFromIntValue(int value) {
106            for (AntecedentOperator antecedentOperators : AntecedentOperator.values()) {
107                if (antecedentOperators.getIntValue() == value) {
108                    return antecedentOperators;
109                }
110            }
111
112            throw new IllegalArgumentException("ItemType is unknown");
113        }
114
115        @Override
116        public String toString() {
117            return _string;
118        }
119    }
120
121    // logic operators used in antecedent
122    static final int ALL_AND = 0x01;
123    static final int ALL_OR = 0x02;
124    static final int MIXED = 0x03;
125
126    public enum Operator {
127        NONE,
128        AND,
129        OR;
130
131        // This method is used by DefaultConditionalManagerXml.store() for backward compatibility
132        public int getIntValue() {
133            switch (this) {
134                case NONE: return OPERATOR_NONE;
135                case AND: return OPERATOR_AND;
136                case OR: return OPERATOR_OR;
137                default: throw new IllegalArgumentException(String.format("operator %s is unknown", this.name()));
138            }
139        }
140
141        // This method is used by DefaultConditionalManagerXml.loadConditionals() for backward compatibility
142        public static Operator getOperatorFromIntValue(int opern) {
143            switch (opern) {
144                case OPERATOR_AND: return Operator.AND;
145                case OPERATOR_NONE: return Operator.NONE;
146                case OPERATOR_OR: return Operator.OR;
147                default: throw new IllegalArgumentException(String.format("operator %d is unknown", opern));
148            }
149        }
150    }
151
152    // state variable definitions. Keep these since they are needed
153    // for backward compatibility in DefaultConditionalManagerXml.
154    // But they are not used elsewhere.
155    static final int OPERATOR_AND = 1;
156    static final int OPERATOR_NONE = 4;
157    static final int OPERATOR_OR = 5;
158
159    // state variable and action items used by logix.
160    enum ItemType {
161        NONE(TYPE_NONE, IsStateVar.IS_STATE_VAR, "ItemTypeNone"),        // There is no ITEM_TYPE_NONE so use TYPE_NONE instead
162        SENSOR(ITEM_TYPE_SENSOR, IsStateVar.IS_STATE_VAR, "ItemTypeSensor"),
163        TURNOUT(ITEM_TYPE_TURNOUT, IsStateVar.IS_STATE_VAR, "ItemTypeTurnout"),
164        LIGHT(ITEM_TYPE_LIGHT, IsStateVar.IS_STATE_VAR, "ItemTypeLight"),
165        SIGNALHEAD(ITEM_TYPE_SIGNALHEAD, IsStateVar.IS_STATE_VAR, "ItemTypeSignalHead"),
166        SIGNALMAST(ITEM_TYPE_SIGNALMAST, IsStateVar.IS_STATE_VAR, "ItemTypeSignalMast"),
167        MEMORY(ITEM_TYPE_MEMORY, IsStateVar.IS_STATE_VAR, "ItemTypeMemory"),
168        CONDITIONAL(ITEM_TYPE_CONDITIONAL, IsStateVar.IS_STATE_VAR, "ItemTypeConditional"),  // used only by ConditionalVariable
169        LOGIX(ITEM_TYPE_LOGIX, IsStateVar.IS_STATE_VAR, "ItemTypeLogix"),                    // used only by ConditionalAction
170        WARRANT(ITEM_TYPE_WARRANT, IsStateVar.IS_STATE_VAR, "ItemTypeWarrant"),
171        CLOCK(ITEM_TYPE_CLOCK, IsStateVar.IS_STATE_VAR, "ItemTypeClock"),
172        OBLOCK(ITEM_TYPE_OBLOCK, IsStateVar.IS_STATE_VAR, "ItemTypeOBlock"),
173        ENTRYEXIT(ITEM_TYPE_ENTRYEXIT, IsStateVar.IS_STATE_VAR, "ItemTypeEntryExit"),
174
175        AUDIO(ITEM_TYPE_AUDIO, IsStateVar.IS_NOT_STATE_VAR, "ItemTypeAudio"),
176        SCRIPT(ITEM_TYPE_SCRIPT, IsStateVar.IS_NOT_STATE_VAR, "ItemTypeScript"),
177        OTHER(ITEM_TYPE_OTHER, IsStateVar.IS_NOT_STATE_VAR, "ItemTypeOther");
178
179        private final int _type;
180        private IsStateVar _isStateVar;
181        private final String _bundleKey;
182
183        private static final List<ItemType> stateVarList;
184
185        static
186        {
187            stateVarList = new ArrayList<>();
188
189            for (ItemType itemType : ItemType.values()) {
190                if (itemType._isStateVar == IsStateVar.IS_STATE_VAR) {
191                    stateVarList.add(itemType);
192                }
193            }
194        }
195
196        private ItemType(int type, IsStateVar isStateVar, String bundleKey) {
197            _type = type;
198            _isStateVar = isStateVar;
199            _bundleKey = bundleKey;
200        }
201
202        public static List<ItemType> getStateVarList() {
203            return stateVarList;
204        }
205
206        public int getIntValue() {
207            return _type;
208        }
209
210        public static ItemType getOperatorFromIntValue(int itemTypeInt) {
211            for (ItemType itemType : ItemType.values()) {
212                if (itemType.getIntValue() == itemTypeInt) {
213                    return itemType;
214                }
215            }
216
217            throw new IllegalArgumentException("ItemType is unknown");
218        }
219
220        @Override
221        public String toString() {
222            return Bundle.getMessage(_bundleKey);
223        }
224
225        // This enum is only used within the outer enum ItemType.
226        private enum IsStateVar {
227            IS_STATE_VAR,
228            IS_NOT_STATE_VAR
229        }
230    }
231
232    // items
233    enum Type {
234        ERROR(TYPE_ERROR, ItemType.NONE, "", ""), // NOI18N
235        NONE(TYPE_NONE, ItemType.NONE, "", ""), // NOI18N
236        SENSOR_ACTIVE(TYPE_SENSOR_ACTIVE, ItemType.SENSOR, Bundle.getMessage("SensorStateActive"), rbx.getString("TypeSensorActive")), // NOI18N
237        SENSOR_INACTIVE(TYPE_SENSOR_INACTIVE, ItemType.SENSOR, Bundle.getMessage("SensorStateInactive"), rbx.getString("TypeSensorInactive")), // NOI18N
238        TURNOUT_THROWN(TYPE_TURNOUT_THROWN, ItemType.TURNOUT, Bundle.getMessage("TurnoutStateThrown"), rbx.getString("TypeTurnoutThrown")), // NOI18N
239        TURNOUT_CLOSED(TYPE_TURNOUT_CLOSED, ItemType.TURNOUT, Bundle.getMessage("TurnoutStateClosed"), rbx.getString("TypeTurnoutClosed")), // NOI18N
240        CONDITIONAL_TRUE(TYPE_CONDITIONAL_TRUE, ItemType.CONDITIONAL, Bundle.getMessage("True"), rbx.getString("TypeConditionalTrue")), // NOI18N
241        CONDITIONAL_FALSE(TYPE_CONDITIONAL_FALSE, ItemType.CONDITIONAL, Bundle.getMessage("False"), rbx.getString("TypeConditionalFalse")), // NOI18N
242        LIGHT_ON(TYPE_LIGHT_ON, ItemType.LIGHT, rbx.getString("LightOn"), rbx.getString("TypeLightOn")), // NOI18N
243        LIGHT_OFF(TYPE_LIGHT_OFF, ItemType.LIGHT, rbx.getString("LightOff"), rbx.getString("TypeLightOff")), // NOI18N
244        MEMORY_EQUALS(TYPE_MEMORY_EQUALS, ItemType.MEMORY, rbx.getString("StateMemoryEquals"), rbx.getString("TypeMemoryEquals")), // NOI18N
245        MEMORY_COMPARE(TYPE_MEMORY_COMPARE, ItemType.MEMORY, rbx.getString("StateMemoryCompare"), rbx.getString("TypeMemoryCompare")), // NOI18N
246        MEMORY_EQUALS_INSENSITIVE(TYPE_MEMORY_EQUALS_INSENSITIVE, ItemType.MEMORY, rbx.getString("StateMemoryEqualsInsensitive"), rbx.getString("TypeMemoryEqualsInsensitive")), // NOI18N
247        MEMORY_COMPARE_INSENSITIVE(TYPE_MEMORY_COMPARE_INSENSITIVE, ItemType.MEMORY, rbx.getString("StateMemoryCompareInsensitive"), rbx.getString("TypeMemoryCompareInsensitive")), // NOI18N
248        FAST_CLOCK_RANGE(TYPE_FAST_CLOCK_RANGE, ItemType.CLOCK, rbx.getString("TypeFastClockRange"), rbx.getString("TypeFastClockRange")), // NOI18N
249
250        // Note the set signalHeadAppearanceSet below which holds those SignalHead types that are appearances.
251        SIGNAL_HEAD_RED(TYPE_SIGNAL_HEAD_RED, ItemType.SIGNALHEAD, Bundle.getMessage("SignalHeadStateRed"), Bundle.getMessage("SignalHeadStateRed")), // NOI18N
252        SIGNAL_HEAD_YELLOW(TYPE_SIGNAL_HEAD_YELLOW, ItemType.SIGNALHEAD, Bundle.getMessage("SignalHeadStateYellow"), Bundle.getMessage("SignalHeadStateYellow")), // NOI18N
253        SIGNAL_HEAD_GREEN(TYPE_SIGNAL_HEAD_GREEN, ItemType.SIGNALHEAD, Bundle.getMessage("SignalHeadStateGreen"), Bundle.getMessage("SignalHeadStateGreen")), // NOI18N
254        SIGNAL_HEAD_DARK(TYPE_SIGNAL_HEAD_DARK, ItemType.SIGNALHEAD, Bundle.getMessage("SignalHeadStateDark"), Bundle.getMessage("SignalHeadStateDark")), // NOI18N
255        SIGNAL_HEAD_FLASHRED(TYPE_SIGNAL_HEAD_FLASHRED, ItemType.SIGNALHEAD, Bundle.getMessage("SignalHeadStateFlashingRed"), Bundle.getMessage("SignalHeadStateFlashingRed")), // NOI18N
256        SIGNAL_HEAD_FLASHYELLOW(TYPE_SIGNAL_HEAD_FLASHYELLOW, ItemType.SIGNALHEAD, Bundle.getMessage("SignalHeadStateFlashingYellow"), Bundle.getMessage("SignalHeadStateFlashingYellow")), // NOI18N
257        SIGNAL_HEAD_FLASHGREEN(TYPE_SIGNAL_HEAD_FLASHGREEN, ItemType.SIGNALHEAD, Bundle.getMessage("SignalHeadStateFlashingGreen"), Bundle.getMessage("SignalHeadStateFlashingGreen")), // NOI18N
258        SIGNAL_HEAD_LIT(TYPE_SIGNAL_HEAD_LIT, ItemType.SIGNALHEAD, Bundle.getMessage("SignalHeadStateLit"), Bundle.getMessage("SignalHeadStateLit")), // NOI18N
259        SIGNAL_HEAD_HELD(TYPE_SIGNAL_HEAD_HELD, ItemType.SIGNALHEAD, Bundle.getMessage("SignalHeadStateHeld"), Bundle.getMessage("SignalHeadStateHeld")), // NOI18N
260        SIGNAL_HEAD_LUNAR(TYPE_SIGNAL_HEAD_LUNAR, ItemType.SIGNALHEAD, Bundle.getMessage("SignalHeadStateLunar"), Bundle.getMessage("SignalHeadStateLunar")), // NOI18N
261        SIGNAL_HEAD_FLASHLUNAR(TYPE_SIGNAL_HEAD_FLASHLUNAR, ItemType.SIGNALHEAD, Bundle.getMessage("SignalHeadStateFlashingLunar"), Bundle.getMessage("SignalHeadStateFlashingLunar")), // NOI18N
262        // Warrant variables
263        ROUTE_FREE(TYPE_ROUTE_FREE, ItemType.WARRANT, rbx.getString("StateRouteFree"), rbx.getString("TypeWarrantRouteFree")), // NOI18N
264        ROUTE_OCCUPIED(TYPE_ROUTE_OCCUPIED, ItemType.WARRANT, rbx.getString("stateRouteOccupied"), rbx.getString("TypeWarrantRouteOccupied")), // NOI18N
265        ROUTE_ALLOCATED(TYPE_ROUTE_ALLOCATED, ItemType.WARRANT, rbx.getString("StateRouteReserved"), rbx.getString("TypeWarrantRouteAllocated")), // NOI18N
266        ROUTE_SET(TYPE_ROUTE_SET, ItemType.WARRANT, rbx.getString("StateRouteIsSet"), rbx.getString("TypeRouteIsSet")), // NOI18N
267        TRAIN_RUNNING(TYPE_TRAIN_RUNNING, ItemType.WARRANT, rbx.getString("StateTrainRunning"), rbx.getString("TypeTrainRunning")), // NOI18N
268        SIGNAL_MAST_ASPECT_EQUALS(TYPE_SIGNAL_MAST_ASPECT_EQUALS, ItemType.SIGNALMAST, rbx.getString("TypeSignalMastAspectEquals"), rbx.getString("TypeSignalMastAspectEquals")), // NOI18N
269        SIGNAL_MAST_LIT(TYPE_SIGNAL_MAST_LIT, ItemType.SIGNALMAST, Bundle.getMessage("SignalMastStateLit"), Bundle.getMessage("SignalMastStateLit")), // NOI18N
270        SIGNAL_MAST_HELD(TYPE_SIGNAL_MAST_HELD, ItemType.SIGNALMAST, Bundle.getMessage("SignalMastStateHeld"), Bundle.getMessage("SignalMastStateHeld")), // NOI18N
271        SIGNAL_HEAD_APPEARANCE_EQUALS(TYPE_SIGNAL_HEAD_APPEARANCE_EQUALS, ItemType.SIGNALHEAD, rbx.getString("TypeSignalHeadAspectEquals"), rbx.getString("TypeSignalHeadAspectEquals")), // NOI18N
272        BLOCK_STATUS_EQUALS(TYPE_BLOCK_STATUS_EQUALS, ItemType.OBLOCK, "", ""), // NOI18N
273        //Entry Exit Rules
274        ENTRYEXIT_ACTIVE(TYPE_ENTRYEXIT_ACTIVE, ItemType.ENTRYEXIT, rbx.getString("TypeEntryExitActive"), rbx.getString("TypeEntryExitActive")), // NOI18N
275        ENTRYEXIT_INACTIVE(TYPE_ENTRYEXIT_INACTIVE, ItemType.ENTRYEXIT, rbx.getString("TypeEntryExitInactive"), rbx.getString("TypeEntryExitInactive")), // NOI18N
276        // OBlock
277        OBLOCK_UNOCCUPIED(TYPE_OBLOCK_UNOCCUPIED, ItemType.OBLOCK, rbxWarrant.getString("unoccupied"), rbxWarrant.getString("unoccupied")), // NOI18N
278        OBLOCK_OCCUPIED(TYPE_OBLOCK_OCCUPIED, ItemType.OBLOCK, rbxWarrant.getString("occupied"), rbxWarrant.getString("occupied")), // NOI18N
279        OBLOCK_ALLOCATED(TYPE_OBLOCK_ALLOCATED, ItemType.OBLOCK, rbxWarrant.getString("allocated"), rbxWarrant.getString("allocated")), // NOI18N
280        OBLOCK_RUNNING(TYPE_OBLOCK_RUNNING, ItemType.OBLOCK, rbxWarrant.getString("running"), rbxWarrant.getString("running")), // NOI18N
281        OBLOCK_OUT_OF_SERVICE(TYPE_OBLOCK_OUT_OF_SERVICE, ItemType.OBLOCK, rbxWarrant.getString("outOfService"), rbxWarrant.getString("outOfService")), // NOI18N
282        OBLOCK_DARK(TYPE_OBLOCK_DARK, ItemType.OBLOCK, rbxWarrant.getString("dark"), rbxWarrant.getString("dark")), // NOI18N
283        OBLOCK_POWER_ERROR(TYPE_OBLOCK_POWER_ERROR, ItemType.OBLOCK, rbxWarrant.getString("powerError"), rbxWarrant.getString("powerError")), // NOI18N
284        // This is used by ConditionalListEdit and ConditionalTreeEdit
285        XXXXXXX(TYPE_XXXXXXX, ItemType.NONE, "XXXXXXX", "XXXXXXX"); // NOI18N
286
287        private final int _item;
288        private final ItemType _itemType;
289        private final String _string;
290        private final String _testTypeString;
291
292        private static final List<Type> sensorItemsList;
293        private static final List<Type> turnoutItemsList;
294        private static final List<Type> conditionalItemsList;
295        private static final List<Type> lightItemsList;
296        private static final List<Type> warrantItemsList;
297        private static final List<Type> memoryItemsList;
298        private static final List<Type> entryExitItemsList;
299        private static final List<Type> signalHeadStateMachineItemsList;
300        private static final List<Type> signalMastItemsList;
301        private static final List<Type> oblockItemsList;
302
303        private static final Set<Type> signalHeadAppearanceSet;
304
305
306        static
307        {
308            Type[] typeArray1 = {SENSOR_ACTIVE, SENSOR_INACTIVE};
309            sensorItemsList = Collections.unmodifiableList(Arrays.asList(typeArray1));
310
311            Type[] typeArray2 = {TURNOUT_THROWN, TURNOUT_CLOSED};
312            turnoutItemsList = Collections.unmodifiableList(Arrays.asList(typeArray2));
313
314            Type[] typeArray3 = {CONDITIONAL_TRUE, CONDITIONAL_FALSE};
315            conditionalItemsList = Collections.unmodifiableList(Arrays.asList(typeArray3));
316
317            Type[] typeArray4 = {LIGHT_ON, LIGHT_OFF};
318            lightItemsList = Collections.unmodifiableList(Arrays.asList(typeArray4));
319
320            Type[] typeArray5 = {ROUTE_FREE, ROUTE_SET, ROUTE_ALLOCATED, ROUTE_OCCUPIED, TRAIN_RUNNING};
321            warrantItemsList = Collections.unmodifiableList(Arrays.asList(typeArray5));
322
323            Type[] typeArray6 = {MEMORY_EQUALS, MEMORY_EQUALS_INSENSITIVE,
324                MEMORY_COMPARE, MEMORY_COMPARE_INSENSITIVE};
325            memoryItemsList = Collections.unmodifiableList(Arrays.asList(typeArray6));
326
327            Type[] typeArray7 = {ENTRYEXIT_ACTIVE, ENTRYEXIT_INACTIVE};
328            entryExitItemsList = Collections.unmodifiableList(Arrays.asList(typeArray7));
329
330            Type[] typeArray8 = {NONE, SIGNAL_HEAD_APPEARANCE_EQUALS, SIGNAL_HEAD_LIT, SIGNAL_HEAD_HELD};
331            signalHeadStateMachineItemsList = Collections.unmodifiableList(Arrays.asList(typeArray8));
332
333            Type[] typeArray9 = {SIGNAL_HEAD_RED, SIGNAL_HEAD_YELLOW, SIGNAL_HEAD_GREEN,
334                SIGNAL_HEAD_DARK, SIGNAL_HEAD_FLASHRED, SIGNAL_HEAD_FLASHYELLOW,
335                SIGNAL_HEAD_FLASHGREEN, SIGNAL_HEAD_LUNAR, SIGNAL_HEAD_FLASHLUNAR,
336            };
337            signalHeadAppearanceSet = Collections.unmodifiableSet(new HashSet<>(Arrays.asList(typeArray9)));
338
339            Type[] typeArray10 = {NONE, SIGNAL_MAST_ASPECT_EQUALS, SIGNAL_MAST_LIT, SIGNAL_MAST_HELD};
340            signalMastItemsList = Collections.unmodifiableList(Arrays.asList(typeArray10));
341
342            Type[] typeArray11 = {OBLOCK_UNOCCUPIED, OBLOCK_OCCUPIED, OBLOCK_ALLOCATED,
343                OBLOCK_RUNNING, OBLOCK_OUT_OF_SERVICE, OBLOCK_DARK, OBLOCK_POWER_ERROR};
344            oblockItemsList = Collections.unmodifiableList(Arrays.asList(typeArray11));
345        }
346
347        private Type(int state, ItemType itemType, String string, String testTypeString) {
348            _item = state;
349            _itemType = itemType;
350            _string = string;
351            _testTypeString = testTypeString;
352        }
353
354        public ItemType getItemType() {
355            return _itemType;
356        }
357
358        public int getIntValue() {
359            return _item;
360        }
361
362        public static List<Type> getSensorItems() {
363            return sensorItemsList;
364        }
365
366        public static List<Type> getTurnoutItems() {
367            return turnoutItemsList;
368        }
369
370        public static List<Type> getConditionalItems() {
371            return conditionalItemsList;
372        }
373
374        public static List<Type> getLightItems() {
375            return lightItemsList;
376        }
377
378        public static List<Type> getWarrantItems() {
379            return warrantItemsList;
380        }
381
382        public static List<Type> getMemoryItems() {
383            return memoryItemsList;
384        }
385
386        public static List<Type> getEntryExitItems() {
387            return entryExitItemsList;
388        }
389
390        public static List<Type> getSignalHeadStateMachineItems() {
391            return signalHeadStateMachineItemsList;
392        }
393
394        public static boolean isSignalHeadApperance(Type type) {
395            return signalHeadAppearanceSet.contains(type);
396        }
397
398        public static List<Type> getSignalMastItems() {
399            return signalMastItemsList;
400        }
401
402        public static List<Type> getOBlockItems() {
403            return oblockItemsList;
404        }
405
406        public static int getIndexInList(List<Type> table, Type entry) {
407            for (int i = 0; i < table.size(); i++) {
408                if (entry == table.get(i)) {
409                    return i;
410                }
411            }
412            return -1;
413        }
414
415        public static Type getOperatorFromIntValue(int typeInt) {
416            for (Type type : Type.values()) {
417                if (type.getIntValue() == typeInt) {
418                    return type;
419                }
420            }
421
422            throw new IllegalArgumentException("Type is unknown");
423        }
424
425        // Some items uses Bundle.getString() and some items uses rbx.getString()
426        // and therefore the items must call getString() in the call to the constructor.
427        @Override
428        public String toString() {
429            return _string;
430        }
431
432        public String getTestTypeString() {
433            return _testTypeString;
434        }
435    }
436
437    // items
438    enum Action {
439        NONE(ACTION_NONE, ItemType.NONE, ""), // NOI18N
440        SET_TURNOUT(ACTION_SET_TURNOUT, ItemType.TURNOUT, rbx.getString("ActionSetTurnout")), // NOI18N
441        // allowed settings for turnout are Thrown and Closed (in data)
442        SET_SIGNAL_APPEARANCE(ACTION_SET_SIGNAL_APPEARANCE, ItemType.SIGNALHEAD, rbx.getString("ActionSetSignal")), // NOI18N
443        // allowed settings for signal head are the seven Appearances (in data)
444        SET_SIGNAL_HELD(ACTION_SET_SIGNAL_HELD, ItemType.SIGNALHEAD, rbx.getString("ActionSetSignalHeld")), // NOI18N
445        CLEAR_SIGNAL_HELD(ACTION_CLEAR_SIGNAL_HELD, ItemType.SIGNALHEAD, rbx.getString("ActionClearSignalHeld")), // NOI18N
446        SET_SIGNAL_DARK(ACTION_SET_SIGNAL_DARK, ItemType.SIGNALHEAD, rbx.getString("ActionSetSignalDark")), // NOI18N
447        SET_SIGNAL_LIT(ACTION_SET_SIGNAL_LIT, ItemType.SIGNALHEAD, rbx.getString("ActionSetSignalLit")), // NOI18N
448        TRIGGER_ROUTE(ACTION_TRIGGER_ROUTE, ItemType.OTHER, rbx.getString("ActionTriggerRoute")), // NOI18N
449        SET_SENSOR(ACTION_SET_SENSOR, ItemType.SENSOR, rbx.getString("ActionSetSensor")), // NOI18N
450        // allowed settings for sensor are active and inactive (in data)
451        DELAYED_SENSOR(ACTION_DELAYED_SENSOR, ItemType.SENSOR, rbx.getString("ActionDelayedSensor")), // NOI18N
452        // allowed settings for timed sensor are active and inactive (in data)
453        //   time in seconds before setting sensor should be in delay
454        SET_LIGHT(ACTION_SET_LIGHT, ItemType.LIGHT, rbx.getString("ActionSetLight")), // NOI18N
455        // allowed settings for light are ON and OFF (in data)
456        SET_MEMORY(ACTION_SET_MEMORY, ItemType.MEMORY, rbx.getString("ActionSetMemory")), // NOI18N
457        // text to set into the memory variable should be in string
458        ENABLE_LOGIX(ACTION_ENABLE_LOGIX, ItemType.LOGIX, rbx.getString("ActionEnableLogix")), // NOI18N
459        DISABLE_LOGIX(ACTION_DISABLE_LOGIX, ItemType.LOGIX, rbx.getString("ActionDisableLogix")), // NOI18N
460        PLAY_SOUND(ACTION_PLAY_SOUND, ItemType.AUDIO, rbx.getString("ActionPlaySound")), // NOI18N
461        // reference to sound should be in string
462        RUN_SCRIPT(ACTION_RUN_SCRIPT, ItemType.SCRIPT, rbx.getString("ActionRunScript")), // NOI18N
463        // reference to script should be in string
464        DELAYED_TURNOUT(ACTION_DELAYED_TURNOUT, ItemType.TURNOUT, rbx.getString("ActionDelayedTurnout")), // NOI18N
465        // allowed settings for timed turnout are Thrown and Closed (in data)
466        //   time in seconds before setting turnout should be in delay
467        LOCK_TURNOUT(ACTION_LOCK_TURNOUT, ItemType.TURNOUT, rbx.getString("ActionTurnoutLock")), // NOI18N
468        RESET_DELAYED_SENSOR(ACTION_RESET_DELAYED_SENSOR, ItemType.SENSOR, rbx.getString("ActionResetDelayedSensor")), // NOI18N
469        // allowed settings for timed sensor are active and inactive (in data)
470        //   time in seconds before setting sensor should be in delay
471        CANCEL_SENSOR_TIMERS(ACTION_CANCEL_SENSOR_TIMERS, ItemType.SENSOR, rbx.getString("ActionCancelSensorTimers")), // NOI18N
472        // cancels all timers delaying setting of specified sensor
473        RESET_DELAYED_TURNOUT(ACTION_RESET_DELAYED_TURNOUT, ItemType.TURNOUT, rbx.getString("ActionResetDelayedTurnout")), // NOI18N
474        // allowed settings for timed sensor are active and inactive (in data)
475        //   time in seconds before setting sensor should be in delay
476        CANCEL_TURNOUT_TIMERS(ACTION_CANCEL_TURNOUT_TIMERS, ItemType.TURNOUT, rbx.getString("ActionCancelTurnoutTimers")), // NOI18N
477        // cancels all timers delaying setting of specified sensor
478        SET_FAST_CLOCK_TIME(ACTION_SET_FAST_CLOCK_TIME, ItemType.CLOCK, rbx.getString("ActionSetFastClockTime")), // NOI18N
479        // sets the fast clock time to the time specified
480        START_FAST_CLOCK(ACTION_START_FAST_CLOCK, ItemType.CLOCK, rbx.getString("ActionStartFastClock")), // NOI18N
481        // starts the fast clock
482        STOP_FAST_CLOCK(ACTION_STOP_FAST_CLOCK, ItemType.CLOCK, rbx.getString("ActionStopFastClock")), // NOI18N
483        // stops the fast clock
484        COPY_MEMORY(ACTION_COPY_MEMORY, ItemType.MEMORY, rbx.getString("ActionCopyMemory")), // NOI18N
485        // copies value from memory variable (in name) to memory variable (in string)
486        SET_LIGHT_INTENSITY(ACTION_SET_LIGHT_INTENSITY, ItemType.LIGHT, rbx.getString("ActionSetLightIntensity")), // NOI18N
487        SET_LIGHT_TRANSITION_TIME(ACTION_SET_LIGHT_TRANSITION_TIME, ItemType.LIGHT, rbx.getString("ActionSetLightTransitionTime")), // NOI18N
488        // control the specified audio object
489        CONTROL_AUDIO(ACTION_CONTROL_AUDIO, ItemType.AUDIO, rbx.getString("ActionControlAudio")), // NOI18N
490        // execute a jython command
491        JYTHON_COMMAND(ACTION_JYTHON_COMMAND, ItemType.SCRIPT, rbx.getString("ActionJythonCommand")), // NOI18N
492        // Warrant actions
493        ALLOCATE_WARRANT_ROUTE(ACTION_ALLOCATE_WARRANT_ROUTE, ItemType.WARRANT, rbx.getString("ActionAllocateWarrant")), // NOI18N
494        DEALLOCATE_WARRANT_ROUTE(ACTION_DEALLOCATE_WARRANT_ROUTE, ItemType.WARRANT, rbx.getString("ActionDeallocateWarrant")), // NOI18N
495        SET_ROUTE_TURNOUTS(ACTION_SET_ROUTE_TURNOUTS, ItemType.WARRANT, rbx.getString("ActionSetWarrantTurnouts")), // NOI18N
496        AUTO_RUN_WARRANT(ACTION_AUTO_RUN_WARRANT, ItemType.WARRANT, rbx.getString("ActionAutoRunWarrant")), // NOI18N
497        MANUAL_RUN_WARRANT(ACTION_MANUAL_RUN_WARRANT, ItemType.WARRANT, rbx.getString("ActionManualRunWarrant")), // NOI18N
498        CONTROL_TRAIN(ACTION_CONTROL_TRAIN, ItemType.WARRANT, rbx.getString("ActionControlTrain")), // NOI18N
499        SET_TRAIN_ID(ACTION_SET_TRAIN_ID, ItemType.WARRANT, rbx.getString("ActionSetTrainId")), // NOI18N
500        SET_TRAIN_NAME(ACTION_SET_TRAIN_NAME, ItemType.WARRANT, rbx.getString("ActionSetTrainName")), // NOI18N
501        SET_SIGNALMAST_ASPECT(ACTION_SET_SIGNALMAST_ASPECT, ItemType.SIGNALMAST, rbx.getString("ActionSetSignalMastAspect")), // NOI18N
502        GET_TRAIN_LOCATION(ACTION_GET_TRAIN_LOCATION, ItemType.WARRANT, rbx.getString("ActionSetTrainLocation")), // NOI18N
503        GET_BLOCK_WARRANT(ACTION_GET_BLOCK_WARRANT, ItemType.OBLOCK, rbx.getString("ActionGetBlockWarrant")), // NOI18N
504        GET_BLOCK_TRAIN_NAME(ACTION_GET_BLOCK_TRAIN_NAME, ItemType.OBLOCK, rbx.getString("ActionGetBlockTrainName")), // NOI18N
505        SET_SIGNALMAST_HELD(ACTION_SET_SIGNALMAST_HELD, ItemType.SIGNALMAST, rbx.getString("ActionSetSignalMastHeld")), // NOI18N
506        CLEAR_SIGNALMAST_HELD(ACTION_CLEAR_SIGNALMAST_HELD, ItemType.SIGNALMAST, rbx.getString("ActionClearSignalMastHeld")), // NOI18N
507        SET_SIGNALMAST_DARK(ACTION_SET_SIGNALMAST_DARK, ItemType.SIGNALMAST, rbx.getString("ActionSetSignalMastDark")), // NOI18N
508        SET_SIGNALMAST_LIT(ACTION_SET_SIGNALMAST_LIT, ItemType.SIGNALMAST, rbx.getString("ActionClearSignalMastDark")), // NOI18N
509        SET_BLOCK_VALUE(ACTION_SET_BLOCK_VALUE, ItemType.OBLOCK, rbx.getString("ActionSetBlockValue")), // NOI18N
510        SET_BLOCK_ERROR(ACTION_SET_BLOCK_ERROR, ItemType.OBLOCK, rbx.getString("ActionSetBlockError")), // NOI18N
511        CLEAR_BLOCK_ERROR(ACTION_CLEAR_BLOCK_ERROR, ItemType.OBLOCK, rbx.getString("ActionClearBlockError")), // NOI18N
512        DEALLOCATE_BLOCK(ACTION_DEALLOCATE_BLOCK, ItemType.OBLOCK, rbx.getString("ActionDeallocateBlock")), // NOI18N
513        SET_BLOCK_OUT_OF_SERVICE(ACTION_SET_BLOCK_OUT_OF_SERVICE, ItemType.OBLOCK, rbx.getString("ActionSetBlockOutOfService")), // NOI18N
514        SET_BLOCK_IN_SERVICE(ACTION_SET_BLOCK_IN_SERVICE, ItemType.OBLOCK, rbx.getString("ActionBlockInService")), // NOI18N
515        // EntryExit Actions
516        SET_NXPAIR_ENABLED(ACTION_SET_NXPAIR_ENABLED, ItemType.ENTRYEXIT, rbx.getString("ActionNXPairEnabled")), // NOI18N
517        SET_NXPAIR_DISABLED(ACTION_SET_NXPAIR_DISABLED, ItemType.ENTRYEXIT, rbx.getString("ActionNXPairDisabled")), // NOI18N
518        SET_NXPAIR_SEGMENT(ACTION_SET_NXPAIR_SEGMENT, ItemType.ENTRYEXIT, rbx.getString("ActionNXPairSegment")); // NOI18N
519
520
521        private final int _item;
522        private final ItemType _itemType;
523        private final String _string;
524
525        private static final List<Action> sensorItemsList;
526        private static final List<Action> turnoutItemsList;
527        private static final List<Action> lightItemsList;
528        private static final List<Action> warrantItemsList;
529        private static final List<Action> memoryItemsList;
530        private static final List<Action> oblockItemsList;
531        private static final List<Action> entryExitItemsList;
532        private static final List<Action> signalHeadItemsList;
533        private static final List<Action> signalMastItemsList;
534        private static final List<Action> clockItemsList;
535        private static final List<Action> logixItemsList;
536        private static final List<Action> audioItemsList;
537        private static final List<Action> scriptItemsList;
538        private static final List<Action> otherItemsList;
539
540
541        static
542        {
543            Action[] typeArray1 = {SET_SENSOR, DELAYED_SENSOR,
544                RESET_DELAYED_SENSOR, CANCEL_SENSOR_TIMERS};
545            sensorItemsList = Collections.unmodifiableList(Arrays.asList(typeArray1));
546
547            Action[] typeArray2 = {SET_TURNOUT, DELAYED_TURNOUT, LOCK_TURNOUT,
548                CANCEL_TURNOUT_TIMERS, RESET_DELAYED_TURNOUT};
549            turnoutItemsList = Collections.unmodifiableList(Arrays.asList(typeArray2));
550
551            Action[] typeArray3 = {SET_LIGHT, SET_LIGHT_INTENSITY,
552                SET_LIGHT_TRANSITION_TIME};
553            lightItemsList = Collections.unmodifiableList(Arrays.asList(typeArray3));
554
555            Action[] typeArray4 = {ALLOCATE_WARRANT_ROUTE, DEALLOCATE_WARRANT_ROUTE,
556                SET_ROUTE_TURNOUTS, AUTO_RUN_WARRANT, MANUAL_RUN_WARRANT, CONTROL_TRAIN,
557                SET_TRAIN_ID, SET_TRAIN_NAME, GET_TRAIN_LOCATION};
558            warrantItemsList = Collections.unmodifiableList(Arrays.asList(typeArray4));
559
560            Action[] typeArray5 = {SET_MEMORY, COPY_MEMORY};
561            memoryItemsList = Collections.unmodifiableList(Arrays.asList(typeArray5));
562
563            Action[] typeArray6 = {SET_NXPAIR_ENABLED, SET_NXPAIR_DISABLED,
564                SET_NXPAIR_SEGMENT};
565            entryExitItemsList = Collections.unmodifiableList(Arrays.asList(typeArray6));
566
567            Action[] typeArray7 = {SET_SIGNAL_APPEARANCE, SET_SIGNAL_HELD,
568                CLEAR_SIGNAL_HELD, SET_SIGNAL_DARK, SET_SIGNAL_LIT};
569            signalHeadItemsList = Collections.unmodifiableList(Arrays.asList(typeArray7));
570
571            Action[] typeArray8 = {SET_SIGNALMAST_ASPECT, SET_SIGNALMAST_HELD,
572                CLEAR_SIGNALMAST_HELD, SET_SIGNALMAST_DARK, SET_SIGNALMAST_LIT};
573            signalMastItemsList = Collections.unmodifiableList(Arrays.asList(typeArray8));
574
575            Action[] typeArray9 = {SET_FAST_CLOCK_TIME, START_FAST_CLOCK,
576                STOP_FAST_CLOCK};
577            clockItemsList = Collections.unmodifiableList(Arrays.asList(typeArray9));
578
579            Action[] typeArray10 = {ENABLE_LOGIX, DISABLE_LOGIX};
580            logixItemsList = Collections.unmodifiableList(Arrays.asList(typeArray10));
581
582            Action[] typeArray11 = {DEALLOCATE_BLOCK, SET_BLOCK_VALUE,
583                SET_BLOCK_ERROR, CLEAR_BLOCK_ERROR, SET_BLOCK_OUT_OF_SERVICE,
584                SET_BLOCK_IN_SERVICE, GET_BLOCK_TRAIN_NAME, GET_BLOCK_WARRANT};
585            oblockItemsList = Collections.unmodifiableList(Arrays.asList(typeArray11));
586
587            Action[] typeArray12 = {PLAY_SOUND, CONTROL_AUDIO};
588            audioItemsList = Collections.unmodifiableList(Arrays.asList(typeArray12));
589
590            Action[] typeArray13 = {RUN_SCRIPT, JYTHON_COMMAND};
591            scriptItemsList = Collections.unmodifiableList(Arrays.asList(typeArray13));
592
593            Action[] typeArray14 = {TRIGGER_ROUTE};
594            otherItemsList = Collections.unmodifiableList(Arrays.asList(typeArray14));
595        }
596
597        private Action(int state, ItemType itemType, String string) {
598            _item = state;
599            _itemType = itemType;
600            _string = string;
601        }
602
603        public ItemType getItemType() {
604            return _itemType;
605        }
606
607        public int getIntValue() {
608            return _item;
609        }
610
611        public static List<Action> getSensorItems() {
612            return sensorItemsList;
613        }
614
615        public static List<Action> getTurnoutItems() {
616            return turnoutItemsList;
617        }
618
619        public static List<Action> getLightItems() {
620            return lightItemsList;
621        }
622
623        public static List<Action> getWarrantItems() {
624            return warrantItemsList;
625        }
626
627        public static List<Action> getMemoryItems() {
628            return memoryItemsList;
629        }
630
631        public static List<Action> getOBlockItems() {
632            return oblockItemsList;
633        }
634
635        public static List<Action> getEntryExitItems() {
636            return entryExitItemsList;
637        }
638
639        public static List<Action> getSignalHeadItems() {
640            return signalHeadItemsList;
641        }
642
643        public static List<Action> getSignalMastItems() {
644            return signalMastItemsList;
645        }
646
647        public static List<Action> getClockItems() {
648            return clockItemsList;
649        }
650
651        public static List<Action> getLogixItems() {
652            return logixItemsList;
653        }
654
655        public static List<Action> getAudioItems() {
656            return audioItemsList;
657        }
658
659        public static List<Action> getScriptItems() {
660            return scriptItemsList;
661        }
662
663        public static List<Action> getOtherItems() {
664            return otherItemsList;
665        }
666
667        public static Action getOperatorFromIntValue(int actionInt) {
668            for (Action action : Action.values()) {
669                if (action.getIntValue() == actionInt) {
670                    return action;
671                }
672            }
673
674            throw new IllegalArgumentException("Action is unknown");
675        }
676
677        // Some items uses Bundle.getString() and some items uses rbx.getString()
678        // and therefore the items must call getString() in the call to the constructor.
679        @Override
680        public String toString() {
681            return _string;
682        }
683
684    }
685
686    // state variable types
687    static final int TYPE_ERROR = -1;
688    static final int TYPE_NONE = 0;
689    static final int TYPE_SENSOR_ACTIVE = 1;
690    static final int TYPE_SENSOR_INACTIVE = 2;
691    static final int TYPE_TURNOUT_THROWN = 3;
692    static final int TYPE_TURNOUT_CLOSED = 4;
693    static final int TYPE_CONDITIONAL_TRUE = 5;
694    static final int TYPE_CONDITIONAL_FALSE = 6;
695    static final int TYPE_LIGHT_ON = 7;
696    static final int TYPE_LIGHT_OFF = 8;
697    static final int TYPE_MEMORY_EQUALS = 9;
698    static final int TYPE_FAST_CLOCK_RANGE = 10;
699    // Note - within the TYPE_SIGNAL_HEAD definitions, all must be together,
700    //  RED must be first, and HELD must be last
701    static final int TYPE_SIGNAL_HEAD_RED = 11;
702    static final int TYPE_SIGNAL_HEAD_YELLOW = 12;
703    static final int TYPE_SIGNAL_HEAD_GREEN = 13;
704    static final int TYPE_SIGNAL_HEAD_DARK = 14;
705    static final int TYPE_SIGNAL_HEAD_FLASHRED = 15;
706    static final int TYPE_SIGNAL_HEAD_FLASHYELLOW = 16;
707    static final int TYPE_SIGNAL_HEAD_FLASHGREEN = 17;
708    static final int TYPE_SIGNAL_HEAD_LIT = 18;
709    static final int TYPE_SIGNAL_HEAD_HELD = 19;
710    static final int TYPE_MEMORY_COMPARE = 20;
711    static final int TYPE_SIGNAL_HEAD_LUNAR = 21;
712    static final int TYPE_SIGNAL_HEAD_FLASHLUNAR = 22;
713    static final int TYPE_MEMORY_EQUALS_INSENSITIVE = 23;
714    static final int TYPE_MEMORY_COMPARE_INSENSITIVE = 24;
715    // Warrant variables
716    static final int TYPE_ROUTE_FREE = 25;
717    static final int TYPE_ROUTE_OCCUPIED = 26;
718    static final int TYPE_ROUTE_ALLOCATED = 27;
719    static final int TYPE_ROUTE_SET = 28;
720    static final int TYPE_TRAIN_RUNNING = 29;
721    static final int TYPE_SIGNAL_MAST_ASPECT_EQUALS = 30;
722    static final int TYPE_SIGNAL_MAST_LIT = 31;
723    static final int TYPE_SIGNAL_MAST_HELD = 32;
724    static final int TYPE_SIGNAL_HEAD_APPEARANCE_EQUALS = 33;
725
726    static final int TYPE_BLOCK_STATUS_EQUALS = 34;
727
728    //Entry Exit Rules
729    static final int TYPE_ENTRYEXIT_ACTIVE = 35;
730    static final int TYPE_ENTRYEXIT_INACTIVE = 36;
731
732    static final int TYPE_OBLOCK_UNOCCUPIED = 37;
733    static final int TYPE_OBLOCK_OCCUPIED = 38;
734    static final int TYPE_OBLOCK_ALLOCATED = 39;
735    static final int TYPE_OBLOCK_RUNNING = 40;
736    static final int TYPE_OBLOCK_OUT_OF_SERVICE = 41;
737    static final int TYPE_OBLOCK_DARK = 42;
738    static final int TYPE_OBLOCK_POWER_ERROR = 43;
739
740    static final int TYPE_XXXXXXX = 9999;
741
742    // action definitions
743    static final int ACTION_OPTION_ON_CHANGE_TO_TRUE = 1;
744    static final int ACTION_OPTION_ON_CHANGE_TO_FALSE = 2;
745    static final int ACTION_OPTION_ON_CHANGE = 3;
746    static final int NUM_ACTION_OPTIONS = 3;
747
748    // action types
749    static final int ACTION_NONE = 1;
750    static final int ACTION_SET_TURNOUT = 2;
751    // allowed settings for turnout are Thrown and Closed (in data)
752    static final int ACTION_SET_SIGNAL_APPEARANCE = 3;
753    // allowed settings for signal head are the seven Appearances (in data)
754    static final int ACTION_SET_SIGNAL_HELD = 4;
755    static final int ACTION_CLEAR_SIGNAL_HELD = 5;
756    static final int ACTION_SET_SIGNAL_DARK = 6;
757    static final int ACTION_SET_SIGNAL_LIT = 7;
758    static final int ACTION_TRIGGER_ROUTE = 8;
759    static final int ACTION_SET_SENSOR = 9;
760    // allowed settings for sensor are active and inactive (in data)
761    static final int ACTION_DELAYED_SENSOR = 10;
762    // allowed settings for timed sensor are active and inactive (in data)
763    //   time in seconds before setting sensor should be in delay
764    static final int ACTION_SET_LIGHT = 11;
765    // allowed settings for light are ON and OFF (in data)
766    static final int ACTION_SET_MEMORY = 12;
767    // text to set into the memory variable should be in string
768    static final int ACTION_ENABLE_LOGIX = 13;
769    static final int ACTION_DISABLE_LOGIX = 14;
770    static final int ACTION_PLAY_SOUND = 15;
771    // reference to sound should be in string
772    static final int ACTION_RUN_SCRIPT = 16;
773    // reference to script should be in string
774    static final int ACTION_DELAYED_TURNOUT = 17;
775    // allowed settings for timed turnout are Thrown and Closed (in data)
776    //   time in seconds before setting turnout should be in delay
777    static final int ACTION_LOCK_TURNOUT = 18;
778    static final int ACTION_RESET_DELAYED_SENSOR = 19;
779    // allowed settings for timed sensor are active and inactive (in data)
780    //   time in seconds before setting sensor should be in delay
781    static final int ACTION_CANCEL_SENSOR_TIMERS = 20;
782    // cancels all timers delaying setting of specified sensor
783    static final int ACTION_RESET_DELAYED_TURNOUT = 21;
784    // allowed settings for timed sensor are active and inactive (in data)
785    //   time in seconds before setting sensor should be in delay
786    static final int ACTION_CANCEL_TURNOUT_TIMERS = 22;
787    // cancels all timers delaying setting of specified sensor
788    static final int ACTION_SET_FAST_CLOCK_TIME = 23;
789    // sets the fast clock time to the time specified
790    static final int ACTION_START_FAST_CLOCK = 24;
791    // starts the fast clock
792    static final int ACTION_STOP_FAST_CLOCK = 25;
793    // stops the fast clock
794    static final int ACTION_COPY_MEMORY = 26;
795    // copies value from memory variable (in name) to memory variable (in string)
796    static final int ACTION_SET_LIGHT_INTENSITY = 27;
797    static final int ACTION_SET_LIGHT_TRANSITION_TIME = 28;
798    // control the specified audio object
799    static final int ACTION_CONTROL_AUDIO = 29;
800    // execute a jython command
801    static final int ACTION_JYTHON_COMMAND = 30;
802    // Warrant actions
803    static final int ACTION_ALLOCATE_WARRANT_ROUTE = 31;
804    static final int ACTION_DEALLOCATE_WARRANT_ROUTE = 32;
805    static final int ACTION_SET_ROUTE_TURNOUTS = 33;
806    static final int ACTION_AUTO_RUN_WARRANT = 34;
807    static final int ACTION_CONTROL_TRAIN = 35;
808    static final int ACTION_SET_TRAIN_ID = 36;
809    static final int ACTION_SET_SIGNALMAST_ASPECT = 37;
810    static final int ACTION_GET_TRAIN_LOCATION = 38;
811    static final int ACTION_SET_SIGNALMAST_HELD = 39;
812    static final int ACTION_CLEAR_SIGNALMAST_HELD = 40;
813    static final int ACTION_SET_SIGNALMAST_DARK = 41;
814    static final int ACTION_SET_SIGNALMAST_LIT = 42;
815    static final int ACTION_SET_BLOCK_ERROR = 43;
816    static final int ACTION_CLEAR_BLOCK_ERROR = 44;
817    static final int ACTION_DEALLOCATE_BLOCK = 45;
818    static final int ACTION_SET_BLOCK_OUT_OF_SERVICE = 46;
819    static final int ACTION_SET_BLOCK_IN_SERVICE = 47;
820    static final int ACTION_MANUAL_RUN_WARRANT = 48;
821    static final int ACTION_SET_TRAIN_NAME = 49;
822    static final int ACTION_SET_BLOCK_VALUE = 50;
823    // EntryExit Actions
824    static final int ACTION_SET_NXPAIR_ENABLED = 51;
825    static final int ACTION_SET_NXPAIR_DISABLED = 52;
826    static final int ACTION_SET_NXPAIR_SEGMENT = 53;
827
828    static final int ACTION_GET_BLOCK_WARRANT = 54;
829    static final int ACTION_GET_BLOCK_TRAIN_NAME = 55;
830
831    /**
832     * ***********************************************************************************
833     */
834    /* New Variable and Action type scheme for Logix UI
835     * State Variables and actions are grouped according to type.  Variable and action
836     * types share the following group categories:
837     */
838    // state variable and action items used by logix.
839    static final int ITEM_TYPE_SENSOR = 1;
840    static final int ITEM_TYPE_TURNOUT = 2;
841    static final int ITEM_TYPE_LIGHT = 3;
842    static final int ITEM_TYPE_SIGNALHEAD = 4;
843    static final int ITEM_TYPE_SIGNALMAST = 5;
844    static final int ITEM_TYPE_MEMORY = 6;
845    static final int ITEM_TYPE_CONDITIONAL = 7;  // used only by ConditionalVariable
846    static final int ITEM_TYPE_LOGIX = 7;        // used only by ConditionalAction
847    static final int ITEM_TYPE_WARRANT = 8;
848    static final int ITEM_TYPE_CLOCK = 9;
849    static final int ITEM_TYPE_OBLOCK = 10;
850    static final int ITEM_TYPE_ENTRYEXIT = 11;
851
852    static final int ITEM_TYPE_AUDIO = 12;
853    static final int ITEM_TYPE_SCRIPT = 13;
854    static final int ITEM_TYPE_OTHER = 14;
855
856    /**
857     * set the logic type (all AND's all OR's or mixed AND's and OR's set the
858     * antecedent expression - should be a well formed boolean statement with
859     * parenthesis indicating the order of evaluation
860     *
861     * @param type       the type
862     * @param antecedent the expression
863     */
864    public void setLogicType(Conditional.AntecedentOperator type, String antecedent);
865
866    /**
867     * Get antecedent (boolean expression) of Conditional
868     *
869     * @return the expression
870     */
871    public String getAntecedentExpression();
872
873    /**
874     * Get type of operators in the antecedent statement
875     *
876     * @return the type
877     */
878    public Conditional.AntecedentOperator getLogicType();
879
880    /**
881     * @return true if action list is executed only when state changes, false if
882     *         action list is executed on every calculation of state
883     */
884    public boolean getTriggerOnChange();
885
886    /**
887     * Set policy for execution of action list
888     *
889     * @param trigger true execute only on change of state
890     */
891    public void setTriggerOnChange(boolean trigger);
892
893    /**
894     * Set list of actions
895     *
896     * @param arrayList the actions
897     */
898    public void setAction(List<ConditionalAction> arrayList);
899
900    /**
901     * Make deep clone of actions.
902     *
903     * @return a list of copies of actions
904     */
905    @Nonnull
906    public List<ConditionalAction> getCopyOfActions();
907
908    /**
909     * Set State Variables for this Conditional. Each state variable will
910     * evaluate either True or False when this Conditional is calculated.
911     * <p>
912     * This method assumes that all information has been validated.
913     *
914     * @param arrayList the list of variables
915     */
916    public void setStateVariables(List<ConditionalVariable> arrayList);
917
918    /**
919     * Make deep clone of variables.
920     *
921     * @return a list containing copies of variables
922     */
923    @Nonnull
924    public List<ConditionalVariable> getCopyOfStateVariables();
925
926    /**
927     * Calculate this Conditional, triggering either or both actions if the user
928     * specified conditions are met, and the Logix is enabled. Sets the state of
929     * the conditional. Returns the calculated state of this Conditional.
930     *
931     * @param enabled true if Logix should be enabled; false otherwise
932     * @param evt     event to trigger if true
933     * @return the new state
934     */
935    public int calculate(boolean enabled, PropertyChangeEvent evt);
936
937    /**
938     * Check that an antecedent is well formed. If not, returns an error
939     * message. Otherwise returns null.
940     *
941     * @param ant          the expression
942     * @param variableList list of variables
943     * @return true if well formed; false otherwise
944     */
945    public String validateAntecedent(String ant, List<ConditionalVariable> variableList);
946
947    /**
948     * Stop a sensor timer if one is actively delaying setting of the specified
949     * sensor
950     *
951     * @param sname the name of the timer
952     */
953    public void cancelSensorTimer(String sname);
954
955    /**
956     * Stop a turnout timer if one is actively delaying setting of the specified
957     * turnout
958     *
959     * @param sname the name of the timer
960     */
961    public void cancelTurnoutTimer(String sname);
962
963    /**
964     * State of the Conditional is returned.
965     *
966     * @return state value
967     */
968    @Override
969    public int getState();
970
971    /**
972     * Request a call-back when the bound KnownState property changes.
973     *
974     * @param l the listener
975     */
976    @Override
977    public void addPropertyChangeListener(PropertyChangeListener l);
978
979    /**
980     * Remove a request for a call-back when a bound property changes.
981     *
982     * @param l the listener
983     */
984    @Override
985    public void removePropertyChangeListener(PropertyChangeListener l);
986
987    /**
988     * Remove references to and from this object, so that it can eventually be
989     * garbage-collected.
990     */
991    @Override
992    public void dispose();  // remove _all_ connections!
993
994}