source: tmcsimulator/trunk/src/tmcsim/client/CADCommandParser.java @ 2

Revision 2, 16.3 KB checked in by jdalbey, 10 years ago (diff)

Initial Import of project files
Line 
1package tmcsim.client;
2
3import java.util.NoSuchElementException;
4import java.util.StringTokenizer;
5import java.util.Vector;
6
7import org.w3c.dom.Document;
8import org.w3c.dom.Element;
9
10import tmcsim.common.CADProtocol.CAD_COMMANDS;
11import tmcsim.common.CADProtocol.CAD_FIELD_CODES;
12import tmcsim.common.CADProtocol.DATA_TAGS;
13
14
15/**
16 * CADCommandParser is used to parse user input from the CAD command line.
17 * The text is parsed for specific CAD command tokens and Field Codes
18 * as specified by the offical CAD syntax.  The parseCommand() method
19 * is used to parse a command line into the XML command Element that
20 * will be sent to the CAD Simulator. 
21 * TODO Where is this specified???
22 *
23 * @author Matthew Cechini
24 * @version
25 */
26public class CADCommandParser {
27   
28    /**
29     * Inner class used in parsing CAD Command Lines.
30     * @author Matthew
31     */
32    private class CommandItem {
33       
34        /** Field Code Mnemonic. */
35        public String mnemonic;
36
37        /** Associated data. */
38        public String value;       
39       
40        public CommandItem(String m, String v) {
41            mnemonic = m;
42            value    = v;
43        }
44    }
45   
46    /**
47     * This method parses the parameter command line for CAD commands.  The
48     * command text is tokenized by the '.' character, which is a delimiter
49     * for CAD commands.  The first parsed token specifies which CAD
50     * command is being performed.  If the token matches a valid CAD command,
51     * the remaining command line is parsed for other '.' delimeted information
52     * that accompanies that command.  <br> 
53     * As the command line is parsed, XML Elements are added to the root
54     * parameter Element to create a command message that will be sent to
55     * the CAD Simulator.  The individual XML schemas are viewable ????
56     * If the command line is not properly formed, an Exception is thrown.
57     * CAD Command syntax is viewable ????
58     * TODO Where are they available??? 
59     *
60     *
61     * The following table specifies the valid CAD command tokens, their
62     * associated CAD Command, the additional information, and error states.
63     *
64     *<table cellpadding="2" cellspacing="2" border="1"
65     * style="text-align: left; width: 250px;">
66     *  <tbody>
67     *    <tr>
68     *      <th>CAD Command Token</th>
69     *      <th>CAD Command</th>
70     *      <th>Additional Information</th>
71     *      <th>Possible Errors</th>
72     *    </tr>
73     *    <tr>
74     *      <td>IB</td>
75     *      <td>Incident Board</td>
76     *      <td>None</td>
77     *      <td>None</td>
78     *    </tr>
79     *    <tr>
80     *      <td>II</td>
81     *      <td>Incident Inquiry</td>
82     *      <td>Numerical log number</td>
83     *      <td>Log number contains invalid characters.</td>
84     *    </tr>
85     *    <tr>
86     *      <td>SA</td>
87     *      <td>Incident Summary By Area</td>
88     *      <td>None</td>
89     *      <td>None</td>
90     *    </tr>
91     *    <tr>
92     *      <td>UI</td>
93     *      <td>Incident Update</td>
94     *      <td>1) Numerical log number (optional)<br>
95     *          2) CAD Field Codes with associated data </td>
96     *      <td>Missing Field Codes.</td>
97     *    </tr>
98     *    <tr>
99     *      <td>TO</td>
100     *      <td>Routed Mssage</td>
101     *      <td>1) Recipient CAD Position Numbers or Mnemonics<br>
102     *          2) Message text </td>
103     *      <td>1) Missing Recipients <br>
104     *          2) Missing Message Field Code</td>
105     *    </tr>
106     *    <tr>
107     *      <td>OF</td>
108     *      <td>Log Terminal Off</td>
109     *      <td>None</td>
110     *      <td>None</td>
111     *    </tr>
112     *  </tbody>
113     *</table>
114     *
115     *
116     * @param currElem Document Element to add command tags to.
117     * @param commandText Command line text to parse.
118     * @throws Exception
119     */
120    public void parseCommand(Element currElem, String commandText) throws Exception {
121                       
122        StringTokenizer tokenizer = new StringTokenizer(commandText, ".");   
123        String          token;
124       
125        Document theDoc  = currElem.getOwnerDocument();
126        Element  cmdElem = null;
127                     
128        if(tokenizer.countTokens() >= 1 && commandText.indexOf(".") != -1) {
129            token = tokenizer.nextToken(); 
130                 
131            //INCIDENT_BOARD Request
132            if(token.equals(CAD_COMMANDS.INCIDENT_BOARD.mnemonic)) {
133                cmdElem = theDoc.createElement(CAD_COMMANDS.INCIDENT_BOARD.fullName);       
134                currElem.appendChild(cmdElem);
135            }
136            //INCIDENT_INQUIRY Request
137            else if(token.equals(CAD_COMMANDS.INCIDENT_INQUIRY.mnemonic)) { 
138                try {
139                    Integer logNumber = Integer.valueOf(tokenizer.nextToken().trim());
140                   
141                    cmdElem = theDoc.createElement(CAD_COMMANDS.INCIDENT_INQUIRY.fullName);
142                    cmdElem.appendChild(theDoc.createTextNode(logNumber.toString()));       
143                    currElem.appendChild(cmdElem);
144                } catch (Exception e) {
145                    //catch NumberFormatException
146                    throw new Exception();
147                }
148            }
149            //INCIDENT_SUMMARY Request
150            else if(token.equals(CAD_COMMANDS.INCIDENT_SUMMARY.mnemonic)) {   
151                cmdElem = theDoc.createElement(CAD_COMMANDS.INCIDENT_SUMMARY.fullName);           
152                currElem.appendChild(cmdElem);                 
153            }                 
154            //INCIDENT_UPDATE Request     
155            else if(token.equals(CAD_COMMANDS.INCIDENT_UPDATE.mnemonic)) {     
156                                     
157                Vector<CommandItem> commands = new Vector<CommandItem>();
158               
159                //ascertain if the next token is a number, if so, we're updating a
160                //specific log, else updating the current log(assuming we're looking at one)
161
162                cmdElem = theDoc.createElement(CAD_COMMANDS.INCIDENT_UPDATE.fullName);           
163                currElem.appendChild(cmdElem);                 
164               
165                try {
166                    token = tokenizer.nextToken().trim();
167                    Integer logNumber = new Integer(token);
168                    cmdElem.setAttribute(DATA_TAGS.LOG_NUM.tag, logNumber.toString());
169                }                   
170                //"UI." missing information
171                catch (NoSuchElementException nsee) {throw new Exception();} 
172                //UI.xxx where xxx not a number, assume UI.D/ format
173                catch (NumberFormatException nfe) {
174                    commands.add(new CommandItem(token.substring(0,2), token.substring(2,token.length())));
175                }                       
176               
177                while(tokenizer.hasMoreTokens()) {
178                    token = tokenizer.nextToken().trim();       
179                    commands.add(new CommandItem(token.substring(0,2), token.substring(2,token.length()))); 
180                }
181               
182                parseIncidentUpdate(cmdElem, commands);                     
183       
184            }
185            //ROUTED_MESSAGE Request
186            else if(token.equals(CAD_COMMANDS.ROUTED_MESSAGE.mnemonic)) {
187                String  message       = "";
188                String  destPositions = "";
189
190                //comma delimited
191                destPositions = tokenizer.nextToken();
192                               
193                //in case there is a . in the following text
194                while(tokenizer.hasMoreTokens())
195                    message += tokenizer.nextToken();
196                   
197                   
198                if(message.substring(0,2).equalsIgnoreCase(CAD_FIELD_CODES.MESSAGE.mnemonic)) {
199                    cmdElem = theDoc.createElement(CAD_COMMANDS.ROUTED_MESSAGE.fullName);           
200                    currElem.appendChild(cmdElem);                 
201
202                    Element destElem = theDoc.createElement(DATA_TAGS.DESTINATION.tag);
203                    destElem.appendChild(theDoc.createTextNode(destPositions));
204                    cmdElem.appendChild(destElem);                 
205
206                    Element msgElem = theDoc.createElement(DATA_TAGS.MESSAGE.tag);
207                    msgElem.appendChild(theDoc.createTextNode(message.substring(2, message.length())));
208                    cmdElem.appendChild(msgElem);
209                }
210                else throw new Exception();                     
211            } 
212            //ENTER_INCIDENT Request
213            else if(token.equals(CAD_COMMANDS.ENTER_INCIDENT.mnemonic)) {
214                //TODO EI Implementation??
215                /*
216                Vector<CommandItem> commands = new Vector<CommandItem>();
217               
218                cmdElem = theDoc.createElement(CAD_COMMANDS.ENTER_INCIDENT.fullName);           
219                currElem.appendChild(cmdElem);                     
220               
221                while(tokenizer.hasMoreTokens()) {
222                    token = tokenizer.nextToken().trim();       
223                    commands.add(new CommandItem(token.substring(0,2), token.substring(2,token.length())));
224                }
225               
226                parseIncidentUpdate(cmdElem, commands);
227                */
228               
229            }
230            //TERMINAL_OFF Request
231            else if(token.equals(CAD_COMMANDS.TERMINAL_OFF.mnemonic)) {
232                cmdElem = theDoc.createElement(CAD_COMMANDS.TERMINAL_OFF.fullName);       
233                currElem.appendChild(cmdElem); 
234            }
235            //APP_CLOSE Request
236            else if(token.equals(CAD_COMMANDS.APP_CLOSE.mnemonic)) {
237                cmdElem = theDoc.createElement(CAD_COMMANDS.APP_CLOSE.fullName);       
238                currElem.appendChild(cmdElem); 
239            }
240            else throw new Exception();
241        }
242        else {
243           
244            try {
245                Integer cadLog = Integer.parseInt(commandText.trim());
246               
247                cmdElem = theDoc.createElement(CAD_COMMANDS.INCIDENT_INQUIRY.fullName);
248                cmdElem.appendChild(theDoc.createTextNode(cadLog.toString()));       
249                currElem.appendChild(cmdElem);
250               
251            } catch (Exception e) {
252                throw new Exception();
253            }
254        }       
255    }   
256
257
258    /**
259     * This method iterates through the parameter Vector of CommandItem objects.
260     * For each object, the appropriate Incident information is extracted
261     * and added as a tag to the parameter XML Element.
262     *
263     * @param currElem XML Element to append Incident information tags to.
264     * @param commands Vector of CommandItems to parse for Incident information.
265     */
266    public void parseIncidentUpdate(Element currElem, Vector<CommandItem> commands) {
267       
268        String witnessName  = null;
269        String witnessAddr  = null;
270        String witnessPhone = null;
271       
272        Document theDoc = currElem.getOwnerDocument();
273       
274        for(CommandItem item : commands) {
275                                           
276            //Address of Witness
277            if(item.mnemonic.equals(CAD_FIELD_CODES.WITNESS_ADDRESS.mnemonic)) {
278                //System.out.print("A");       
279                witnessAddr = item.value;               
280            }               
281            //Beat
282            else if(item.mnemonic.equals(CAD_FIELD_CODES.BEAT.mnemonic)) {             
283                //System.out.print("B");           
284                Element beatElem = theDoc.createElement(CAD_FIELD_CODES.BEAT.fullName);
285                beatElem.appendChild(theDoc.createTextNode(item.value));
286                currElem.appendChild(beatElem);
287            }
288            //Callbox
289            else if(item.mnemonic.equals(CAD_FIELD_CODES.CALLBOX.mnemonic)) {
290                //System.out.print("C");   
291                //xmlOut.writeTag(CALLBOX, commandMap.get(key));
292            }
293            //Details
294            else if(item.mnemonic.equals(CAD_FIELD_CODES.DETAILS.mnemonic)) {
295                //System.out.print("D");
296                Element detailElem = theDoc.createElement(CAD_FIELD_CODES.DETAILS.fullName);
297               
298                //if the details contains a '|' character, the text is sensitive.  Remove
299                //the pipe and mark the detail as sensitive.
300                if(item.value.contains("|")) {
301                    StringBuffer detailBuf = new StringBuffer();
302                    detailBuf.append(item.value.substring(0, item.value.indexOf("|")));
303                    detailBuf.append(item.value.substring(item.value.indexOf("|") + 1, 
304                            item.value.length()));
305                   
306                    detailElem.setAttribute(DATA_TAGS.SENSITIVE.tag, 
307                            new Boolean(true).toString());
308                    detailElem.appendChild(theDoc.createTextNode(detailBuf.toString()));
309                }
310                else {
311                    detailElem.setAttribute(DATA_TAGS.SENSITIVE.tag, 
312                            new Boolean(false).toString());
313                    detailElem.appendChild(theDoc.createTextNode(item.value));
314                }
315                               
316                currElem.appendChild(detailElem);       
317            }
318            //Handling Unit
319            else if(item.mnemonic.equals(CAD_FIELD_CODES.HANDLING_UNIT.mnemonic)) {
320                //System.out.print("H");   
321                Element unitElem = theDoc.createElement(CAD_FIELD_CODES.HANDLING_UNIT.fullName);
322                unitElem.appendChild(theDoc.createTextNode(item.value));
323                currElem.appendChild(unitElem);
324            }               
325            //IncidentNumber
326            else if(item.mnemonic.equals(CAD_FIELD_CODES.INCIDENT_NUMBER.mnemonic)) {
327                //System.out.print("I");
328                currElem.setAttribute(CAD_FIELD_CODES.INCIDENT_NUMBER.fullName, item.value);
329            }
330            //Location
331            else if(item.mnemonic.equals(CAD_FIELD_CODES.LOCATION.mnemonic)) {
332                //System.out.print("L");
333                currElem.setAttribute(DATA_TAGS.FULL_LOCATION.tag, item.value);
334                currElem.setAttribute(DATA_TAGS.TRUNC_LOCATION.tag, item.value);
335            }
336            //Priority
337            else if(item.mnemonic.equals(CAD_FIELD_CODES.PRIORITY.mnemonic)) {
338                //System.out.print("P");                   
339                currElem.setAttribute(CAD_FIELD_CODES.PRIORITY.fullName, item.value);               
340            }                       
341            //Routing mnemonic
342            else if(item.mnemonic.equals(CAD_FIELD_CODES.ROUTE.mnemonic)) {
343                //System.out.print("R");
344                Element unitElem = theDoc.createElement(CAD_FIELD_CODES.ROUTE.fullName);
345                unitElem.appendChild(theDoc.createTextNode(item.value));
346                currElem.appendChild(unitElem);
347            }   
348            //Witness Phone Number
349            else if(item.mnemonic.equals(CAD_FIELD_CODES.WITNESS_PHONE.mnemonic)) {
350                //System.out.print("N");   
351                witnessPhone = item.value;
352            }
353            //Type
354            else if(item.mnemonic.equals(CAD_FIELD_CODES.TYPE.mnemonic)) {
355                //System.out.print("T");
356                currElem.setAttribute(CAD_FIELD_CODES.TYPE.fullName, item.value);
357            }
358            //Tow
359            else if(item.mnemonic.equals(CAD_FIELD_CODES.TOW.mnemonic)) {
360                //System.out.print("V");
361                Element towElem = theDoc.createElement(CAD_FIELD_CODES.TOW.fullName);
362                towElem.appendChild(theDoc.createTextNode("name=\"" + item.value + "\""));
363                currElem.appendChild(towElem);
364            }               
365            //Witness
366            else if(item.mnemonic.equals(CAD_FIELD_CODES.WITNESS.mnemonic)) {
367                //System.out.print("W");   
368                witnessName = item.value;
369            }                       
370        }   
371       
372        if(witnessName != null)
373        {
374
375            Element witnessElem = theDoc.createElement(CAD_FIELD_CODES.WITNESS.fullName);
376            currElem.appendChild(witnessElem);
377           
378            witnessElem.setAttribute(DATA_TAGS.WITNESS_NAME.tag, witnessName);
379       
380            if(witnessAddr != null)
381                witnessElem.setAttribute(DATA_TAGS.WITNESS_ADDR.tag, witnessAddr); 
382               
383            if(witnessPhone != null)
384                witnessElem.setAttribute(DATA_TAGS.WITNESS_PHONE.tag, witnessPhone);
385               
386        }
387    }
388}
Note: See TracBrowser for help on using the repository browser.