TalkMessageParser


1   package com.quikj.application.web.talk.messaging;
2   
3   // JAXP packages
4   import javax.xml.parsers.*;
5   import org.xml.sax.*;
6   import org.w3c.dom.*;
7   
8   // NANOXML packages
9   import net.n3.nanoxml.*;
10  
11  import java.io.*;
12  
13  public class TalkMessageParser
14  {
15      public static final int DOM_PARSER = 1;
16  
17      public static final int NANOXML_PARSER = 2;
18  
19      // constructor for the DOM parser
20      public TalkMessageParser(DocumentBuilder builder)
21              throws AceMessageException
22      {
23          if (getParserType() != DOM_PARSER)
24          {
25              throw new AceMessageException(
26                      "You can invoke this constructor only for a DOM parser");
27          }
28  
29          domParser = new TalkMessageParser.XMLParserDOM(builder);
30      }
31  
32      // constructor for the NanoXML parser
33      public TalkMessageParser() throws ClassNotFoundException  ,
34              InstantiationException  , IllegalAccessException  , AceMessageException
35      {
36          if (getParserType() != NANOXML_PARSER)
37          {
38              throw new AceMessageException(
39                      "You can invoke this constructor only for a NANOXML parser");
40          }
41  
42          nanoParser = new TalkMessageParser.XMLParserNANO();
43      }
44  
45      public boolean parse(String   body, boolean request)
46      {
47          message = null; // initialize
48  
49          Object   root_element = null;
50          String   node_name = null;
51  
52          if (getParserType() == DOM_PARSER)
53          {
54              if (domParser.parse(body) == false)
55              {
56                  return false;
57              }
58  
59              root_element = domParser.getRootElement();
60              node_name = domParser.getNodeName();
61          }
62          else
63          // NANOXML parser
64          {
65              if (nanoParser.parse(body) == false)
66              {
67                  return false;
68              }
69  
70              root_element = nanoParser.getRootElement();
71              node_name = nanoParser.getNodeName();
72          }
73  
74          if (node_name.equals(TalkMessageInterface.SETUP_NODE_NAME) == true)
75          {
76              if (request == true) // HTTP request
77              {
78                  TalkMessageInterface msg = new SetupRequestMessage();
79                  if (msg.parse(root_element) == false) // parsing
80                                                                                           // failed
81                  {
82                      errorMessage = msg.getErrorMessage();
83                      return false;
84                  }
85                  message = msg;
86                  return true;
87              }
88              else
89              // HTTP response
90              {
91                  TalkMessageInterface msg = new SetupResponseMessage();
92                  if (msg.parse(root_element) == false) // parsing
93                                                                                           // failed
94                  {
95                      errorMessage = msg.getErrorMessage();
96                      return false;
97                  }
98                  message = msg;
99                  return true;
100             }
101         }
102         else if (node_name.equals(TalkMessageInterface.DISCONNECT_NODE_NAME) == true)
103         {
104             if (request == true) // HTTP request
105             {
106                 TalkMessageInterface msg = new DisconnectMessage();
107                 if (msg.parse(root_element) == false) // parsing
108                                                                                          // failed
109                 {
110                     errorMessage = msg.getErrorMessage();
111                     return false;
112                 }
113                 message = msg;
114             }
115             else
116             // HTTP response
117             {
118                 // there is no Disconnect response message
119                 errorMessage = "A disconnect message is received as a response message";
120                 return false;
121             }
122         }
123         else if (node_name.equals(TalkMessageInterface.RTP_NODE_NAME) == true)
124         {
125             if (request == true) // HTTP request
126             {
127                 TalkMessageInterface msg = new RTPMessage();
128                 if (msg.parse(root_element) == false) // parsing
129                                                                                          // failed
130                 {
131                     errorMessage = msg.getErrorMessage();
132                     return false;
133                 }
134                 message = msg;
135             }
136             else
137             // HTTP response
138             {
139                 // there is no RTP response message
140                 errorMessage = "An RTP message is received as a response message";
141                 return false;
142             }
143         }
144         else if (node_name.equals(TalkMessageInterface.REGISTRATION_NODE_NAME) == true)
145         {
146             if (request == true) // HTTP request
147             {
148                 TalkMessageInterface msg = new RegistrationRequestMessage();
149                 if (msg.parse(root_element) == false) // parsing
150                                                                                          // failed
151                 {
152                     errorMessage = msg.getErrorMessage();
153                     return false;
154                 }
155                 message = msg;
156                 return true;
157             }
158             else
159             // HTTP response
160             {
161                 TalkMessageInterface msg = new RegistrationResponseMessage();
162                 if (msg.parse(root_element) == false) // parsing
163                                                                                          // failed
164                 {
165                     errorMessage = msg.getErrorMessage();
166                     return false;
167                 }
168                 message = msg;
169                 return true;
170             }
171         }
172         else if (node_name.equals(TalkMessageInterface.JOIN_NODE_NAME) == true)
173         {
174             if (request == true) // HTTP request
175             {
176                 TalkMessageInterface msg = new JoinRequestMessage();
177                 if (msg.parse(root_element) == false) // parsing
178                                                                                          // failed
179                 {
180                     errorMessage = msg.getErrorMessage();
181                     return false;
182                 }
183                 message = msg;
184                 return true;
185             }
186             else
187             // HTTP response
188             {
189                 TalkMessageInterface msg = new JoinResponseMessage();
190                 if (msg.parse(root_element) == false) // parsing
191                                                                                          // failed
192                 {
193                     errorMessage = msg.getErrorMessage();
194                     return false;
195                 }
196                 message = msg;
197                 return true;
198             }
199         }
200         else if (node_name
201                 .equals(TalkMessageInterface.REPLACE_SESSION_NODE_NAME) == true)
202         {
203             if (request == true) // HTTP request
204             {
205                 TalkMessageInterface msg = new ReplaceSessionMessage();
206                 if (msg.parse(root_element) == false) // parsing
207                                                                                          // failed
208                 {
209                     errorMessage = msg.getErrorMessage();
210                     return false;
211                 }
212                 message = msg;
213                 return true;
214             }
215             else
216             // HTTP response
217             {
218                 errorMessage = "A Replace Session message is received as a response message";
219                 return false;
220             }
221         }
222         else if (node_name
223                 .equals(TalkMessageInterface.CONFERENCE_INFO_NODE_NAME) == true)
224         {
225             if (request == true) // HTTP request
226             {
227                 TalkMessageInterface msg = new ConferenceInformationMessage();
228                 if (msg.parse(root_element) == false) // parsing
229                                                                                          // failed
230                 {
231                     errorMessage = msg.getErrorMessage();
232                     return false;
233                 }
234                 message = msg;
235                 return true;
236             }
237             else
238             // HTTP response
239             {
240                 errorMessage = "A Conference Info message is received as a response message";
241                 return false;
242             }
243         }
244         else if (node_name
245                 .equals(TalkMessageInterface.GROUP_ACTIVITY_NODE_NAME) == true)
246         {
247             if (request == true) // HTTP request
248             {
249                 TalkMessageInterface msg = new GroupActivityMessage();
250                 if (msg.parse(root_element) == false) // parsing
251                                                                                          // failed
252                 {
253                     errorMessage = msg.getErrorMessage();
254                     return false;
255                 }
256                 message = msg;
257                 return true;
258             }
259             else
260             // HTTP response
261             {
262                 errorMessage = "A Group Activity message is received as a response message";
263                 return false;
264             }
265         }
266         else if (node_name
267                 .equals(TalkMessageInterface.CHANGE_PASSWORD_NODE_NAME) == true)
268         {
269             if (request == true) // HTTP request
270             {
271                 TalkMessageInterface msg = new ChangePasswordRequestMessage();
272                 if (msg.parse(root_element) == false) // parsing
273                                                                                          // failed
274                 {
275                     errorMessage = msg.getErrorMessage();
276                     return false;
277                 }
278                 message = msg;
279             }
280             else
281             // HTTP response
282             {
283                 TalkMessageInterface msg = new ChangePasswordResponseMessage();
284                 if (msg.parse(root_element) == false) // parsing
285                                                                                          // failed
286                 {
287                     errorMessage = msg.getErrorMessage();
288                     return false;
289                 }
290                 message = msg;
291                 return true;
292             }
293         }
294         else if (node_name.equals(TalkMessageInterface.SEND_MAIL_NODE_NAME) == true)
295         {
296             if (request == true) // HTTP request
297             {
298                 TalkMessageInterface msg = new SendMailRequestMessage();
299                 if (msg.parse(root_element) == false) // parsing
300                                                                                          // failed
301                 {
302                     errorMessage = msg.getErrorMessage();
303                     return false;
304                 }
305                 message = msg;
306             }
307             else
308             // HTTP response
309             {
310                 TalkMessageInterface msg = new SendMailResponseMessage();
311                 if (msg.parse(root_element) == false) // parsing
312                                                                                          // failed
313                 {
314                     errorMessage = msg.getErrorMessage();
315                     return false;
316                 }
317                 message = msg;
318                 return true;
319             }
320         }
321         else if (node_name.equals(TalkMessageInterface.USER_TO_USER_NODE_NAME) == true)
322         {
323             TalkMessageInterface msg = new UserToUserMessage();
324             if (msg.parse(root_element) == false) // parsing
325                                                                                      // failed
326             {
327                 errorMessage = msg.getErrorMessage();
328                 return false;
329             }
330             message = msg;
331             return true;
332         }
333         else if (node_name.equals(TalkMessageInterface.DND_NODE_NAME) == true)
334         {
335             if (request == true) // HTTP request
336             {
337                 TalkMessageInterface msg = new DndRequestMessage();
338                 if (msg.parse(root_element) == false) // parsing
339                                                                                          // failed
340                 {
341                     errorMessage = msg.getErrorMessage();
342                     return false;
343                 }
344                 message = msg;
345             }
346             else
347             // HTTP response
348             {
349                 TalkMessageInterface msg = new DndResponseMessage();
350                 if (msg.parse(root_element) == false) // parsing
351                                                                                          // failed
352                 {
353                     errorMessage = msg.getErrorMessage();
354                     return false;
355                 }
356                 message = msg;
357                 return true;
358             }
359         }
360         else
361         {
362             errorMessage = "Unsupported message type: " + node_name
363                     + " received";
364             return false;
365         }
366         return true;
367     }
368 
369     public TalkMessageInterface getMessage()
370     {
371         return message;
372     }
373 
374     public String   getErrorMessage()
375     {
376         return errorMessage;
377     }
378 
379     /**
380      * Getter for property parserType.
381      * 
382      * @return Value of property parserType.
383      */
384     public static int getParserType()
385     {
386         return parserType;
387     }
388 
389     /**
390      * Setter for property parserType.
391      * 
392      * @param parserType
393      *                       New value of property parserType.
394      */
395     public static void setParserType(int parser_type)
396     {
397         parserType = parser_type;
398     }
399 
400     public static String   encodeXMLString(java.lang.String   input)
401     {
402         char[] str = input.toCharArray();
403         StringBuffer   buffer = new StringBuffer  ();
404 
405         for (int i = 0; i < str.length; i++)
406         {
407             switch (str[i])
408             {
409             case '<':
410                 buffer.append("&lt;");
411                 break;
412 
413             case '>':
414                 buffer.append("&gt;");
415                 break;
416 
417             case '&':
418                 buffer.append("&amp;");
419                 break;
420 
421             case '\'':
422                 buffer.append("&apos;");
423                 break;
424 
425             case '\"':
426                 buffer.append("&quot;");
427                 break;
428 
429             default:
430                 int intv = str[i];
431                 if (intv > 127)
432                 {
433                     buffer.append("&#x" + Integer.toHexString(intv) + ";");
434                 }
435                 else
436                 {
437                     buffer.append(str[i]);
438                 }
439             }
440         }
441 
442         return buffer.toString();
443     }
444 
445     class XMLParserDOM
446     {
447         public XMLParserDOM(DocumentBuilder builder)
448         {
449             this.builder = builder;
450         }
451 
452         public boolean parse(String   body)
453         {
454             try
455             {
456                 InputSource source = new InputSource(new StringReader(body));
457                 Document doc = builder.parse(source);
458 
459                 if (doc.getNodeType() != Node.DOCUMENT_NODE)
460                 {
461                     // the root node must be of the type document
462                     errorMessage = "The message does not begin with an Document node";
463                     return false;
464                 }
465 
466                 Node root = null;
467                 boolean root_found = false;
468                 for (root = doc.getFirstChild(); root != null; root = root
469                         .getNextSibling())
470                 {
471                     if (root.getNodeType() == Node.ELEMENT_NODE)
472                     {
473                         root_found = true;
474                         break;
475 
476                     }
477                     // else discard
478                 }
479 
480                 if (root_found == false)
481                 {
482                     errorMessage = "Root element not found";
483                     return false;
484                 }
485                 else
486                 {
487                     rootElement = root;
488                     nodeName = root.getNodeName();
489                 }
490             }
491             catch (SAXException ex)
492             {
493                 errorMessage = "Malformatted message: " + ex.getMessage();
494                 return false;
495             }
496             catch (IOException ex)
497             {
498                 errorMessage = "IO error: " + ex.getMessage();
499                 return false;
500             }
501 
502             return true;
503         }
504 
505         /**
506          * Getter for property nodeName.
507          * 
508          * @return Value of property nodeName.
509          */
510         public java.lang.String   getNodeName()
511         {
512             return nodeName;
513         }
514 
515         /**
516          * Setter for property nodeName.
517          * 
518          * @param nodeName
519          *                       New value of property nodeName.
520          */
521         public void setNodeName(java.lang.String   nodeName)
522         {
523             this.nodeName = nodeName;
524         }
525 
526         /**
527          * Getter for property rootElement.
528          * 
529          * @return Value of property rootElement.
530          */
531         public java.lang.Object   getRootElement()
532         {
533             return rootElement;
534         }
535 
536         /**
537          * Setter for property rootElement.
538          * 
539          * @param rootElement
540          *                       New value of property rootElement.
541          */
542         public void setRootElement(java.lang.Object   rootElement)
543         {
544             this.rootElement = rootElement;
545         }
546 
547         private String   nodeName = null;
548 
549         private Object   rootElement = null;
550 
551         private DocumentBuilder builder = null;
552     }
553 
554     class XMLParserNANO
555     {
556         public XMLParserNANO() throws ClassNotFoundException  ,
557                 InstantiationException  , IllegalAccessException  
558         {
559             nanoXMLParser = XMLParserFactory.createXMLParser(
560                     "net.n3.nanoxml.StdXMLParser", new StdXMLBuilder());
561         }
562 
563         public boolean parse(String   body)
564         {
565             try
566             {
567                 nanoXMLParser.setReader(StdXMLReader.stringReader(body));
568                 IXMLElement element = (IXMLElement) nanoXMLParser.parse();
569 
570                 // the parsing has been successful
571                 rootElement = element;
572                 nodeName = element.getFullName();
573             }
574             catch (XMLException ex)
575             {
576                 errorMessage = "Malformatted message: " + ex.getMessage();
577                 return false;
578             }
579 
580             return true;
581         }
582 
583         /**
584          * Getter for property nodeName.
585          * 
586          * @return Value of property nodeName.
587          */
588         public java.lang.String   getNodeName()
589         {
590             return nodeName;
591         }
592 
593         /**
594          * Setter for property nodeName.
595          * 
596          * @param nodeName
597          *                       New value of property nodeName.
598          */
599         public void setNodeName(java.lang.String   nodeName)
600         {
601             this.nodeName = nodeName;
602         }
603 
604         /**
605          * Getter for property rootElement.
606          * 
607          * @return Value of property rootElement.
608          */
609         public java.lang.Object   getRootElement()
610         {
611             return rootElement;
612         }
613 
614         /**
615          * Setter for property rootElement.
616          * 
617          * @param rootElement
618          *                       New value of property rootElement.
619          */
620         public void setRootElement(java.lang.Object   rootElement)
621         {
622             this.rootElement = rootElement;
623         }
624 
625         private String   nodeName = null;
626 
627         private Object   rootElement = null;
628 
629         private IXMLParser nanoXMLParser = null;
630     }
631 
632     private TalkMessageInterface message;
633 
634     private static int parserType = DOM_PARSER;
635 
636     private String   errorMessage = "";
637 
638     private XMLParserDOM domParser = null;
639 
640     private XMLParserNANO nanoParser = null;
641 }
642 
643
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Popular Tags