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

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
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 }