OAMPTalkMessageParser


1   package com.quikj.application.web.talk.messaging.oamp;
2   
3   // JAXP packages
4   import org.w3c.dom.*;
5   
6   // NANOXML packages
7   import net.n3.nanoxml.*;
8   
9   import com.quikj.application.web.oamp.messaging.*;
10  
11  public class OAMPTalkMessageParser implements OAMPMessageParserInterface
12  {
13      public OAMPTalkMessageParser()
14      {
15      }
16      
17      public boolean parse(Object   message_element, boolean request)
18      {
19          message = null; // initialize
20          errorMessage = "";
21          String   node_name;
22          
23          if (OAMPFrameworkMessageParser.getParserType() == OAMPFrameworkMessageParser.DOM_PARSER)
24          {
25              node_name = getDomNodeName(message_element);
26          }
27          else // NANOXML parser
28          {
29              node_name = getNanoNodeName(message_element);
30          }
31          
32          if (node_name.equals(OAMPTalkMessageTypes.MONITOR_FEATURES_START_NODE_NAME) == true)
33          {
34              if (request == true) // HTTP request
35              {
36                  OAMPMessageInterface msg = new MonitorFeaturesStartMessage();
37                  if (msg.parse(message_element) == false) // parsing failed
38                  {
39                      errorMessage = msg.getErrorMessage();
40                      return false;
41                  }
42                  message = msg;
43                  return true;
44              }
45              else // HTTP response
46              {
47                  errorMessage = "Unsupported OAMP talk message type: "
48                  + node_name
49                  + " received";
50                  return false;
51              }
52          }
53          else if (node_name.equals(OAMPTalkMessageTypes.MONITOR_FEATURES_STOP_NODE_NAME) == true)
54          {
55              if (request == true) // HTTP request
56              {
57                  OAMPMessageInterface msg = new MonitorFeaturesStopMessage();
58                  if (msg.parse(message_element) == false) // parsing failed
59                  {
60                      errorMessage = msg.getErrorMessage();
61                      return false;
62                  }
63                  message = msg;
64                  return true;
65              }
66              else // HTTP response
67              {
68                  errorMessage = "Unsupported OAMP talk message type: "
69                  + node_name
70                  + " received";
71                  return false;
72              }
73          }
74          else if (node_name.equals(OAMPTalkMessageTypes.MONITOR_FEATURES_STATS_NODE_NAME) == true)
75          {
76              if (request == true) // HTTP request
77              {
78                  OAMPMessageInterface msg = new MonitorFeaturesStatisticsMessage();
79                  if (msg.parse(message_element) == false) // parsing failed
80                  {
81                      errorMessage = msg.getErrorMessage();
82                      return false;
83                  }
84                  message = msg;
85                  return true;
86              }
87              else // HTTP response
88              {
89                  errorMessage = "Unsupported OAMP talk message type: "
90                  + node_name
91                  + " received";
92                  return false;
93              }
94          }
95          else if (node_name.equals(OAMPTalkMessageTypes.MONITOR_USERS_START_NODE_NAME) == true)
96          {
97              if (request == true) // HTTP request
98              {
99                  OAMPMessageInterface msg = new MonitorUsersStartMessage();
100                 if (msg.parse(message_element) == false) // parsing failed
101                 {
102                     errorMessage = msg.getErrorMessage();
103                     return false;
104                 }
105                 message = msg;
106                 return true;
107             }
108             else // HTTP response
109             {
110                 errorMessage = "Unsupported OAMP talk message type: "
111                 + node_name
112                 + " received";
113                 return false;
114             }
115         }
116         else if (node_name.equals(OAMPTalkMessageTypes.MONITOR_USERS_STOP_NODE_NAME) == true)
117         {
118             if (request == true) // HTTP request
119             {
120                 OAMPMessageInterface msg = new MonitorUsersStopMessage();
121                 if (msg.parse(message_element) == false) // parsing failed
122                 {
123                     errorMessage = msg.getErrorMessage();
124                     return false;
125                 }
126                 message = msg;
127                 return true;
128             }
129             else // HTTP response
130             {
131                 errorMessage = "Unsupported OAMP talk message type: "
132                 + node_name
133                 + " received";
134                 return false;
135             }
136         }
137         else if (node_name.equals(OAMPTalkMessageTypes.MONITOR_USERS_STATS_NODE_NAME) == true)
138         {
139             if (request == true) // HTTP request
140             {
141                 OAMPMessageInterface msg = new MonitorUsersStatisticsMessage();
142                 if (msg.parse(message_element) == false) // parsing failed
143                 {
144                     errorMessage = msg.getErrorMessage();
145                     return false;
146                 }
147                 message = msg;
148                 return true;
149             }
150             else // HTTP response
151             {
152                 errorMessage = "Unsupported OAMP talk message type: "
153                 + node_name
154                 + " received";
155                 return false;
156             }
157         }
158         else if (node_name.equals(OAMPTalkMessageTypes.MONITOR_ENDPOINTS_START_NODE_NAME) == true)
159         {
160             if (request == true) // HTTP request
161             {
162                 OAMPMessageInterface msg = new MonitorEndPointsStartMessage();
163                 if (msg.parse(message_element) == false) // parsing failed
164                 {
165                     errorMessage = msg.getErrorMessage();
166                     return false;
167                 }
168                 message = msg;
169                 return true;
170             }
171             else // HTTP response
172             {
173                 errorMessage = "Unsupported OAMP talk message type: "
174                 + node_name
175                 + " received";
176                 return false;
177             }
178         }
179         else if (node_name.equals(OAMPTalkMessageTypes.MONITOR_ENDPOINTS_STOP_NODE_NAME) == true)
180         {
181             if (request == true) // HTTP request
182             {
183                 OAMPMessageInterface msg = new MonitorEndPointsStopMessage();
184                 if (msg.parse(message_element) == false) // parsing failed
185                 {
186                     errorMessage = msg.getErrorMessage();
187                     return false;
188                 }
189                 message = msg;
190                 return true;
191             }
192             else // HTTP response
193             {
194                 errorMessage = "Unsupported OAMP talk message type: "
195                 + node_name
196                 + " received";
197                 return false;
198             }
199         }
200         else if (node_name.equals(OAMPTalkMessageTypes.MONITOR_ENDPOINTS_STATS_NODE_NAME) == true)
201         {
202             if (request == true) // HTTP request
203             {
204                 OAMPMessageInterface msg = new MonitorEndPointsStatisticsMessage();
205                 if (msg.parse(message_element) == false) // parsing failed
206                 {
207                     errorMessage = msg.getErrorMessage();
208                     return false;
209                 }
210                 message = msg;
211                 return true;
212             }
213             else // HTTP response
214             {
215                 errorMessage = "Unsupported OAMP talk message type: "
216                 + node_name
217                 + " received";
218                 return false;
219             }
220         }
221         else
222         {
223             errorMessage = "Unsupported OAMP talk message type: "
224             + node_name
225             + " received";
226             return false;
227         }
228         
229     }
230     
231     private String   getDomNodeName(Object   message_element)
232     {
233         return ((Node)message_element).getNodeName();
234     }
235     
236     private String   getNanoNodeName(Object   message_element)
237     {
238         return ((IXMLElement)message_element).getFullName();
239     }
240     
241     public OAMPMessageInterface getMessage()
242     {
243         return message;
244     }
245     
246     public String   getErrorMessage()
247     {
248         return errorMessage;
249     }
250     
251     private OAMPMessageInterface message;
252     private String   errorMessage = "";
253     
254 }
255
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Popular Tags