001package jmri.implementation;
002
003import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
004import java.util.List;
005import jmri.AddressedProgrammer;
006import jmri.Programmer;
007import org.jdom2.Element;
008import org.slf4j.Logger;
009import org.slf4j.LoggerFactory;
010
011/**
012 * Utility to load a specific ProgrammerFacade from an XML element.
013 *
014 * @see jmri.jmrix.AbstractProgrammerFacade
015 *
016 * @author Bob Jacobsen Copyright (C) 2013
017 */
018public class ProgrammerFacadeSelector {
019
020    /**
021     * Add facades specified in an XML decoder definition element to the front
022     * of a programmer.
023     *
024     * @param element    Contains "capability" elements that define the Facades
025     * @param programmer Programmer implementation to decorate
026     * @param allowCache Passed to facades that optionally cache
027     * @param baseProg   The original underlying programmer, less any facades
028     * @return the programmer with added facades
029     */
030    @SuppressFBWarnings(value = "BC_UNCONFIRMED_CAST",
031            justification = "cast is checked by conditional surrounding the code block")  // NOI18N
032    public static Programmer loadFacadeElements(
033            Element element, Programmer programmer, boolean allowCache, Programmer baseProg) {
034        // iterate over any facades and add them
035        List<Element> facades = element.getChildren("capability");
036        if (log.isDebugEnabled()) {
037            log.debug("Found {} capability elements", facades.size());
038        }
039        for (Element facade : facades) {
040            String fname = facade.getChild("name").getText();
041            if (log.isDebugEnabled()) {
042                log.debug("Process capability facade: {}", fname);
043            }
044
045            List<Element> parameters = facade.getChildren("parameter");
046            if (log.isDebugEnabled()) {
047                log.debug("Found {} capability parameters", facades.size());
048            }
049            for (Element parameter : parameters) {
050                String pname = parameter.getAttributeValue("name");
051                String pval = parameter.getText();
052                log.debug("Found parameter name=\"{}\", value=\"{}\" ", pname, pval);
053            }
054
055            switch (fname) {
056                case "High Access via Double Index": {
057                    String top = parameters.get(0).getText();
058                    String addrCVhigh = parameters.get(1).getText();
059                    String addrCVlow = parameters.get(2).getText();
060                    String valueCV = parameters.get(3).getText();
061                    String modulo = parameters.get(4).getText();
062                    jmri.implementation.AddressedHighCvProgrammerFacade pf
063                            = new jmri.implementation.AddressedHighCvProgrammerFacade(programmer, top, addrCVhigh, addrCVlow, valueCV, modulo);
064                    log.debug("new programmer '{}' {}", fname, pf);
065                    programmer = pf; // to go around and see if there are more
066                    break;
067                }
068                case "High Access via Partial Index": {
069                    String top = parameters.get(0).getText();
070                    String addrCV = parameters.get(1).getText();
071                    String factor = parameters.get(2).getText();
072                    String modulo = parameters.get(3).getText();
073                    jmri.implementation.OffsetHighCvProgrammerFacade pf
074                            = new jmri.implementation.OffsetHighCvProgrammerFacade(programmer, top, addrCV, factor, modulo);
075                    log.debug("new programmer '{}' {}", fname, pf);
076                    programmer = pf; // to go around and see if there are more
077                    break;
078                }
079                case "High Access via Partial Index with Reset": {
080                    String top = parameters.get(0).getText();
081                    String addrCV = parameters.get(1).getText();
082                    String factor = parameters.get(2).getText();
083                    String modulo = parameters.get(3).getText();
084                    String indicator = parameters.get(4).getText();
085                    jmri.implementation.ResettingOffsetHighCvProgrammerFacade pf
086                            = new jmri.implementation.ResettingOffsetHighCvProgrammerFacade(programmer, top, addrCV, factor, modulo, indicator);
087                    log.debug("new programmer '{}' {}", fname, pf);
088                    programmer = pf; // to go around and see if there are more
089                    break;
090                }
091                case "Indexed CV access": {
092                    String PI = parameters.get(0).getText();
093                    String SI = (parameters.size() > 1) ? parameters.get(1).getText() : null;
094                    boolean cvFirst = (parameters.size() > 2) ? (!parameters.get(2).getText().equals("false")) : true;
095                    boolean skipDupIndexWrite = (parameters.size() > 3) ? (parameters.get(3).getText().equals("false") ? false : allowCache) : allowCache; // if not present, use default
096                    jmri.implementation.MultiIndexProgrammerFacade pf
097                            = new jmri.implementation.MultiIndexProgrammerFacade(programmer, PI, SI, cvFirst, skipDupIndexWrite);
098                    log.debug("new programmer '{}' {}", fname, pf);
099                    programmer = pf; // to go around and see if there are more
100                    break;
101                }
102                case "TCS 4 CV access": {
103                    jmri.implementation.TwoIndexTcsProgrammerFacade pf
104                            = new jmri.implementation.TwoIndexTcsProgrammerFacade(programmer);
105                    log.debug("new programmer '{}' {}", fname, pf);
106                    programmer = pf; // to go around and see if there are more
107                    break;
108                }
109                case "Ops Mode Accessory Programming":
110                    if (AddressedProgrammer.class.isAssignableFrom(baseProg.getClass())) {  // create if relevant to current mode, otherwise silently ignore
111                        String addrType = "decoder";
112                        int delay = 500;
113                        for (Element x : parameters) {
114                            switch (x.getAttributeValue("name")) {
115                                case "Address Type":
116                                    addrType = x.getText();
117                                    break;
118                                case "Delay":
119                                    delay = Integer.parseInt(x.getText());
120                                    break;
121                                default:
122                                    log.error("Unknown parameter \"{}\" for \"{}\"", fname, x.getText());
123                                    break;
124                            }
125                        }
126                        log.debug("\"{}\": addrType=\"{}\", delay=\"{}\", baseProg=\"{}\"", fname, addrType, delay, baseProg);
127
128                        jmri.implementation.AccessoryOpsModeProgrammerFacade pf
129                                = new jmri.implementation.AccessoryOpsModeProgrammerFacade(programmer, addrType, delay, (AddressedProgrammer) baseProg);
130                        log.debug("new programmer '{}' {}", fname, pf);
131                        programmer = pf; // to go around and see if there are more
132                    }
133                    break;
134                case "Ops Mode Delayed Programming":
135                    if (AddressedProgrammer.class.isAssignableFrom(baseProg.getClass())) {  // create if relevant to current mode, otherwise silently ignore
136                        int delay = 500;
137                        for (Element x : parameters) {
138                            switch (x.getAttributeValue("name")) {
139                                case "Delay":
140                                    delay = Integer.parseInt(x.getText());
141                                    break;
142                                default:
143                                    log.error("Unknown parameter \"{}\" for \"{}\"", fname, x.getText());
144                                    break;
145                            }
146                        }
147                        log.debug("\"{}\": delay=\"{}\"", fname, delay);
148                        jmri.implementation.OpsModeDelayedProgrammerFacade pf
149                                = new jmri.implementation.OpsModeDelayedProgrammerFacade(programmer, delay);
150                        log.debug("new programmer '{}' {}", fname, pf);
151                        programmer = pf; // to go around and see if there are more
152                    }
153                    break;
154                default:
155                    log.error("Cannot create programmer capability named: \"{}\"", fname);
156                    break;
157            }
158        }
159
160        return programmer;
161    }
162
163    private final static Logger log = LoggerFactory.getLogger(ProgrammerFacadeSelector.class);
164}