001package jmri.jmrit.logixng.expressions;
002
003import java.beans.PropertyChangeEvent;
004import java.beans.PropertyChangeListener;
005import java.util.Locale;
006import java.util.Map;
007import jmri.*;
008import jmri.jmrit.logixng.*;
009import jmri.jmrit.logixng.util.ReferenceUtil;
010
011/**
012 * Evaluates what a reference points to.
013 * 
014 * @author Daniel Bergqvist Copyright 2018
015 */
016public class ExpressionReference extends AbstractDigitalExpression
017        implements PropertyChangeListener {
018//        implements PropertyChangeListener, VetoableChangeListener {
019
020    private String _reference;
021    private Is_IsNot_Enum _is_IsNot = Is_IsNot_Enum.Is;
022    private PointsTo _pointsTo = PointsTo.Nothing;
023
024    public ExpressionReference(String sys, String user)
025            throws BadUserNameException, BadSystemNameException {
026        super(sys, user);
027    }
028    
029    @Override
030    public Base getDeepCopy(Map<String, String> systemNames, Map<String, String> userNames) throws JmriException {
031        DigitalExpressionManager manager = InstanceManager.getDefault(DigitalExpressionManager.class);
032        String sysName = systemNames.get(getSystemName());
033        String userName = userNames.get(getSystemName());
034        if (sysName == null) sysName = manager.getAutoSystemName();
035        ExpressionReference copy = new ExpressionReference(sysName, userName);
036        copy.setComment(getComment());
037        copy.setReference(_reference);
038        copy.set_Is_IsNot(_is_IsNot);
039        copy.setPointsTo(_pointsTo);
040        return manager.registerExpression(copy).deepCopyChildren(this, systemNames, userNames);
041    }
042    
043    public void setReference(String reference) {
044        assertListenersAreNotRegistered(log, "setReference");
045        _reference = reference;
046    }
047    
048    public String getReference() {
049        return _reference;
050    }
051    
052    public void set_Is_IsNot(Is_IsNot_Enum is_IsNot) {
053        _is_IsNot = is_IsNot;
054    }
055    
056    public Is_IsNot_Enum get_Is_IsNot() {
057        return _is_IsNot;
058    }
059    
060    public void setPointsTo(PointsTo pointsTo) {
061        _pointsTo = pointsTo;
062    }
063    
064    public PointsTo getPointsTo() {
065        return _pointsTo;
066    }
067/*
068    @Override
069    public void vetoableChange(java.beans.PropertyChangeEvent evt) throws java.beans.PropertyVetoException {
070        if ("CanDelete".equals(evt.getPropertyName())) { // No I18N
071            if (evt.getOldValue() instanceof String) {
072                if (evt.getOldValue().equals(getReference().getBean())) {
073                    throw new PropertyVetoException(getDisplayName(), evt);
074                }
075            }
076        } else if ("DoDelete".equals(evt.getPropertyName())) { // No I18N
077            if (evt.getOldValue() instanceof String) {
078                if (evt.getOldValue().equals(getReference().getBean())) {
079                    setReference((Turnout)null);
080                }
081            }
082        }
083    }
084*/    
085    /** {@inheritDoc} */
086    @Override
087    public LogixNG_Category getCategory() {
088        return LogixNG_Category.ITEM;
089    }
090
091    /** {@inheritDoc} */
092    @Override
093    public boolean evaluate() {
094        if (_reference == null) return false;
095        
096        boolean result;
097        String ref = ReferenceUtil.getReference(
098                getConditionalNG().getSymbolTable(), _reference);
099        NamedBean t;
100
101        switch (_pointsTo) {
102            case Nothing:
103                result = "".equals(ref);
104                break;
105            
106            case LogixNGTable:
107                t = InstanceManager.getDefault(NamedTableManager.class).getNamedBean(ref);
108                result = (t != null);
109                break;
110            
111            case Audio:
112                t = InstanceManager.getDefault(AudioManager.class).getNamedBean(ref);
113                result = (t != null);
114                break;
115            
116            case Light:
117                t = InstanceManager.getDefault(LightManager.class).getNamedBean(ref);
118                result = (t != null);
119                break;
120            
121            case Memory:
122                t = InstanceManager.getDefault(MemoryManager.class).getNamedBean(ref);
123                result = (t != null);
124                break;
125            
126            case Sensor:
127                t = InstanceManager.getDefault(SensorManager.class).getNamedBean(ref);
128                result = (t != null);
129                break;
130            
131            case SignalHead:
132                t = InstanceManager.getDefault(SignalHeadManager.class).getNamedBean(ref);
133                result = (t != null);
134                break;
135            
136            case SignalMast:
137                t = InstanceManager.getDefault(SignalMastManager.class).getNamedBean(ref);
138                result = (t != null);
139                break;
140            
141            case Turnout:
142                t = InstanceManager.getDefault(TurnoutManager.class).getNamedBean(ref);
143                result = (t != null);
144                break;
145            
146            default:
147                throw new UnsupportedOperationException("_pointsTo has unknown value: "+_pointsTo.name());
148        }
149        
150        if (_is_IsNot == Is_IsNot_Enum.Is) {
151            return result;
152        } else {
153            return !result;
154        }
155    }
156
157    @Override
158    public FemaleSocket getChild(int index) throws IllegalArgumentException, UnsupportedOperationException {
159        throw new UnsupportedOperationException("Not supported.");
160    }
161
162    @Override
163    public int getChildCount() {
164        return 0;
165    }
166
167    @Override
168    public String getShortDescription(Locale locale) {
169        return Bundle.getMessage(locale, "Reference_Short");
170    }
171
172    @Override
173    public String getLongDescription(Locale locale) {
174        String reference;
175        if (_reference != null) {
176            reference = _reference;
177        } else {
178            reference = Bundle.getMessage(locale, "ReferenceNotSelected");
179        }
180        
181        return Bundle.getMessage(
182                locale,
183                "Reference_Long",
184                reference.isEmpty() ? "''" : reference,
185                _is_IsNot.toString(),
186                _pointsTo._text);
187    }
188    
189    /** {@inheritDoc} */
190    @Override
191    public void setup() {
192        // Do nothing
193    }
194    
195    /** {@inheritDoc} */
196    @Override
197    public void registerListenersForThisClass() {
198        if (!_listenersAreRegistered && (_reference != null)) {
199//            _reference.getBean().addPropertyChangeListener("KnownState", this);
200            _listenersAreRegistered = true;
201        }
202    }
203    
204    /** {@inheritDoc} */
205    @Override
206    public void unregisterListenersForThisClass() {
207        if (_listenersAreRegistered) {
208//            _reference.getBean().removePropertyChangeListener("KnownState", this);
209            _listenersAreRegistered = false;
210        }
211    }
212    
213    /** {@inheritDoc} */
214    @Override
215    public void propertyChange(PropertyChangeEvent evt) {
216        getConditionalNG().execute();
217    }
218    
219    /** {@inheritDoc} */
220    @Override
221    public void disposeMe() {
222    }
223    
224    
225    
226    public enum PointsTo {
227        Nothing(Bundle.getMessage("ReferencePointsTo_Nothing")),
228        Audio(Bundle.getMessage("ReferencePointsTo_Audio")),
229        Light(Bundle.getMessage("ReferencePointsTo_Light")),
230        Memory(Bundle.getMessage("ReferencePointsTo_Memory")),
231        Sensor(Bundle.getMessage("ReferencePointsTo_Sensor")),
232        SignalHead(Bundle.getMessage("ReferencePointsTo_SignalHead")),
233        SignalMast(Bundle.getMessage("ReferencePointsTo_SignalMast")),
234        Turnout(Bundle.getMessage("ReferencePointsTo_Turnout")),
235        LogixNGTable(Bundle.getMessage("ReferencePointsTo_LogixNGTable"));
236        
237        private final String _text;
238        
239        private PointsTo(String text) {
240            this._text = text;
241        }
242        
243        @Override
244        public String toString() {
245            return _text;
246        }
247        
248    }
249    
250    
251    private final static org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(ExpressionReference.class);
252    
253}