001package jmri.jmrit.decoderdefn;
002
003import java.awt.GraphicsEnvironment;
004import java.io.File;
005import java.io.IOException;
006import java.net.URL;
007import java.util.ArrayList;
008import java.util.Arrays;
009import java.util.Collections;
010import java.util.HashMap;
011import java.util.List;
012import java.util.Set;
013import javax.annotation.Nonnull;
014import javax.swing.JComboBox;
015import javax.swing.JDialog;
016import javax.swing.JProgressBar;
017import javax.swing.JOptionPane;
018import jmri.InstanceInitializer;
019import jmri.InstanceManager;
020import jmri.implementation.AbstractInstanceInitializer;
021import jmri.jmrit.XmlFile;
022import jmri.util.FileUtil;
023import jmri.util.ThreadingUtil;
024import org.jdom2.Attribute;
025import org.jdom2.Comment;
026import org.jdom2.Document;
027import org.jdom2.Element;
028import org.jdom2.JDOMException;
029import org.jdom2.ProcessingInstruction;
030import org.openide.util.lookup.ServiceProvider;
031import org.slf4j.Logger;
032import org.slf4j.LoggerFactory;
033
034/**
035 * DecoderIndex represents the decoderIndex.xml (decoder types) and
036 * nmra_mfg_list.xml (Manufacturer ID list) files in memory.
037 * <p>
038 * This allows a program to navigate to various decoder descriptions without
039 * having to manipulate files.
040 * <p>
041 * This class doesn't provide tools for defining the index; that's done
042 * by {@link jmri.jmrit.decoderdefn.DecoderIndexCreateAction}, which
043 * rebuilds it from the decoder files.
044 * <p>
045 * Multiple DecoderIndexFile objects don't make sense, so we use an "instance"
046 * member to navigate to a single one.
047 * <p>
048 * Previous to JMRI 4.19.1, the manufacturer information was kept in the
049 * decoderIndex.xml file. Starting with that version it's in the separate
050 * nmra_mfg_list.xml file, but still written to decoderIndex.xml when
051 * one is created.
052 *
053 * @author Bob Jacobsen Copyright (C) 2001, 2019
054 * @see jmri.jmrit.decoderdefn.DecoderIndexCreateAction
055 *
056 */
057public class DecoderIndexFile extends XmlFile {
058
059    public static final String MANUFACTURER = "manufacturer";
060    public static final String MFG_ID = "mfgID";
061    public static final String DECODER_INDEX = "decoderIndex";
062    public static final String VERSION = "version";
063    public static final String LOW_VERSION_ID = "lowVersionID";
064    public static final String HIGH_VERSION_ID = "highVersionID";
065    // fill in abstract members
066    protected List<DecoderFile> decoderList = new ArrayList<>();
067
068    public int numDecoders() {
069        return decoderList.size();
070    }
071
072    int fileVersion = -1;
073
074    // map mfg ID numbers from & to mfg names
075    protected HashMap<String, String> _mfgIdFromNameHash = new HashMap<>();
076    protected HashMap<String, String> _mfgNameFromIdHash = new HashMap<>();
077
078    protected ArrayList<String> mMfgNameList = new ArrayList<>();
079
080    public List<String> getMfgNameList() {
081        return mMfgNameList;
082    }
083
084    public String mfgIdFromName(String name) {
085        return _mfgIdFromNameHash.get(name);
086    }
087
088    /**
089     *
090     * @param idNum String containing the manufacturer's NMRA
091     *      manufacturer ID number
092     * @return String containing the "friendly" name of the manufacturer
093     */
094
095    public String mfgNameFromID(String idNum) {
096        return _mfgNameFromIdHash.get(idNum);
097    }
098
099    /**
100     * Get a List of decoders matching some information.
101     *
102     * @param mfg              decoder manufacturer
103     * @param family           decoder family
104     * @param decoderMfgID     NMRA decoder manufacturer ID
105     * @param decoderVersionID decoder version ID
106     * @param decoderProductID decoder product ID
107     * @param model            decoder model
108     * @return a list, possibly empty, of matching decoders
109     */
110    @Nonnull
111    public List<DecoderFile> matchingDecoderList(String mfg, String family,
112            String decoderMfgID, String decoderVersionID, String decoderProductID,
113            String model) {
114        return (matchingDecoderList(mfg, family, decoderMfgID, decoderVersionID, decoderProductID, model, null, null, null));
115    }
116
117    /**
118     * Get a List of decoders matching some information.
119     *
120     * @param mfg              decoder manufacturer
121     * @param family           decoder family
122     * @param decoderMfgID     NMRA decoder manufacturer ID
123     * @param decoderVersionID decoder version ID
124     * @param decoderProductID decoder product ID
125     * @param model            decoder model
126     * @param developerID      developer ID number
127     * @param manufacturerID   manufacturerID number
128     * @param productID        productID number
129     * @return a list, possibly empty, of matching decoders
130     */
131    @Nonnull
132    public List<DecoderFile> matchingDecoderList(String mfg, String family,
133            String decoderMfgID, String decoderVersionID,
134            String decoderProductID, String model, String developerID, String manufacturerID, String productID) {
135        List<DecoderFile> l = new ArrayList<>();
136        for (int i = 0; i < numDecoders(); i++) {
137            if (checkEntry(i, mfg, family, decoderMfgID, decoderVersionID, decoderProductID, model, developerID, manufacturerID, productID)) {
138                l.add(decoderList.get(i));
139            }
140        }
141        return l;
142    }
143
144    /**
145     * Get a JComboBox representing the choices that match some information.
146     *
147     * @param mfg              decoder manufacturer
148     * @param family           decoder family
149     * @param decoderMfgID     NMRA decoder manufacturer ID
150     * @param decoderVersionID decoder version ID
151     * @param decoderProductID decoder product ID
152     * @param model            decoder model
153     * @return a combo box populated with matching decoders
154     */
155    public JComboBox<String> matchingComboBox(String mfg, String family, String decoderMfgID, String decoderVersionID, String decoderProductID, String model) {
156        List<DecoderFile> l = matchingDecoderList(mfg, family, decoderMfgID, decoderVersionID, decoderProductID, model);
157        return jComboBoxFromList(l);
158    }
159
160    /**
161     * Get a JComboBox made with the titles from a list of DecoderFile entries.
162     *
163     * @param l list of decoders
164     * @return a combo box populated with the list
165     */
166    public static JComboBox<String> jComboBoxFromList(List<DecoderFile> l) {
167        return new JComboBox<>(jComboBoxModelFromList(l));
168    }
169
170    /**
171     * Get a new ComboBoxModel made with the titles from a list of DecoderFile
172     * entries.
173     *
174     * @param l list of decoders
175     * @return a combo box model populated with the list
176     */
177    public static javax.swing.ComboBoxModel<String> jComboBoxModelFromList(List<DecoderFile> l) {
178        javax.swing.DefaultComboBoxModel<String> b = new javax.swing.DefaultComboBoxModel<>();
179        for (int i = 0; i < l.size(); i++) {
180            DecoderFile r = l.get(i);
181            b.addElement(r.titleString());
182        }
183        return b;
184    }
185
186    /**
187     * Get a DecoderFile from a "title" string, typically a selection in a
188     * matching ComboBox.
189     *
190     * @param title the decoder title
191     * @return the decoder file
192     */
193    public DecoderFile fileFromTitle(String title) {
194        for (int i = numDecoders() - 1; i >= 0; i--) {
195            DecoderFile r = decoderList.get(i);
196            if (r.titleString().equals(title)) {
197                return r;
198            }
199        }
200        return null;
201    }
202
203    /**
204     * Check if an entry consistent with specific properties. A null String
205     * entry always matches. Strings are used for convenience in GUI building.
206     * Don't bother asking about the model number...
207     *
208     * @param i                index of entry
209     * @param mfgName          decoder manufacturer
210     * @param family           decoder family
211     * @param mfgID            NMRA decoder manufacturer ID
212     * @param decoderVersionID decoder version ID
213     * @param decoderProductID decoder product ID
214     * @param model            decoder model
215     * @param developerID      developer ID number
216     * @param manufacturerID   manufacturer ID number
217     * @param productID        product ID number
218     * @return true if entry at i matches the other parameters; false otherwise
219     */
220    public boolean checkEntry(int i, String mfgName, String family, String mfgID,
221            String decoderVersionID, String decoderProductID, String model,
222            String developerID, String manufacturerID, String productID) {
223        DecoderFile r = decoderList.get(i);
224        if (mfgName != null && !mfgName.equals(r.getMfg())) {
225            return false;
226        }
227        if (family != null && !family.equals(r.getFamily())) {
228            return false;
229        }
230        if (mfgID != null && !mfgID.equals(r.getMfgID())) {
231            return false;
232        }
233        if (model != null && !model.equals(r.getModel())) {
234            return false;
235        }
236        // check version ID - no match if a range specified and out of range
237        if (decoderVersionID != null) {
238            int versionID = Integer.parseInt(decoderVersionID);
239            if (!r.isVersion(versionID)) {
240                return false;
241            }
242        }
243
244        if (decoderProductID != null && !checkInCommaDelimString(decoderProductID, r.getProductID())) {
245            return false;
246        }
247
248        if (developerID != null) {
249            // must have a developerID value that matches to consider this entry a match
250            if (!developerID.equals(r.getDeveloperID())) {
251                // didn't match the getDeveloperID() value, so check the model developerID value
252                if (r.getModelElement().getAttribute("developerID") == null) {
253                    // no model developerID value, so not a match!
254                    return false;
255                }
256                if (!("," + r.getModelElement().getAttribute("developerID").getValue() + ",").contains("," + developerID + ",")) {
257                        return false;
258                }
259            }
260            log.debug("developerID match");
261        }
262
263
264        if (manufacturerID != null) {
265            log.debug("checking manufactureriD {}, mfgID {}, modelElement[manufacturerID] {}",
266                    manufacturerID, r._mfgID, r.getModelElement().getAttribute("manufacturerID"));
267            // must have a manufacturerID value that matches to consider this entry a match
268
269            if ((r._mfgID == null) || (manufacturerID.compareTo(r._mfgID) != 0)) {
270                // ID number from manufacturer name isn't identical; try another way
271                if (!manufacturerID.equals(r.getManufacturerID())) {
272                    // no match to the manufacturerID attribute at the (family?) level, so try model level
273                    Attribute a = r.getModelElement().getAttribute("manufacturerID");
274                    if ((a == null) || (a.getValue() == null) ||
275                            (manufacturerID.compareTo(a.getValue())!=0)) {
276                            // no model manufacturerID value, or model manufacturerID
277                            // value does not match so this decoder is not a match!
278                            return false;
279                    }
280                }
281            }
282            log.debug("manufacturerID match");
283        }
284
285        if (productID != null) {
286            // must have a productID value that matches to consider this entry a match
287            if (!productID.equals(r.getProductID())) {
288                // didn't match the getProductID() value, so check the model productID value
289                if (r.getModelElement().getAttribute("productID") == null) {
290                    // no model productID value, so not a match!
291                    return false;
292                }
293                if (!("," + r.getModelElement().getAttribute("productID").getValue() + ",").contains("," + productID + ",")) {
294                        return false;
295                }
296            }
297            log.debug("productID match");
298        }
299        return true;
300    }
301
302    /**
303     * Replace the managed instance with a new instance.
304     */
305    public static synchronized void resetInstance() {
306        InstanceManager.getDefault().clear(DecoderIndexFile.class);
307    }
308
309    /**
310     * Check whether the user's version of the decoder index file needs to be
311     * updated; if it does, then forces the update.
312     *
313     * @return true is the index should be reloaded because it was updated
314     * @throws org.jdom2.JDOMException if unable to parse decoder index
315     * @throws java.io.IOException     if unable to read decoder index
316     */
317    public static boolean updateIndexIfNeeded() throws org.jdom2.JDOMException, java.io.IOException {
318        switch (FileUtil.findFiles(defaultDecoderIndexFilename(), ".").size()) {
319            case 0:
320                log.debug("creating decoder index");
321                forceCreationOfNewIndex();
322                return true; // no index exists, so create one
323            case 1:
324                return false; // only one index, so nothing to compare
325            default:
326                // multiple indexes, so continue with more specific checks
327                break;
328        }
329
330        // get version from master index; if not found, give up
331        String masterVersion = null;
332        DecoderIndexFile masterXmlFile = new DecoderIndexFile();
333        URL masterFile = FileUtil.findURL("xml/" + defaultDecoderIndexFilename(), FileUtil.Location.INSTALLED);
334        if (masterFile == null) {
335            return false;
336        }
337        log.debug("checking for master file at {}", masterFile);
338        Element masterRoot = masterXmlFile.rootFromURL(masterFile);
339        if (masterRoot.getChild(DECODER_INDEX) != null) {
340            if (masterRoot.getChild(DECODER_INDEX).getAttribute(VERSION) != null) {
341                masterVersion = masterRoot.getChild(DECODER_INDEX).getAttribute(VERSION).getValue();
342            }
343            log.debug("master version found, is {}", masterVersion);
344        } else {
345            return false;
346        }
347
348        // get from user index.  Unless they are equal, force an update.
349        // note we find this file via the search path; if not exists, so that
350        // the master is found, we still do the right thing (nothing).
351        String userVersion = null;
352        DecoderIndexFile userXmlFile = new DecoderIndexFile();
353        log.debug("checking for user file at {}", defaultDecoderIndexFilename());
354        Element userRoot = userXmlFile.rootFromName(defaultDecoderIndexFilename());
355        if (userRoot.getChild(DECODER_INDEX) != null) {
356            if (userRoot.getChild(DECODER_INDEX).getAttribute(VERSION) != null) {
357                userVersion = userRoot.getChild(DECODER_INDEX).getAttribute(VERSION).getValue();
358            }
359            log.debug("user version found, is {}", userVersion);
360        }
361        if (masterVersion != null && masterVersion.equals(userVersion)) {
362            return false;
363        }
364
365        // force the update, with the version number located earlier is available
366        log.debug("forcing update of decoder index due to {} and {}", masterVersion, userVersion);
367        forceCreationOfNewIndex();
368        // and force it to be used
369        return true;
370    }
371
372    /**
373     * Force creation of a new user index without incrementing version
374     */
375    public static void forceCreationOfNewIndex() {
376        forceCreationOfNewIndex(false);
377    }
378
379    /**
380     * Force creation of a new user index.
381     *
382     * @param increment true to increment the version of the decoder index
383     */
384    public static void forceCreationOfNewIndex(boolean increment) {
385        log.info("update decoder index");
386        // make sure we're using only the default manufacturer info
387        // to keep from propagating wrong, old stuff
388        File oldfile = new File(FileUtil.getUserFilesPath() + DECODER_INDEX_FILE_NAME);
389        if (oldfile.exists()) {
390            log.debug("remove existing user decoderIndex.xml file");
391            if (!oldfile.delete()) // delete file, check for success
392            {
393                log.error("Failed to delete old index file");
394            }
395            // force read from distributed file on next access
396            resetInstance();
397        }
398
399        // create an array of file names from decoders dir in preferences, count entries
400        ArrayList<String> al = new ArrayList<>();
401        FileUtil.createDirectory(FileUtil.getUserFilesPath() + DecoderFile.fileLocation);
402        File fp = new File(FileUtil.getUserFilesPath() + DecoderFile.fileLocation);
403
404        if (fp.exists()) {
405            String[] list = fp.list();
406            if (list !=null) {
407                for (String sp : list) {
408                    if (sp.endsWith(".xml") || sp.endsWith(".XML")) {
409                        al.add(sp);
410                    }
411                }
412            }
413        } else {
414            log.debug("{}decoders was missing, though tried to create it", FileUtil.getUserFilesPath());
415        }
416        // create an array of file names from xml/decoders, count entries
417        String[] fileList = (new File(XmlFile.xmlDir() + DecoderFile.fileLocation)).list();
418        if (fileList != null) {
419            for (String sx : fileList ) {
420                if (sx.endsWith(".xml") || sx.endsWith(".XML")) {
421                    // Valid name.  Does it exist in preferences xml/decoders?
422                    if (!al.contains(sx)) {
423                        // no, include it!
424                        al.add(sx);
425                    }
426                }
427            }
428        } else {
429            log.error("Could not access decoder definition directory {}{}", XmlFile.xmlDir(), DecoderFile.fileLocation);
430        }
431        // copy the decoder entries to the final array
432        String[] sbox = al.toArray(new String[al.size()]);
433
434        //the resulting array is now sorted on file-name to make it easier
435        // for humans to read
436        Arrays.sort(sbox);
437
438        // create a new decoderIndex
439        DecoderIndexFile index = new DecoderIndexFile();
440
441        // For user operations the existing version is used, so that a new master file
442        // with a larger one will force an update
443        if (increment) {
444            index.fileVersion = InstanceManager.getDefault(DecoderIndexFile.class).fileVersion + 2;
445        } else {
446            index.fileVersion = InstanceManager.getDefault(DecoderIndexFile.class).fileVersion;
447        }
448
449        // If not many entries, or headless, just recreate index without updating the UI
450        // Also block if not on the GUI (event dispatch) thread
451        if (sbox.length < 30 || GraphicsEnvironment.isHeadless() || !ThreadingUtil.isGUIThread()) {
452            try {
453                index.writeFile(DECODER_INDEX_FILE_NAME,
454                            InstanceManager.getDefault(DecoderIndexFile.class), sbox, null, null);
455            } catch (java.io.IOException ex) {
456                log.error("Error writing new decoder index file: {}", ex.getMessage());
457            }
458            return;
459        }
460
461        // Create a dialog with a progress bar and a cancel button
462        String message = Bundle.getMessage("DecoderProgressMessage", "..."); // NOI18N
463        String title = Bundle.getMessage("DecoderProgressMessage", "");
464        String cancel = Bundle.getMessage("ButtonCancel"); // NOI18N
465        // HACK: add long blank space to message to make dialog wider.
466        JOptionPane pane = new JOptionPane(message + "                            \t",
467                JOptionPane.PLAIN_MESSAGE,
468                JOptionPane.OK_CANCEL_OPTION,
469                null,
470                new String[]{cancel});
471        JProgressBar pb = new JProgressBar(0, sbox.length);
472        pb.setValue(0);
473        pane.add(pb, 1);
474        JDialog dialog = pane.createDialog(null, title);
475
476        ThreadingUtil.newThread(() -> {
477            try {
478                index.writeFile(DECODER_INDEX_FILE_NAME,
479                            InstanceManager.getDefault(DecoderIndexFile.class), sbox, pane, pb);
480            // catch all exceptions, so progress dialog will close
481            } catch (Exception e) {
482                // TODO: show message in progress dialog?
483                log.error("Error writing new decoder index file: {}", e.getMessage());
484            }
485            dialog.setVisible(false);
486            dialog.dispose();
487        }, "decoderIndexer").start();
488
489        // improve visibility if any always on top frames present
490        dialog.setAlwaysOnTop(true);
491        dialog.toFront();
492        // this will block until the thread completes, either by
493        // finishing or by being cancelled
494        dialog.setVisible(true);
495    }
496
497    /**
498     * Read the contents of a decoderIndex XML file into this object. Note that
499     * this does not clear any existing entries; reset the instance to do that.
500     *
501     * @param name the name of the decoder index file
502     * @throws org.jdom2.JDOMException if unable to parse to decoder index file
503     * @throws java.io.IOException     if unable to read decoder index file
504     */
505    void readFile(String name) throws org.jdom2.JDOMException, java.io.IOException {
506        log.debug("readFile {}", name);
507
508        // read file, find root
509        Element root = rootFromName(name);
510
511        // decode type, invoke proper processing routine if a decoder file
512        if (root.getChild(DECODER_INDEX) != null) {
513            if (root.getChild(DECODER_INDEX).getAttribute(VERSION) != null) {
514                fileVersion = Integer.parseInt(root.getChild(DECODER_INDEX)
515                        .getAttribute(VERSION)
516                        .getValue()
517                );
518            }
519            log.debug("found fileVersion of {}", fileVersion);
520            readMfgSection();
521            readFamilySection(root.getChild(DECODER_INDEX));
522        } else {
523            log.error("Unrecognized decoderIndex file contents in file: {}", name);
524        }
525    }
526
527    void readMfgSection() throws org.jdom2.JDOMException, java.io.IOException {
528        // always reads the NMRA manufacturer file distributed with JMRI
529        Element mfgList = rootFromName("nmra_mfg_list.xml");
530
531        if (mfgList != null) {
532
533            Attribute a;
534            a = mfgList.getAttribute("nmraListDate");
535            if (a != null) {
536                nmraListDate = a.getValue();
537            }
538            a = mfgList.getAttribute("updated");
539            if (a != null) {
540                updated = a.getValue();
541            }
542            a = mfgList.getAttribute("lastadd");
543            if (a != null) {
544                lastAdd = a.getValue();
545            }
546
547            List<Element> l = mfgList.getChildren(MANUFACTURER);
548            if (log.isDebugEnabled()) {
549                log.debug("readMfgSection sees {} children",l.size());
550            }
551            for (int i = 0; i < l.size(); i++) {
552                // handle each entry
553                Element el = l.get(i);
554                String mfg = el.getAttribute("mfg").getValue();
555                mMfgNameList.add(mfg);
556                Attribute attr = el.getAttribute(MFG_ID);
557                if (attr != null) {
558                    _mfgIdFromNameHash.put(mfg, attr.getValue());
559                    _mfgNameFromIdHash.put(attr.getValue(), mfg);
560                }
561            }
562        } else {
563            log.debug("no mfgList found");
564        }
565    }
566
567    void readFamilySection(Element decoderIndex) {
568        Element familyList = decoderIndex.getChild("familyList");
569        if (familyList != null) {
570
571            List<Element> l = familyList.getChildren("family");
572            log.trace("readFamilySection sees {} children", l.size());
573            for (int i = 0; i < l.size(); i++) {
574                // handle each entry
575                Element el = l.get(i);
576                readFamily(el);
577            }
578        } else {
579            log.debug("no familyList found in decoderIndexFile");
580        }
581    }
582
583    void readFamily(Element family) {
584        Attribute attr;
585        String filename = family.getAttribute("file").getValue();
586        String parentLowVersID = ((attr = family.getAttribute(LOW_VERSION_ID)) != null ? attr.getValue() : null);
587        String parentHighVersID = ((attr = family.getAttribute(HIGH_VERSION_ID)) != null ? attr.getValue() : null);
588        String ParentReplacementFamilyName = ((attr = family.getAttribute("replacementFamily")) != null ? attr.getValue() : null);
589        String familyName = ((attr = family.getAttribute("name")) != null ? attr.getValue() : null);
590        String mfg = ((attr = family.getAttribute("mfg")) != null ? attr.getValue() : null);
591        String developerID = ((attr = family.getAttribute("developerID")) != null ? attr.getValue() : null);
592        String manufacturerID = ((attr = family.getAttribute("manufacturerID")) != null ? attr.getValue() : null);
593        String productID = ((attr = family.getAttribute("productID")) != null ? attr.getValue() : null);
594        String mfgID = null;
595        if (mfg != null) {
596            mfgID = mfgIdFromName(mfg);
597        } else {
598            log.error("Did not find required mfg attribute, may not find proper manufacturer");
599        }
600
601        List<Element> l = family.getChildren("model");
602        log.trace("readFamily sees {} children", l.size());
603        Element modelElement;
604        if (l.isEmpty()) {
605            log.error("Did not find at least one model in the {} family", familyName);
606            modelElement = null;
607        } else {
608            modelElement = l.get(0);
609        }
610
611        // Record the family as a specific model, which allows you to select the
612        // family as a possible thing to program
613        DecoderFile vFamilyDecoderFile
614                = new DecoderFile(mfg, mfgID, familyName,
615                        parentLowVersID, parentHighVersID,
616                        familyName,
617                        filename,
618                        (developerID != null) ? developerID : "-1",
619                        (manufacturerID != null) ? manufacturerID : "-1",
620                        (productID != null) ? productID : "-1",
621                        -1, -1, modelElement,
622                        ParentReplacementFamilyName, ParentReplacementFamilyName); // numFns, numOuts, XML element equal
623        // to the first decoder
624        decoderList.add(vFamilyDecoderFile);
625
626        // record each of the decoders
627        for (int i = 0; i < l.size(); i++) {
628            // handle each entry by creating a DecoderFile object containing all it knows
629            Element decoder = l.get(i);
630            String loVersID = ((attr = decoder.getAttribute(LOW_VERSION_ID)) != null ? attr.getValue() : parentLowVersID);
631            String hiVersID = ((attr = decoder.getAttribute(HIGH_VERSION_ID)) != null ? attr.getValue() : parentHighVersID);
632            String replacementModelName = ((attr = decoder.getAttribute("replacementModel")) != null ? attr.getValue() : null);
633            String replacementFamilyName = ((attr = decoder.getAttribute("replacementFamily")) != null ? attr.getValue() : ParentReplacementFamilyName);
634            int numFns = ((attr = decoder.getAttribute("numFns")) != null ? Integer.parseInt(attr.getValue()) : -1);
635            int numOuts = ((attr = decoder.getAttribute("numOuts")) != null ? Integer.parseInt(attr.getValue()) : -1);
636            String devId = ((attr = decoder.getAttribute("developerID")) != null ? attr.getValue() : "-1");
637            String manufId = ((attr = decoder.getAttribute("manufacturerID")) != null ? attr.getValue() : "-1");
638            String prodId = ((attr = decoder.getAttribute("productID")) != null ? attr.getValue() : "-1");
639            DecoderFile df = new DecoderFile(mfg, mfgID,
640                    ((attr = decoder.getAttribute("model")) != null ? attr.getValue() : null),
641                    loVersID, hiVersID, familyName, filename, devId, manufId, prodId, numFns, numOuts, decoder,
642                    replacementModelName, replacementFamilyName);
643            // and store it
644            decoderList.add(df);
645            // if there are additional version numbers defined, handle them too
646            List<Element> vcodes = decoder.getChildren("versionCV");
647            for (int j = 0; j < vcodes.size(); j++) {
648                // for each versionCV element
649                Element vcv = vcodes.get(j);
650                String vLoVersID = ((attr = vcv.getAttribute(LOW_VERSION_ID)) != null ? attr.getValue() : loVersID);
651                String vHiVersID = ((attr = vcv.getAttribute(HIGH_VERSION_ID)) != null ? attr.getValue() : hiVersID);
652                df.setVersionRange(vLoVersID, vHiVersID);
653            }
654        }
655    }
656
657    /**
658     * Is target string in comma-delimited string
659     *
660     * Example:
661     *      findString = "47"
662     *      inString = "1,4,53,97"
663     *      return value is 'false'
664     *
665     * Example:
666     *      findString = "47"
667     *      inString = "1,31,47,51"
668     *      return value is 'true'
669     *
670     * Example:
671     *      findString = "47"
672     *      inString = "47"
673     *      return value is true
674     *
675     * @param findString string to find
676     * @param inString comma-delimited string of sub-strings
677     * @return true if target string is found as sub-string within comma-
678     *      delimited string
679     */
680    public boolean checkInCommaDelimString(String findString, String inString) {
681        String bracketedFindString = ","+findString+",";
682        String bracketedInString = ","+inString+",";
683        return bracketedInString.contains(bracketedFindString);
684    }
685
686    /**
687     * Build and write the decoder index file, based on a set of decoder files.
688     *
689     * This creates the full DOM object for the decoder index based on reading the
690     * supplied decoder xml files. It then saves the decoder index out to a new file.
691     *
692     * @param name name of the new index file
693     * @param oldIndex old decoder index file
694     * @param files array of files to read for new index
695     * @param pane optional JOptionPane to check for cancellation
696     * @param pb optional JProgressBar to update during operations
697     * @throws java.io.IOException for errors writing the decoder index file
698     */
699    public void writeFile(String name, DecoderIndexFile oldIndex,
700                          String[] files, JOptionPane pane, JProgressBar pb) throws java.io.IOException {
701        if (log.isDebugEnabled()) {
702            log.debug("writeFile {}",name);
703        }
704
705        // This is taken in large part from "Java and XML" page 368
706        File file = new File(FileUtil.getUserFilesPath() + name);
707
708        // create root element and document
709        Element root = new Element("decoderIndex-config");
710        root.setAttribute("noNamespaceSchemaLocation",
711                "http://jmri.org/xml/schema/decoder-4-15-2.xsd",
712                org.jdom2.Namespace.getNamespace("xsi",
713                        "http://www.w3.org/2001/XMLSchema-instance"));
714
715        Document doc = newDocument(root);
716
717        // add XSLT processing instruction
718        // <?xml-stylesheet type="text/xsl" href="XSLT/DecoderID.xsl"?>
719        java.util.Map<String, String> m = new java.util.HashMap<>();
720        m.put("type", "text/xsl");
721        m.put("href", xsltLocation + "DecoderID.xsl");
722        ProcessingInstruction p = new ProcessingInstruction("xml-stylesheet", m);
723        doc.addContent(0, p);
724
725        // add top-level elements
726        Element index;
727        root.addContent(index = new Element(DECODER_INDEX));
728        index.setAttribute(VERSION, Integer.toString(fileVersion));
729        log.debug("version written to file as {}", fileVersion);
730
731        // add mfg list from existing DecoderIndexFile item
732        Element mfgList = new Element("mfgList");
733        // copy dates from original mfgList element
734        if (oldIndex.nmraListDate != null) {
735            mfgList.setAttribute("nmraListDate", oldIndex.nmraListDate);
736        }
737        if (oldIndex.updated != null) {
738            mfgList.setAttribute("updated", oldIndex.updated);
739        }
740        if (oldIndex.lastAdd != null) {
741            mfgList.setAttribute("lastadd", oldIndex.lastAdd);
742        }
743
744        // We treat "NMRA" special...
745        Element mfg = new Element(MANUFACTURER);
746        mfg.setAttribute("mfg", "NMRA");
747        mfg.setAttribute(MFG_ID, "999");
748        mfgList.addContent(mfg);
749        // start working on the rest of the entries
750        List<String> keys = new ArrayList<>(oldIndex._mfgIdFromNameHash.keySet());
751        Collections.sort(keys);
752        for (Object item : keys) {
753            String mfgName = (String) item;
754            if (!mfgName.equals("NMRA")) {
755                mfg = new Element(MANUFACTURER);
756                mfg.setAttribute("mfg", mfgName);
757                mfg.setAttribute(MFG_ID, oldIndex._mfgIdFromNameHash.get(mfgName));
758                mfgList.addContent(mfg);
759            }
760        }
761
762        // add family list by scanning files
763        Element familyList = new Element("familyList");
764        int fileNum = 0;
765        for (String fileName : files) {
766            // update progress monitor, if passed in
767            if (pb != null) {
768                pb.setValue(fileNum++);
769            }
770            if (pane != null && pane.getValue() != JOptionPane.UNINITIALIZED_VALUE) {
771                log.info("Decoder index recreation cancelled");
772                return;
773            }
774            DecoderFile d = new DecoderFile();
775            try {
776                // get <family> element and add the file name
777                Element droot = d.rootFromName(DecoderFile.fileLocation + fileName);
778                Element family = droot.getChild("decoder").getChild("family").clone();
779                family.setAttribute("file", fileName);
780
781                // drop the decoder implementation content
782                    // comment is kept so it displays
783                // don't remove "outputs" due to use by ESU function map pane
784                // family.removeChildren("output");
785                // family.removeChildren("functionlabels");
786
787                // and drop content of model elements
788                for (Element element : family.getChildren()) { // model elements
789                    element.removeAttribute("maxInputVolts");
790                    element.removeAttribute("maxMotorCurrent");
791                    element.removeAttribute("maxTotalCurrent");
792                    element.removeAttribute("formFactor");
793                    element.removeAttribute("connector");
794                    // comment is kept so it displays
795                    element.removeAttribute("nmraWarrant");
796                    element.removeAttribute("nmraWarrantStart");
797
798                    // element.removeContent();
799                    element.removeChildren("size");
800
801                    //element.removeChildren("functionlabels");
802
803                    // don't remove "output" due to use by ESU function map pane
804                    for (Element output : element.getChildren()) {
805                        output.removeAttribute("connection");
806                        output.removeAttribute("maxcurrent");
807                        output.removeChildren("label");
808                    }
809                }
810
811                // and store to output
812                familyList.addContent(family);
813            } catch (org.jdom2.JDOMException exj) {
814                log.error("could not parse {}: {}", fileName, exj.getMessage());
815            } catch (java.io.FileNotFoundException exj) {
816                log.error("could not read {}: {}", fileName, exj.getMessage());
817            } catch (IOException exj) {
818                log.error("other exception while dealing with {}: {}", fileName, exj.getMessage());
819            } catch (Exception exq) {
820                log.error("exception reading {}", fileName, exq);
821                throw exq;
822            }
823        }
824
825        index.addContent(new Comment("The manufacturer list is from the nmra_mfg_list.xml file"));
826        index.addContent(mfgList);
827        index.addContent(familyList);
828
829        log.debug("Writing decoderIndex");
830        writeXML(file, doc);
831
832        // force a read of the new file next time
833        resetInstance();
834    }
835
836    String nmraListDate = null;
837    String updated = null;
838    String lastAdd = null;
839
840    /**
841     * Get the filename for the default decoder index file, including location.
842     * This is here to allow easy override in tests.
843     *
844     * @return the complete path to the decoder index
845     */
846    protected static String defaultDecoderIndexFilename() {
847        return DECODER_INDEX_FILE_NAME;
848    }
849
850    protected static final String DECODER_INDEX_FILE_NAME = "decoderIndex.xml";
851    private static final Logger log = LoggerFactory.getLogger(DecoderIndexFile.class);
852
853    @ServiceProvider(service = InstanceInitializer.class)
854    public static class Initializer extends AbstractInstanceInitializer {
855
856        @Override
857        @Nonnull
858        public <T> Object getDefault(Class<T> type) {
859            if (type.equals(DecoderIndexFile.class)) {
860                // create and load
861                DecoderIndexFile instance = new DecoderIndexFile();
862                log.debug("DecoderIndexFile creating instance");
863                try {
864                    instance.readFile(defaultDecoderIndexFilename());
865                } catch (IOException | JDOMException e) {
866                    log.error("Exception during decoder index reading: ", e);
867                }
868                // see if needs to be updated
869                try {
870                    if (updateIndexIfNeeded()) {
871                        try {
872                            instance = new DecoderIndexFile();
873                            instance.readFile(defaultDecoderIndexFilename());
874                        } catch (IOException | JDOMException e) {
875                            log.error("Exception during decoder index reload: ", e);
876                        }
877                    }
878                } catch (IOException | JDOMException e) {
879                    log.error("Exception during decoder index update: ", e);
880                }
881                log.debug("DecoderIndexFile returns instance {}", instance);
882                return instance;
883            }
884            return super.getDefault(type);
885        }
886
887        @Override
888        @Nonnull
889        public Set<Class<?>> getInitalizes() {
890            Set<Class<?>> set = super.getInitalizes();
891            set.add(DecoderIndexFile.class);
892            return set;
893        }
894    }
895
896}