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    Sensor(
174            Bundle.getMessage("BeanNameSensor"),
175            Bundle.getMessage("BeanNameSensors"),
176            Sensor.class,
177            "KnownState",
178            () -> InstanceManager.getDefault(SensorManager.class),
179            new CreateBean() {
180                @Override
181                public NamedBean createBean(String systemName, String userName) {
182                    return InstanceManager.getDefault(SensorManager.class)
183                            .newSensor(systemName, userName);
184                }
185            },
186            (NamedBean bean, String property) -> {
187                if (!(bean instanceof Sensor)) {
188                    throw new IllegalArgumentException("bean is not a Sensor");
189                }
190                InstanceManager.getDefault(SensorManager.class)
191                        .deleteBean((Sensor)bean, property);
192            }),
193
194    SignalHead(
195            Bundle.getMessage("BeanNameSignalHead"),
196            Bundle.getMessage("BeanNameSignalHeads"),
197            SignalHead.class,
198            "Appearance",
199            () -> InstanceManager.getDefault(SignalHeadManager.class),
200            null,
201            (NamedBean bean, String property) -> {
202                if (!(bean instanceof SignalHead)) {
203                    throw new IllegalArgumentException("bean is not a SignalHead");
204                }
205                InstanceManager.getDefault(SignalHeadManager.class)
206                        .deleteBean((SignalHead)bean, property);
207            }),
208
209    SignalMast(
210            Bundle.getMessage("BeanNameSignalMast"),
211            Bundle.getMessage("BeanNameSignalMasts"),
212            SignalMast.class,
213            "Aspect",
214            () -> InstanceManager.getDefault(SignalMastManager.class),
215            null,
216            (NamedBean bean, String property) -> {
217                if (!(bean instanceof SignalMast)) {
218                    throw new IllegalArgumentException("bean is not a SignalMast");
219                }
220                InstanceManager.getDefault(SignalMastManager.class)
221                        .deleteBean((SignalMast)bean, property);
222            }),
223
224    Turnout(
225            Bundle.getMessage("BeanNameTurnout"),
226            Bundle.getMessage("BeanNameTurnouts"),
227            Turnout.class, "KnownState",
228            () -> InstanceManager.getDefault(TurnoutManager.class),
229            new CreateBean() {
230                @Override
231                public NamedBean createBean(String systemName, String userName) {
232                    return InstanceManager.getDefault(TurnoutManager.class)
233                            .newTurnout(systemName, userName);
234                }
235            },
236            (NamedBean bean, String property) -> {
237                if (!(bean instanceof Turnout)) {
238                    throw new IllegalArgumentException("bean is not a Turnout");
239                }
240                InstanceManager.getDefault(TurnoutManager.class)
241                        .deleteBean((Turnout)bean, property);
242            }),
243
244    Warrant(
245            Bundle.getMessage("BeanNameWarrant"),
246            Bundle.getMessage("BeanNameWarrants"),
247            Warrant.class, "KnownState",
248            () -> InstanceManager.getDefault(WarrantManager.class),
249            null,
250            (NamedBean bean, String property) -> {
251                if (!(bean instanceof Warrant)) {
252                    throw new IllegalArgumentException("bean is not a Warrant");
253                }
254                InstanceManager.getDefault(WarrantManager.class)
255                        .deleteBean((Warrant)bean, property);
256            });
257
258
259    private final String _name;
260    private final String _namePlural;
261    private final Class<? extends NamedBean> _clazz;
262    private final String _propertyName;
263    private final GetManager _getManager;
264    private Manager<? extends NamedBean> _manager;
265    private final CreateBean _createBean;
266    private final DeleteBean _deleteBean;
267
268    NamedBeanType(
269            String name,
270            String namePlural,
271            Class<? extends NamedBean> clazz,
272            String propertyName,
273            GetManager getManager,
274            CreateBean createBean,
275            DeleteBean deleteBean) {
276        _name = name;
277        _namePlural = namePlural;
278        _clazz = clazz;
279        _propertyName = propertyName;
280        _getManager = getManager;
281        _manager = _getManager.getManager();
282        _createBean = createBean;
283        _deleteBean = deleteBean;
284    }
285
286    @Override
287    public String toString() {
288        return _name;
289    }
290
291    public String getName(boolean plural) {
292        return plural ? _namePlural : _name;
293    }
294
295    public Class<? extends NamedBean> getClazz() {
296        return _clazz;
297    }
298
299    public String getPropertyName() {
300        return _propertyName;
301    }
302
303    public Manager<? extends NamedBean> getManager() {
304        return _manager;
305    }
306
307    public CreateBean getCreateBean() {
308        return _createBean;
309    }
310
311    public DeleteBean getDeleteBean() {
312        return _deleteBean;
313    }
314
315    // This method is used by test classes to reset this enum.
316    // Each test resets the InstanceManager so we need to reset the
317    // managers in this enum.
318    public static void reset() {
319        for (NamedBeanType type : NamedBeanType.values()) {
320            type._manager = type._getManager.getManager();
321        }
322    }
323
324    private interface GetManager {
325
326        Manager<? extends NamedBean> getManager();
327    }
328
329    public interface CreateBean {
330
331        public NamedBean createBean(String systemName, String userName);
332    }
333
334    public interface DeleteBean {
335
336        public void deleteBean(NamedBean bean, String property)
337                throws java.beans.PropertyVetoException;
338    }
339
340}