Mercurial > repos > uga-galaxy-group > webservice_toolsuite_v1_1
comparison WebServiceExtensionsV1.1/WebServiceToolWorkflow_REST_SOAP/lib/SAWADLParser/src/javax/wadls/extensions/ExtensionRegistry.java @ 0:049760c677de default tip
Galaxy WSExtensions added successfully
author | uga-galaxy-group |
---|---|
date | Tue, 05 Jul 2011 19:34:18 -0400 |
parents | |
children |
comparison
equal
deleted
inserted
replaced
-1:000000000000 | 0:049760c677de |
---|---|
1 /* | |
2 * (c) Copyright IBM Corp 2001, 2005 | |
3 */ | |
4 | |
5 package javax.wadls.extensions; | |
6 | |
7 import java.util.*; | |
8 | |
9 import javax.wadls.*; | |
10 import javax.xml.namespace.*; | |
11 | |
12 /** | |
13 * This class is used to associate serializers, deserializers, and | |
14 * Java implementation types with extensibility elements. | |
15 * | |
16 * @author Matthew J. Duftler (duftler@us.ibm.com) | |
17 */ | |
18 public class ExtensionRegistry implements java.io.Serializable | |
19 { | |
20 public static final long serialVersionUID = 1; | |
21 | |
22 /** | |
23 * Creates the extension registry, and sets the defaultSerializer | |
24 * and defaultDeserializer properties to instances of an | |
25 * UnknownExtensionSerializer, and an UnknownExtensionDeserializer, | |
26 * respectively. | |
27 */ | |
28 public ExtensionRegistry() | |
29 { | |
30 setDefaultSerializer(new UnknownExtensionSerializer()); | |
31 setDefaultDeserializer(new UnknownExtensionDeserializer()); | |
32 } | |
33 | |
34 /* | |
35 This is a Map of Maps. The top-level Map is keyed by (Class)parentType, | |
36 and the inner Maps are keyed by (QName)elementType. | |
37 */ | |
38 protected Map serializerReg = new Hashtable(); | |
39 /* | |
40 This is a Map of Maps. The top-level Map is keyed by (Class)parentType, | |
41 and the inner Maps are keyed by (QName)elementType. | |
42 */ | |
43 protected Map deserializerReg = new Hashtable(); | |
44 /* | |
45 This is a Map of Maps. The top-level Map is keyed by (Class)parentType, | |
46 and the inner Maps are keyed by (QName)elementType. | |
47 */ | |
48 protected Map extensionTypeReg = new Hashtable(); | |
49 protected ExtensionSerializer defaultSer = null; | |
50 protected ExtensionDeserializer defaultDeser = null; | |
51 /* | |
52 This is a Map of Maps. The top-level Map is keyed by (Class)parentType, | |
53 and the inner Maps are keyed by (QName)attrName. | |
54 */ | |
55 protected Map extensionAttributeTypeReg = new Hashtable(); | |
56 | |
57 /** | |
58 * Set the serializer to be used when none is found for an extensibility | |
59 * element. Set this to null to have an exception thrown when | |
60 * unexpected extensibility elements are encountered. Default value is | |
61 * an instance of UnknownExtensionSerializer. | |
62 * | |
63 * @see UnknownExtensionSerializer | |
64 */ | |
65 public void setDefaultSerializer(ExtensionSerializer defaultSer) | |
66 { | |
67 this.defaultSer = defaultSer; | |
68 } | |
69 | |
70 /** | |
71 * Get the serializer to be used when none is found for an extensibility | |
72 * element. Default value is an instance of UnknownExtensionSerializer. | |
73 * | |
74 * @see UnknownExtensionSerializer | |
75 */ | |
76 public ExtensionSerializer getDefaultSerializer() | |
77 { | |
78 return defaultSer; | |
79 } | |
80 | |
81 /** | |
82 * Set the deserializer to be used when none is found for an encountered | |
83 * element. Set this to null to have an exception thrown when | |
84 * unexpected extensibility elements are encountered. Default value is | |
85 * an instance of UnknownExtensionDeserializer. | |
86 * | |
87 * @see UnknownExtensionDeserializer | |
88 */ | |
89 public void setDefaultDeserializer(ExtensionDeserializer defaultDeser) | |
90 { | |
91 this.defaultDeser = defaultDeser; | |
92 } | |
93 | |
94 /** | |
95 * Get the deserializer to be used when none is found for an encountered | |
96 * element. Default value is an instance of UnknownExtensionDeserializer. | |
97 * | |
98 * @see UnknownExtensionDeserializer | |
99 */ | |
100 public ExtensionDeserializer getDefaultDeserializer() | |
101 { | |
102 return defaultDeser; | |
103 } | |
104 | |
105 /** | |
106 * Declare that the specified serializer should be used to serialize | |
107 * all extensibility elements with a qname matching elementType, when | |
108 * encountered as children of the specified parentType. | |
109 * | |
110 * @param parentType a class object indicating where in the WSDL | |
111 * definition this extension was encountered. For | |
112 * example, javax.wsdls.Binding.class would be used to indicate | |
113 * this extensibility element was found in the list of | |
114 * extensibility elements belonging to a javax.wsdls.Binding. | |
115 * @param elementType the qname of the extensibility element | |
116 * @param es the extension serializer to use | |
117 * | |
118 * @see #querySerializer(Class, QName) | |
119 */ | |
120 public void registerSerializer(Class parentType, | |
121 QName elementType, | |
122 ExtensionSerializer es) | |
123 { | |
124 Map innerSerializerReg = (Map)serializerReg.get(parentType); | |
125 | |
126 if (innerSerializerReg == null) | |
127 { | |
128 innerSerializerReg = new Hashtable(); | |
129 | |
130 serializerReg.put(parentType, innerSerializerReg); | |
131 } | |
132 | |
133 innerSerializerReg.put(elementType, es); | |
134 } | |
135 | |
136 /** | |
137 * Declare that the specified deserializer should be used to deserialize | |
138 * all extensibility elements with a qname matching elementType, when | |
139 * encountered as immediate children of the element represented by the | |
140 * specified parentType. | |
141 * | |
142 * @param parentType a class object indicating where in the WSDL | |
143 * document this extensibility element was encountered. For | |
144 * example, javax.wsdls.Binding.class would be used to indicate | |
145 * this element was encountered as an immediate child of | |
146 * a <wsdl:binding> element. | |
147 * @param elementType the qname of the extensibility element | |
148 * @param ed the extension deserializer to use | |
149 * | |
150 * @see #queryDeserializer(Class, QName) | |
151 */ | |
152 public void registerDeserializer(Class parentType, | |
153 QName elementType, | |
154 ExtensionDeserializer ed) | |
155 { | |
156 Map innerDeserializerReg = (Map)deserializerReg.get(parentType); | |
157 | |
158 if (innerDeserializerReg == null) | |
159 { | |
160 innerDeserializerReg = new Hashtable(); | |
161 | |
162 deserializerReg.put(parentType, innerDeserializerReg); | |
163 } | |
164 | |
165 innerDeserializerReg.put(elementType, ed); | |
166 } | |
167 | |
168 /** | |
169 * Look up the serializer to use for the extensibility element with | |
170 * the qname elementType, which was encountered as a child of the | |
171 * specified parentType. | |
172 * | |
173 * @param parentType a class object indicating where in the WSDL | |
174 * definition this extension was encountered. For | |
175 * example, javax.wsdls.Binding.class would be used to indicate | |
176 * this extensibility element was found in the list of | |
177 * extensibility elements belonging to a javax.wsdls.Binding. | |
178 * @param elementType the qname of the extensibility element | |
179 * | |
180 * @return the extension serializer, if one was found. If none was | |
181 * found, the behavior depends on the value of the defaultSerializer | |
182 * property. If the defaultSerializer property is set to a non-null | |
183 * value, that value is returned; otherwise, a WSDLSException is | |
184 * thrown. | |
185 * | |
186 * @see #registerSerializer(Class, QName, ExtensionSerializer) | |
187 * @see #setDefaultSerializer(ExtensionSerializer) | |
188 */ | |
189 public ExtensionSerializer querySerializer(Class parentType, | |
190 QName elementType) | |
191 throws WADLSException | |
192 { | |
193 Map innerSerializerReg = (Map)serializerReg.get(parentType); | |
194 ExtensionSerializer es = null; | |
195 | |
196 if (innerSerializerReg != null) | |
197 { | |
198 es = (ExtensionSerializer)innerSerializerReg.get(elementType); | |
199 } | |
200 | |
201 if (es == null) | |
202 { | |
203 es = defaultSer; | |
204 } | |
205 | |
206 if (es == null) | |
207 { | |
208 throw new WADLSException(WADLSException.CONFIGURATION_ERROR, | |
209 "No ExtensionSerializer found " + | |
210 "to serialize a '" + elementType + | |
211 "' element in the context of a '" + | |
212 parentType.getName() + "'."); | |
213 } | |
214 | |
215 return es; | |
216 } | |
217 | |
218 /** | |
219 * Look up the deserializer for the extensibility element with the | |
220 * qname elementType, which was encountered as an immediate child | |
221 * of the element represented by the specified parentType. | |
222 * | |
223 * @param parentType a class object indicating where in the WSDL | |
224 * document this extensibility element was encountered. For | |
225 * example, javax.wsdls.Binding.class would be used to indicate | |
226 * this element was encountered as an immediate child of | |
227 * a <wsdl:binding> element. | |
228 * @param elementType the qname of the extensibility element | |
229 * | |
230 * @return the extension deserializer, if one was found. If none was | |
231 * found, the behavior depends on the value of the defaultDeserializer | |
232 * property. If the defaultDeserializer property is set to a non-null | |
233 * value, that value is returned; otherwise, a WSDLSException is thrown. | |
234 * | |
235 * @see #registerDeserializer(Class, QName, ExtensionDeserializer) | |
236 * @see #setDefaultDeserializer(ExtensionDeserializer) | |
237 */ | |
238 public ExtensionDeserializer queryDeserializer(Class parentType, | |
239 QName elementType) | |
240 throws WADLSException | |
241 { | |
242 | |
243 System.out.println("%%%% Inside Query Deserializer"); | |
244 Map innerDeserializerReg = (Map)deserializerReg.get(parentType); | |
245 System.out.println("%%%% inner DeserializerReg Size:"+innerDeserializerReg.size()); | |
246 ExtensionDeserializer ed = null; | |
247 | |
248 if (innerDeserializerReg != null) | |
249 { | |
250 System.out.println("%%%% Inner Deserializer not null"); | |
251 ed = (ExtensionDeserializer)innerDeserializerReg.get(elementType); | |
252 System.out.println("%%%% Ed string "+ed.toString()); | |
253 } | |
254 | |
255 if (ed == null) | |
256 { | |
257 ed = defaultDeser; | |
258 System.out.println("%%%% Default Deser String:"+defaultDeser.toString()); | |
259 } | |
260 | |
261 if (ed == null) | |
262 { | |
263 throw new WADLSException(WADLSException.CONFIGURATION_ERROR, | |
264 "No ExtensionDeserializer found " + | |
265 "to deserialize a '" + elementType + | |
266 "' element in the context of a '" + | |
267 parentType.getName() + "'."); | |
268 } | |
269 | |
270 return ed; | |
271 } | |
272 | |
273 /** | |
274 * Returns a set of QNames representing the extensibility elements | |
275 * that are allowed as children of the specified parent type. | |
276 * Basically, this method returns the keys associated with the set | |
277 * of extension deserializers registered for this parent type. | |
278 * Returns null if no extension deserializers are registered for | |
279 * this parent type. | |
280 */ | |
281 public Set getAllowableExtensions(Class parentType) | |
282 { | |
283 Map innerDeserializerReg = (Map)deserializerReg.get(parentType); | |
284 | |
285 return (innerDeserializerReg != null) | |
286 ? innerDeserializerReg.keySet() | |
287 : null; | |
288 } | |
289 | |
290 /** | |
291 * Declare that the specified extensionType is the concrete | |
292 * class which should be used to represent extensibility elements | |
293 * with qnames matching elementType, that are intended to exist as | |
294 * children of the specified parentType. | |
295 * | |
296 * @param parentType a class object indicating where in the WSDL | |
297 * definition this extension would exist. For example, | |
298 * javax.wsdls.Binding.class would be used to indicate | |
299 * this extensibility element would be added to the list of | |
300 * extensibility elements belonging to a javax.wsdls.Binding, | |
301 * after being instantiated. | |
302 * @param elementType the qname of the extensibility element | |
303 * @param extensionType the concrete class which should be instantiated | |
304 * | |
305 * @see #createExtension(Class, QName) | |
306 */ | |
307 public void mapExtensionTypes(Class parentType, | |
308 QName elementType, | |
309 Class extensionType) | |
310 { | |
311 Map innerExtensionTypeReg = (Map)extensionTypeReg.get(parentType); | |
312 | |
313 if (innerExtensionTypeReg == null) | |
314 { | |
315 innerExtensionTypeReg = new Hashtable(); | |
316 | |
317 extensionTypeReg.put(parentType, innerExtensionTypeReg); | |
318 } | |
319 | |
320 innerExtensionTypeReg.put(elementType, extensionType); | |
321 } | |
322 | |
323 /** | |
324 * Create an instance of the type which was declared to be used to | |
325 * represent extensibility elements with qnames matching elementType, | |
326 * when intended to exist as children of the specified parentType. | |
327 * This method allows a user to instantiate an extensibility element | |
328 * without having to know the implementing type. | |
329 * | |
330 * @param parentType a class object indicating where in the WSDL | |
331 * definition this extension will exist. For example, | |
332 * javax.wsdls.Binding.class would be used to indicate | |
333 * this extensibility element is going to be added to the list of | |
334 * extensibility elements belonging to a javax.wsdls.Binding, | |
335 * after being instantiated. | |
336 * @param elementType the qname of the extensibility element | |
337 * | |
338 * @return a new instance of the type used to represent the | |
339 * specified extension | |
340 * | |
341 * @see #mapExtensionTypes(Class, QName, Class) | |
342 */ | |
343 public ExtensibilityElement createExtension(Class parentType, | |
344 QName elementType) | |
345 throws WADLSException | |
346 { | |
347 Map innerExtensionTypeReg = (Map)extensionTypeReg.get(parentType); | |
348 Class extensionType = null; | |
349 | |
350 if (innerExtensionTypeReg != null) | |
351 { | |
352 extensionType = (Class)innerExtensionTypeReg.get(elementType); | |
353 } | |
354 | |
355 if (extensionType == null) | |
356 { | |
357 throw new WADLSException(WADLSException.CONFIGURATION_ERROR, | |
358 "No Java extensionType found " + | |
359 "to represent a '" + elementType + | |
360 "' element in the context of a '" + | |
361 parentType.getName() + "'."); | |
362 } | |
363 else if (!(ExtensibilityElement.class.isAssignableFrom(extensionType))) | |
364 { | |
365 throw new WADLSException(WADLSException.CONFIGURATION_ERROR, | |
366 "The Java extensionType '" + | |
367 extensionType.getName() + "' does " + | |
368 "not implement the ExtensibilityElement " + | |
369 "interface."); | |
370 } | |
371 | |
372 try | |
373 { | |
374 ExtensibilityElement ee = (ExtensibilityElement)extensionType.newInstance(); | |
375 | |
376 if (ee.getElementType() == null) | |
377 { | |
378 ee.setElementType(elementType); | |
379 } | |
380 | |
381 return ee; | |
382 } | |
383 catch (Exception e) | |
384 { | |
385 /* | |
386 Catches: | |
387 InstantiationException | |
388 IllegalAccessException | |
389 */ | |
390 throw new WADLSException(WADLSException.CONFIGURATION_ERROR, | |
391 "Problem instantiating Java " + | |
392 "extensionType '" + extensionType.getName() + | |
393 "'.", | |
394 e); | |
395 } | |
396 } | |
397 | |
398 /** | |
399 * Declare that the type of the specified extension attribute, when it occurs | |
400 * as an attribute of the specified parent type, should be assumed to be | |
401 * attrType. | |
402 * | |
403 * @param parentType a class object indicating where in the WSDL | |
404 * document this extensibility attribute was encountered. For | |
405 * example, javax.wsdls.Binding.class would be used to indicate | |
406 * this attribute was defined on a <wsdl:binding> element. | |
407 * @param attrName the qname of the extensibility attribute | |
408 * @param attrType one of the constants defined on the AttributeExtensible | |
409 * class | |
410 * | |
411 * @see #queryExtensionAttributeType(Class, QName) | |
412 * @see AttributeExtensible | |
413 */ | |
414 public void registerExtensionAttributeType(Class parentType, | |
415 QName attrName, | |
416 int attrType) | |
417 { | |
418 Map innerExtensionAttributeTypeReg = | |
419 (Map)extensionAttributeTypeReg.get(parentType); | |
420 | |
421 if (innerExtensionAttributeTypeReg == null) | |
422 { | |
423 innerExtensionAttributeTypeReg = new Hashtable(); | |
424 | |
425 extensionAttributeTypeReg.put(parentType, innerExtensionAttributeTypeReg); | |
426 } | |
427 | |
428 innerExtensionAttributeTypeReg.put(attrName, new Integer(attrType)); | |
429 } | |
430 | |
431 /** | |
432 * Look up the type of the extensibility attribute with the qname attrName, | |
433 * which was defined on an element represented by the specified parentType. | |
434 * | |
435 * @param parentType a class object indicating where in the WSDL | |
436 * document this extensibility attribute was encountered. For | |
437 * example, javax.wsdls.Binding.class would be used to indicate | |
438 * this attribute was defined on a <wsdl:binding> element. | |
439 * @param attrName the qname of the extensibility attribute | |
440 * | |
441 * @return one of the constants defined on the AttributeExtensible class | |
442 * | |
443 * @see #registerExtensionAttributeType(Class, QName, int) | |
444 * @see AttributeExtensible | |
445 */ | |
446 public int queryExtensionAttributeType(Class parentType, QName attrName) | |
447 { | |
448 Map innerExtensionAttributeTypeReg = | |
449 (Map)extensionAttributeTypeReg.get(parentType); | |
450 Integer attrType = null; | |
451 | |
452 if (innerExtensionAttributeTypeReg != null) | |
453 { | |
454 attrType = (Integer)innerExtensionAttributeTypeReg.get(attrName); | |
455 } | |
456 | |
457 if (attrType != null) | |
458 { | |
459 return attrType.intValue(); | |
460 } | |
461 else | |
462 { | |
463 return AttributeExtensible.NO_DECLARED_TYPE; | |
464 } | |
465 } | |
466 } |