Source code

001package jmri.implementation;
002
003import java.util.*;
004
005import javax.annotation.Nonnull;
006
007import jmri.NamedBeanHandle;
008import jmri.Turnout;
009
010/**
011 * SignalMast implemented via Turnout objects.
012 * <p>
013 * A SignalMast that is built up using turnouts to control a specific
014 * appearance. System name specifies the creation information:
015 * <pre>
016 * IF$tsm:basic:one-searchlight(IT1)(IT2)
017 * </pre> The name is a colon-separated series of terms:
018 * <ul>
019 * <li>IF$tsm - defines signal masts of this type
020 * <li>basic - name of the signaling system
021 * <li>one-searchlight - name of the particular aspect map
022 * <li>(IT1)(IT2) - colon-separated list of names for Turnouts
023 * </ul>
024 *
025 * @author Bob Jacobsen Copyright (C) 2009, 2014
026 */
027public class TurnoutSignalMast extends AbstractSignalMast {
028
029    public TurnoutSignalMast(String systemName, String userName) {
030        super(systemName, userName);
031        configureFromName(systemName);
032    }
033
034    public TurnoutSignalMast(String systemName) {
035        super(systemName);
036        configureFromName(systemName);
037    }
038
039    private static final String THE_MAST_TYPE = "IF$tsm";
040
041    private void configureFromName(String systemName) {
042        // split out the basic information
043        String[] parts = systemName.split(":");
044        if (parts.length < 3) {
045            log.error("SignalMast system name needs at least three parts: {}", systemName);
046            throw new IllegalArgumentException("System name needs at least three parts: " + systemName);
047        }
048        if (!parts[0].equals(THE_MAST_TYPE)) {
049            log.warn("SignalMast system name should start with {} but is {}", THE_MAST_TYPE, systemName);
050        }
051        String system = parts[1];
052        String mast = parts[2];
053
054        mast = mast.substring(0, mast.indexOf("("));
055        setMastType(mast);
056
057        String tmp = parts[2].substring(parts[2].indexOf("($") + 2, parts[2].indexOf(")"));
058        try {
059            int autoNumber = Integer.parseInt(tmp);
060            if (autoNumber > getLastRef()) {
061                setLastRef(autoNumber);
062            }
063        } catch (NumberFormatException e) {
064            log.warn("Auto generated SystemName {} is not in the correct format", systemName);
065        }
066
067        configureSignalSystemDefinition(system);
068        configureAspectTable(system, mast);
069    }
070
071    @Override
072    public void setAspect(@Nonnull String aspect) {
073        // check it's a choice
074        if (!map.checkAspect(aspect)) {
075            // not a valid aspect
076            log.warn("attempting to set invalid aspect: {} on mast: {}", aspect, getDisplayName());
077            throw new IllegalArgumentException("attempting to set invalid aspect: "
078                + aspect + " on mast: " + getDisplayName());
079        } else if (disabledAspects.contains(aspect)) {
080            log.warn("attempting to set an aspect that has been disabled: {} on mast: {}", aspect, getDisplayName());
081            throw new IllegalArgumentException("attempting to set an aspect that has been disabled: "
082                + aspect + " on mast: " + getDisplayName());
083        }
084
085
086        if (getLit()) { // If the signalmast is lit, then send the commands to change the aspect.
087
088            // reset all states before setting this one, including this one
089            if (resetPreviousStates) {
090                // Clear all the current states, this will result in the signalmast going blank for a very short time.
091                for (Map.Entry<String, TurnoutAspect> entry : turnouts.entrySet()) {
092                    String appearance = entry.getKey();
093                    TurnoutAspect aspt = entry.getValue();
094                    if (!isAspectDisabled(appearance)) {
095                        int setState = Turnout.CLOSED;
096                        if (aspt.getTurnoutState() == Turnout.CLOSED) {
097                            setState = Turnout.THROWN;
098                        }
099                        if (aspt.getTurnout() != null ) {
100                            if (aspt.getTurnout().getKnownState() != setState) {
101                                aspt.getTurnout().setCommandedState(setState);
102                            }
103                        } else {
104                            log.error("Trying to reset \"{}\" on signal mast \"{}\" which has not been configured",
105                                appearance, getDisplayName());
106                        }
107                    }
108                }
109            }
110
111            // set the finel state if possible
112            if (turnouts.get(aspect) != null && turnouts.get(aspect).getTurnout() != null) {
113                Turnout turnToSet = turnouts.get(aspect).getTurnout();
114                int stateToSet = turnouts.get(aspect).getTurnoutState();
115                turnToSet.setCommandedState(stateToSet);
116            } else {
117                log.error("Trying to set \"{}\" on signal mast \"{}\" which has not been configured",
118                    aspect, getDisplayName());
119            }
120
121        } else {
122            log.debug("Mast set to unlit, will not send aspect change to hardware");
123        }
124        super.setAspect(aspect);
125    }
126
127    private TurnoutAspect unLit = null;
128
129    public void setUnLitTurnout(String turnoutName, int turnoutState) {
130        unLit = new TurnoutAspect(turnoutName, turnoutState);
131    }
132
133    public String getUnLitTurnoutName() {
134        if (unLit != null) {
135            return unLit.getTurnoutName();
136        }
137        return null;
138    }
139
140    public Turnout getUnLitTurnout() {
141        if (unLit != null) {
142            return unLit.getTurnout();
143        }
144        return null;
145    }
146
147    public int getUnLitTurnoutState() {
148        if (unLit != null) {
149            return unLit.getTurnoutState();
150        }
151        return -1;
152    }
153
154    @Override
155    public void setLit(boolean newLit) {
156        if (!allowUnLit() || newLit == getLit()) {
157            return;
158        }
159        super.setLit(newLit);
160        if (newLit) {
161            // This will force the signalmast to send out the commands to set the aspect again.
162            String litAspect = getAspect();
163            if (litAspect != null ) {
164                setAspect(litAspect);
165            }
166        } else {
167            if (unLit != null) {
168                // there is a specific unlit output defined
169                Turnout t = unLit.getTurnout();
170                if (t != null && t.getKnownState() != getUnLitTurnoutState()) {
171                    t.setCommandedState(getUnLitTurnoutState());
172                }
173            } else {
174                // turn everything off
175                for (TurnoutAspect tAspect : turnouts.values()) {
176                    int setState = Turnout.CLOSED;
177                    if (tAspect.getTurnoutState() == Turnout.CLOSED) {
178                        setState = Turnout.THROWN;
179                    }
180                    if (tAspect.getTurnout().getKnownState() != setState) {
181                        tAspect.getTurnout().setCommandedState(setState);
182                    }
183                }
184            }
185        }
186    }
187
188    public String getTurnoutName(String appearance) {
189        TurnoutAspect tAspect = turnouts.get(appearance);
190        if (tAspect != null) {
191            return tAspect.getTurnoutName();
192        }
193        return "";
194    }
195
196    public int getTurnoutState(String appearance) {
197        TurnoutAspect tAspect = turnouts.get(appearance);
198        if (tAspect != null) {
199            return tAspect.getTurnoutState();
200        }
201        return -1;
202    }
203
204    public void setTurnout(String appearance, String turn, int state) {
205        if (turnouts.containsKey(appearance)) {
206            log.debug("Appearance {} is already defined so will override", appearance);
207            turnouts.remove(appearance);
208        }
209        turnouts.put(appearance, new TurnoutAspect(turn, state));
210    }
211
212    private final HashMap<String, TurnoutAspect> turnouts = new HashMap<>();
213
214    private boolean resetPreviousStates = false;
215
216    /**
217     * If the signal mast driver requires the previous state to be cleared down
218     * before the next state is set.
219     *
220     * @param boo true if prior states should be cleared; false otherwise
221     */
222    public void resetPreviousStates(boolean boo) {
223        resetPreviousStates = boo;
224    }
225
226    public boolean resetPreviousStates() {
227        return resetPreviousStates;
228    }
229
230    private static class TurnoutAspect {
231
232        NamedBeanHandle<Turnout> namedTurnout;
233        int state;
234
235        TurnoutAspect(String turnoutName, int turnoutState) {
236            if (turnoutName != null && !turnoutName.isEmpty()) {
237                state = turnoutState;
238                Turnout turn = jmri.InstanceManager.turnoutManagerInstance().getTurnout(turnoutName);
239                if (turn == null) {
240                    log.error("TurnoutAspect couldn't locate turnout {}", turnoutName);
241                    return;
242                }
243                namedTurnout = jmri.InstanceManager.getDefault(jmri.NamedBeanHandleManager.class)
244                    .getNamedBeanHandle(turnoutName, turn);
245            }
246        }
247
248        Turnout getTurnout() {
249            if (namedTurnout == null) {
250                return null;
251            }
252            return namedTurnout.getBean();
253        }
254
255        String getTurnoutName() {
256            if (namedTurnout == null) {
257                return null;
258            }
259            return namedTurnout.getName();
260        }
261
262        int getTurnoutState() {
263            return state;
264        }
265    }
266
267    public boolean isTurnoutUsed(Turnout t) {
268        for (TurnoutAspect ta : turnouts.values()) {
269            if (t.equals(ta.getTurnout())) {
270                return true;
271            }
272        }
273        return t.equals(getUnLitTurnout());
274    }
275
276    public List<NamedBeanHandle<Turnout>> getHeadsUsed() {
277        return new ArrayList<>();
278    }
279
280    /**
281     *
282     * @param newVal for ordinal of all TurnoutSignalMasts in use
283     */
284    protected static void setLastRef(int newVal) {
285        lastRef = newVal;
286    }
287
288    /**
289     * @return highest ordinal of all TurnoutSignalMasts in use
290     */
291    public static int getLastRef() {
292        return lastRef;
293    }
294
295    /**
296     * Ordinal of all TurnoutSignalMasts to create unique system name.
297     */
298    protected static volatile int lastRef = 0;
299    // TODO narrow access to static, once jmri/jmrit/beantable/signalmast/TurnoutSignalMastAddPane uses setLastRef(n)
300    //private static volatile int lastRef = 0;
301
302    @Override
303    public void vetoableChange(java.beans.PropertyChangeEvent evt) throws java.beans.PropertyVetoException {
304        if (jmri.Manager.PROPERTY_CAN_DELETE.equals(evt.getPropertyName())
305                && (evt.getOldValue() instanceof Turnout) && (isTurnoutUsed((Turnout) evt.getOldValue()))) {
306
307            java.beans.PropertyChangeEvent e = new java.beans.PropertyChangeEvent(this,
308                jmri.Manager.PROPERTY_DO_NOT_DELETE, null, null);
309            throw new java.beans.PropertyVetoException(Bundle.getMessage("InUseTurnoutSignalMastVeto",
310                getDisplayName()), e);
311        }
312    }
313
314    private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(TurnoutSignalMast.class);
315
316}