001package jmri.jmrit.logixng;
002
003import jmri.*;
004import jmri.jmrit.entryexit.DestinationPoints;
005import jmri.jmrit.entryexit.EntryExitPairs;
006import jmri.jmrit.logix.OBlock;
007import jmri.jmrit.logix.OBlockManager;
008import jmri.jmrit.logix.Warrant;
009import jmri.jmrit.logix.WarrantManager;
010
011/**
012 * Defines types of NamedBeans, for example Turnout and Light.
013 *
014 * @author Daniel Bergqvist Copyright 2019
015 */
016public enum NamedBeanType {
017
018    Audio(
019            Bundle.getMessage("BeanNameAudio"),
020            Bundle.getMessage("BeanNameAudios"),
021            Audio.class,
022            "State",
023            () -> InstanceManager.getDefault(AudioManager.class),
024            null,
025            (NamedBean bean, String property) -> {
026                if (!(bean instanceof Audio)) {
027                    throw new IllegalArgumentException("bean is not an Audio");
028                }
029                InstanceManager.getDefault(AudioManager.class)
030                        .deleteBean((Audio)bean, property);
031            }),
032
033    Block(
034            Bundle.getMessage("BeanNameBlock"),
035            Bundle.getMessage("BeanNameBlocks"),
036            Block.class,
037            null,
038            () -> InstanceManager.getDefault(BlockManager.class),
039            new CreateBean() {
040                @Override
041                public NamedBean createBean(String systemName, String userName) {
042                    return InstanceManager.getDefault(BlockManager.class)
043                            .createNewBlock(systemName, userName);
044                }
045            },
046            (NamedBean bean, String property) -> {
047                if (!(bean instanceof Block)) {
048                    throw new IllegalArgumentException("bean is not a Block");
049                }
050                InstanceManager.getDefault(BlockManager.class)
051                        .deleteBean((Block)bean, property);
052            }),
053
054    GlobalVariable(
055            Bundle.getMessage("BeanNameGlobalVariable"),
056            Bundle.getMessage("BeanNameGlobalVariables"),
057            GlobalVariable.class,
058            "value",
059            () -> InstanceManager.getDefault(GlobalVariableManager.class),
060            new CreateBean() {
061                @Override
062                public NamedBean createBean(String systemName, String userName) {
063                    return InstanceManager.getDefault(GlobalVariableManager.class)
064                            .createGlobalVariable(systemName, userName);
065                }
066            },
067            (NamedBean bean, String property) -> {
068                if (!(bean instanceof GlobalVariable)) {
069                    throw new IllegalArgumentException("bean is not a GlobalVariable");
070                }
071                InstanceManager.getDefault(GlobalVariableManager.class)
072                        .deleteBean((GlobalVariable)bean, property);
073            }),
074
075    EntryExit(
076            Bundle.getMessage("BeanNameEntryExit"),
077            Bundle.getMessage("BeanNameEntryExits"),
078            DestinationPoints.class,
079            "active",
080            () -> InstanceManager.getDefault(EntryExitPairs.class),
081            null,
082            (NamedBean bean, String property) -> {
083                if (!(bean instanceof DestinationPoints)) {
084                    throw new IllegalArgumentException("bean is not a DestinationPoints");
085                }
086                InstanceManager.getDefault(EntryExitPairs.class)
087                        .deleteBean((DestinationPoints)bean, property);
088            }),
089
090    Light(
091            Bundle.getMessage("BeanNameLight"),
092            Bundle.getMessage("BeanNameLights"),
093            Light.class,
094            "KnownState",
095            () -> InstanceManager.getDefault(LightManager.class),
096            new CreateBean() {
097                @Override
098                public NamedBean createBean(String systemName, String userName) {
099                    return InstanceManager.getDefault(LightManager.class)
100                            .newLight(systemName, userName);
101                }
102            },
103            (NamedBean bean, String property) -> {
104                if (!(bean instanceof Light)) {
105                    throw new IllegalArgumentException("bean is not a Light");
106                }
107                InstanceManager.getDefault(LightManager.class).deleteBean((Light)bean, property);
108            }),
109
110    Memory(
111            Bundle.getMessage("BeanNameMemory"),
112            Bundle.getMessage("BeanNameMemories"),
113            Memory.class,
114            "value",
115            () -> InstanceManager.getDefault(MemoryManager.class),
116            new CreateBean() {
117                @Override
118                public NamedBean createBean(String systemName, String userName) {
119                    return InstanceManager.getDefault(MemoryManager.class)
120                            .newMemory(systemName, userName);
121                }
122            },
123            (NamedBean bean, String property) -> {
124                if (!(bean instanceof Memory)) {
125                    throw new IllegalArgumentException("bean is not a Memory");
126                }
127                InstanceManager.getDefault(MemoryManager.class)
128                        .deleteBean((Memory)bean, property);
129            }),
130
131    OBlock(
132            Bundle.getMessage("BeanNameOBlock"),
133            Bundle.getMessage("BeanNameOBlocks"),
134            OBlock.class,
135            "state",
136            () -> InstanceManager.getDefault(OBlockManager.class),
137            new CreateBean() {
138                @Override
139                public NamedBean createBean(String systemName, String userName) {
140                    return InstanceManager.getDefault(OBlockManager.class)
141                            .createNewOBlock(systemName, userName);
142                }
143            },
144            (NamedBean bean, String property) -> {
145                if (!(bean instanceof OBlock)) {
146                    throw new IllegalArgumentException("bean is not a OBlock");
147                }
148                InstanceManager.getDefault(OBlockManager.class)
149                        .deleteBean((OBlock)bean, property);
150            }),
151
152    Reporter(
153            Bundle.getMessage("BeanNameReporter"),
154            Bundle.getMessage("BeanNameReporters"),
155            Reporter.class,
156            "currentReport",
157            () -> InstanceManager.getDefault(ReporterManager.class),
158            new CreateBean() {
159                @Override
160                public NamedBean createBean(String systemName, String userName) {
161                    return InstanceManager.getDefault(ReporterManager.class)
162                            .newReporter(systemName, userName);
163                }
164            },
165            (NamedBean bean, String property) -> {
166                if (!(bean instanceof Reporter)) {
167                    throw new IllegalArgumentException("bean is not a Reporter");
168                }
169                InstanceManager.getDefault(ReporterManager.class)
170                        .deleteBean((Reporter)bean, property);
171            }),
172
173    Section(
174            Bundle.getMessage("BeanNameSection"),
175            Bundle.getMessage("BeanNameSections"),
176            Section.class,
177            "state",
178            () -> InstanceManager.getDefault(SectionManager.class),
179            null,
180            (NamedBean bean, String property) -> {
181                if (!(bean instanceof Section)) {
182                    throw new IllegalArgumentException("bean is not a Section");
183                }
184                InstanceManager.getDefault(SectionManager.class)
185                        .deleteBean((Section)bean, property);
186            }),
187
188    Sensor(
189            Bundle.getMessage("BeanNameSensor"),
190            Bundle.getMessage("BeanNameSensors"),
191            Sensor.class,
192            "KnownState",
193            () -> InstanceManager.getDefault(SensorManager.class),
194            new CreateBean() {
195                @Override
196                public NamedBean createBean(String systemName, String userName) {
197                    return InstanceManager.getDefault(SensorManager.class)
198                            .newSensor(systemName, userName);
199                }
200            },
201            (NamedBean bean, String property) -> {
202                if (!(bean instanceof Sensor)) {
203                    throw new IllegalArgumentException("bean is not a Sensor");
204                }
205                InstanceManager.getDefault(SensorManager.class)
206                        .deleteBean((Sensor)bean, property);
207            }),
208
209    SignalHead(
210            Bundle.getMessage("BeanNameSignalHead"),
211            Bundle.getMessage("BeanNameSignalHeads"),
212            SignalHead.class,
213            "Appearance",
214            () -> InstanceManager.getDefault(SignalHeadManager.class),
215            null,
216            (NamedBean bean, String property) -> {
217                if (!(bean instanceof SignalHead)) {
218                    throw new IllegalArgumentException("bean is not a SignalHead");
219                }
220                InstanceManager.getDefault(SignalHeadManager.class)
221                        .deleteBean((SignalHead)bean, property);
222            }),
223
224    SignalMast(
225            Bundle.getMessage("BeanNameSignalMast"),
226            Bundle.getMessage("BeanNameSignalMasts"),
227            SignalMast.class,
228            "Aspect",
229            () -> InstanceManager.getDefault(SignalMastManager.class),
230            null,
231            (NamedBean bean, String property) -> {
232                if (!(bean instanceof SignalMast)) {
233                    throw new IllegalArgumentException("bean is not a SignalMast");
234                }
235                InstanceManager.getDefault(SignalMastManager.class)
236                        .deleteBean((SignalMast)bean, property);
237            }),
238
239    Transit(
240            Bundle.getMessage("BeanNameTransit"),
241            Bundle.getMessage("BeanNameTransits"),
242            Transit.class,
243            "state",
244            () -> InstanceManager.getDefault(TransitManager.class),
245            null,
246            (NamedBean bean, String property) -> {
247                if (!(bean instanceof Transit)) {
248                    throw new IllegalArgumentException("bean is not a Transit");
249                }
250                InstanceManager.getDefault(TransitManager.class)
251                        .deleteBean((Transit)bean, property);
252            }),
253
254    Turnout(
255            Bundle.getMessage("BeanNameTurnout"),
256            Bundle.getMessage("BeanNameTurnouts"),
257            Turnout.class, "KnownState",
258            () -> InstanceManager.getDefault(TurnoutManager.class),
259            new CreateBean() {
260                @Override
261                public NamedBean createBean(String systemName, String userName) {
262                    return InstanceManager.getDefault(TurnoutManager.class)
263                            .newTurnout(systemName, userName);
264                }
265            },
266            (NamedBean bean, String property) -> {
267                if (!(bean instanceof Turnout)) {
268                    throw new IllegalArgumentException("bean is not a Turnout");
269                }
270                InstanceManager.getDefault(TurnoutManager.class)
271                        .deleteBean((Turnout)bean, property);
272            }),
273
274    Warrant(
275            Bundle.getMessage("BeanNameWarrant"),
276            Bundle.getMessage("BeanNameWarrants"),
277            Warrant.class, "KnownState",
278            () -> InstanceManager.getDefault(WarrantManager.class),
279            null,
280            (NamedBean bean, String property) -> {
281                if (!(bean instanceof Warrant)) {
282                    throw new IllegalArgumentException("bean is not a Warrant");
283                }
284                InstanceManager.getDefault(WarrantManager.class)
285                        .deleteBean((Warrant)bean, property);
286            });
287
288
289    private final String _name;
290    private final String _namePlural;
291    private final Class<? extends NamedBean> _clazz;
292    private final String _propertyName;
293    private final GetManager _getManager;
294    private Manager<? extends NamedBean> _manager;
295    private final CreateBean _createBean;
296    private final DeleteBean _deleteBean;
297
298    NamedBeanType(
299            String name,
300            String namePlural,
301            Class<? extends NamedBean> clazz,
302            String propertyName,
303            GetManager getManager,
304            CreateBean createBean,
305            DeleteBean deleteBean) {
306        _name = name;
307        _namePlural = namePlural;
308        _clazz = clazz;
309        _propertyName = propertyName;
310        _getManager = getManager;
311        _manager = _getManager.getManager();
312        _createBean = createBean;
313        _deleteBean = deleteBean;
314    }
315
316    @Override
317    public String toString() {
318        return _name;
319    }
320
321    public String getName(boolean plural) {
322        return plural ? _namePlural : _name;
323    }
324
325    public Class<? extends NamedBean> getClazz() {
326        return _clazz;
327    }
328
329    public String getPropertyName() {
330        return _propertyName;
331    }
332
333    public Manager<? extends NamedBean> getManager() {
334        return _manager;
335    }
336
337    public CreateBean getCreateBean() {
338        return _createBean;
339    }
340
341    public DeleteBean getDeleteBean() {
342        return _deleteBean;
343    }
344
345    // This method is used by test classes to reset this enum.
346    // Each test resets the InstanceManager so we need to reset the
347    // managers in this enum.
348    public static void reset() {
349        for (NamedBeanType type : NamedBeanType.values()) {
350            type._manager = type._getManager.getManager();
351        }
352    }
353
354    private interface GetManager {
355
356        Manager<? extends NamedBean> getManager();
357    }
358
359    public interface CreateBean {
360
361        public NamedBean createBean(String systemName, String userName);
362    }
363
364    public interface DeleteBean {
365
366        public void deleteBean(NamedBean bean, String property)
367                throws java.beans.PropertyVetoException;
368    }
369
370}