|
1
17 package org.apache.ws.jaxme.generator.sg.impl;
18
19 import java.util.HashMap  ;
20 import java.util.Map ;
21
22 import org.apache.ws.jaxme.generator.sg.ComplexTypeSG;
23 import org.apache.ws.jaxme.generator.sg.ComplexTypeSGChain;
24 import org.apache.ws.jaxme.generator.sg.Context;
25 import org.apache.ws.jaxme.generator.sg.SGFactory;
26 import org.apache.ws.jaxme.generator.sg.SchemaSG;
27 import org.apache.ws.jaxme.generator.sg.SimpleContentSG;
28 import org.apache.ws.jaxme.generator.sg.SimpleTypeSG;
29 import org.apache.ws.jaxme.generator.sg.SimpleTypeSGChain;
30 import org.apache.ws.jaxme.generator.sg.TypeSG;
31 import org.apache.ws.jaxme.generator.sg.TypeSGChain;
32 import org.apache.ws.jaxme.generator.types.Base64BinarySG;
33 import org.apache.ws.jaxme.generator.types.BooleanSG;
34 import org.apache.ws.jaxme.generator.types.ByteSG;
35 import org.apache.ws.jaxme.generator.types.DateSG;
36 import org.apache.ws.jaxme.generator.types.DateTimeSG;
37 import org.apache.ws.jaxme.generator.types.DecimalSG;
38 import org.apache.ws.jaxme.generator.types.DoubleSG;
39 import org.apache.ws.jaxme.generator.types.DurationSG;
40 import org.apache.ws.jaxme.generator.types.FloatSG;
41 import org.apache.ws.jaxme.generator.types.HexBinarySG;
42 import org.apache.ws.jaxme.generator.types.IDREFSG;
43 import org.apache.ws.jaxme.generator.types.IDSG;
44 import org.apache.ws.jaxme.generator.types.IntSG;
45 import org.apache.ws.jaxme.generator.types.IntegerSG;
46 import org.apache.ws.jaxme.generator.types.ListTypeSGImpl;
47 import org.apache.ws.jaxme.generator.types.LongSG;
48 import org.apache.ws.jaxme.generator.types.QNameSG;
49 import org.apache.ws.jaxme.generator.types.ShortSG;
50 import org.apache.ws.jaxme.generator.types.StringSG;
51 import org.apache.ws.jaxme.generator.types.TimeSG;
52 import org.apache.ws.jaxme.generator.types.UnionTypeSGImpl;
53 import org.apache.ws.jaxme.generator.types.UnsignedIntSG;
54 import org.apache.ws.jaxme.generator.types.UnsignedShortSG;
55 import org.apache.ws.jaxme.js.DirectAccessible;
56 import org.apache.ws.jaxme.js.JavaField;
57 import org.apache.ws.jaxme.js.JavaMethod;
58 import org.apache.ws.jaxme.js.JavaQName;
59 import org.apache.ws.jaxme.js.JavaQNameImpl;
60 import org.apache.ws.jaxme.js.JavaSource;
61 import org.apache.ws.jaxme.logging.Logger;
62 import org.apache.ws.jaxme.logging.LoggerAccess;
63 import org.apache.ws.jaxme.xs.XSEnumeration;
64 import org.apache.ws.jaxme.xs.XSSchema;
65 import org.apache.ws.jaxme.xs.XSSimpleType;
66 import org.apache.ws.jaxme.xs.XSType;
67 import org.apache.ws.jaxme.xs.jaxb.JAXBEnumeration;
68 import org.apache.ws.jaxme.xs.jaxb.JAXBGlobalBindings;
69 import org.apache.ws.jaxme.xs.jaxb.JAXBJavaType;
70 import org.apache.ws.jaxme.xs.jaxb.JAXBSchema;
71 import org.apache.ws.jaxme.xs.jaxb.JAXBSchemaBindings;
72 import org.apache.ws.jaxme.xs.jaxb.JAXBSimpleType;
73 import org.apache.ws.jaxme.xs.jaxb.JAXBType;
74 import org.apache.ws.jaxme.xs.jaxb.JAXBTypesafeEnumClass;
75 import org.apache.ws.jaxme.xs.types.XSAnySimpleType;
76 import org.apache.ws.jaxme.xs.types.XSAnyURI;
77 import org.apache.ws.jaxme.xs.types.XSBase64Binary;
78 import org.apache.ws.jaxme.xs.types.XSBoolean;
79 import org.apache.ws.jaxme.xs.types.XSByte;
80 import org.apache.ws.jaxme.xs.types.XSDate;
81 import org.apache.ws.jaxme.xs.types.XSDateTime;
82 import org.apache.ws.jaxme.xs.types.XSDecimal;
83 import org.apache.ws.jaxme.xs.types.XSDouble;
84 import org.apache.ws.jaxme.xs.types.XSDuration;
85 import org.apache.ws.jaxme.xs.types.XSEntity;
86 import org.apache.ws.jaxme.xs.types.XSFloat;
87 import org.apache.ws.jaxme.xs.types.XSGDay;
88 import org.apache.ws.jaxme.xs.types.XSGMonth;
89 import org.apache.ws.jaxme.xs.types.XSGMonthDay;
90 import org.apache.ws.jaxme.xs.types.XSGYear;
91 import org.apache.ws.jaxme.xs.types.XSGYearMonth;
92 import org.apache.ws.jaxme.xs.types.XSHexBinary;
93 import org.apache.ws.jaxme.xs.types.XSID;
94 import org.apache.ws.jaxme.xs.types.XSIDREF;
95 import org.apache.ws.jaxme.xs.types.XSInt;
96 import org.apache.ws.jaxme.xs.types.XSInteger;
97 import org.apache.ws.jaxme.xs.types.XSLanguage;
98 import org.apache.ws.jaxme.xs.types.XSLong;
99 import org.apache.ws.jaxme.xs.types.XSNCName;
100 import org.apache.ws.jaxme.xs.types.XSNMToken;
101 import org.apache.ws.jaxme.xs.types.XSName;
102 import org.apache.ws.jaxme.xs.types.XSNegativeInteger;
103 import org.apache.ws.jaxme.xs.types.XSNonNegativeInteger;
104 import org.apache.ws.jaxme.xs.types.XSNonPositiveInteger;
105 import org.apache.ws.jaxme.xs.types.XSNormalizedString;
106 import org.apache.ws.jaxme.xs.types.XSNotation;
107 import org.apache.ws.jaxme.xs.types.XSPositiveInteger;
108 import org.apache.ws.jaxme.xs.types.XSQName;
109 import org.apache.ws.jaxme.xs.types.XSShort;
110 import org.apache.ws.jaxme.xs.types.XSString;
111 import org.apache.ws.jaxme.xs.types.XSTime;
112 import org.apache.ws.jaxme.xs.types.XSToken;
113 import org.apache.ws.jaxme.xs.types.XSUnsignedByte;
114 import org.apache.ws.jaxme.xs.types.XSUnsignedInt;
115 import org.apache.ws.jaxme.xs.types.XSUnsignedLong;
116 import org.apache.ws.jaxme.xs.types.XSUnsignedShort;
117 import org.apache.ws.jaxme.xs.xml.XsQName;
118 import org.apache.ws.jaxme.xs.xml.XsSchemaHeader;
119 import org.xml.sax.Locator ;
120 import org.xml.sax.SAXException ;
121 import org.xml.sax.SAXParseException ;
122
123
127 public class JAXBTypeSG extends JAXBSGItem implements TypeSGChain {
128 private final static Logger log = LoggerAccess.getLogger(JAXBTypeSG.class);
129 private SimpleTypeSG simpleTypeSG;
130 private ComplexTypeSG complexTypeSG;
131 private final TypeSG restrictedType, extendedType;
132 private final Context classContext;
133 private final XSType xsType;
134 private boolean isGlobalClass;
135 private final XsQName name;
136 private Map properties;
137 private final XsSchemaHeader schemaHeader;
138
139
141 protected JAXBTypeSG(SGFactory pFactory, SchemaSG pSchema, XSType pType)
142 throws SAXException {
143 this(pFactory, pSchema, pType, null, pType.getName());
144 isGlobalClass = true;
145 }
146
147 protected JAXBTypeSG(SGFactory pFactory, SchemaSG pSchema, XSType pType, XsQName pName) throws SAXException {
148 this(pFactory, pSchema, pType, null, pName);
149 isGlobalClass = true;
150 }
151
152 private TypeSG getReferencedType(SGFactory pFactory, Context pClassContext,
153 XSType pReferencingType, XSType pReferencedType)
154 throws SAXException {
155 XsQName name = pReferencedType.getName();
156 TypeSG result;
157 if (pReferencedType.isGlobal()) {
158 result = pFactory.getTypeSG(pReferencedType);
159 if (result == null) {
160 throw new SAXParseException ("Unknown global type " + name,
161 pReferencingType.getLocator());
162 }
163 } else {
164 throw new IllegalStateException ("A referenced type must be global.");
165 }
166 return result;
167 }
168
169
172 protected JAXBTypeSG(SGFactory pFactory, SchemaSG pSchema, XSType pType, Context pClassContext, XsQName pName)
173 throws SAXException {
174 super(pFactory, pSchema, pType);
175 name = pName;
176 xsType = pType;
177 if (pType.isSimple()) {
178 if (pType.getSimpleType().isRestriction()) {
179 XSType restrictedXsType = pType.getSimpleType().getRestrictedType();
180 restrictedType = getReferencedType(pFactory, pClassContext, pType, restrictedXsType);
181 extendedType = null;
182 } else {
183 restrictedType = extendedType = null;
184 }
185 } else {
186 if (pType.getComplexType().isRestriction()) {
187 restrictedType = getReferencedType(pFactory, pClassContext, pType, pType.getComplexType().getRestrictedType());
188 extendedType = null;
189 } else if (pType.getComplexType().isExtension()) {
190 extendedType = getReferencedType(pFactory, pClassContext, pType, pType.getComplexType().getExtendedType());
191 restrictedType = null;
192 } else {
193 restrictedType = extendedType = null;
194 }
195 }
196 classContext = pClassContext;
197 schemaHeader = pType.getSchemaHeader();
198 }
199
200 public Object newComplexTypeSG(TypeSG pController) throws SAXException {
201 return classContext == null ? new JAXBComplexTypeSG(pController, xsType) :
202 new JAXBComplexTypeSG(pController, xsType, classContext);
203 }
204
205
206 protected XSType getXSType() { return (XSType) getXSObject(); }
207 public XsQName getName(TypeSG pController) { return name; }
208 public boolean isGlobalType(TypeSG pController) { return getXSType().isGlobal(); }
209 public boolean isGlobalClass(TypeSG pController) { return isGlobalClass; }
210 public boolean isComplex(TypeSG pController) { return !getXSType().isSimple(); }
211 public Locator getLocator(TypeSG pController) { return getLocator(); }
212 public SGFactory getFactory(TypeSG pController) { return getFactory(); }
213 public SchemaSG getSchema(TypeSG pController) { return getSchema(); }
214 public boolean isExtension(TypeSG pController) { return extendedType != null; }
215 public TypeSG getExtendedType(TypeSG pController) {
216 if (extendedType == null) {
217 throw new IllegalStateException ("This type is no extension.");
218 }
219 return extendedType;
220 }
221 public boolean isRestriction(TypeSG pController) { return restrictedType != null; }
222 public TypeSG getRestrictedType(TypeSG pController) {
223 if (restrictedType == null) {
224 throw new IllegalStateException ("This type is no restriction.");
225 }
226 return restrictedType;
227 }
228
229 public void init(TypeSG pController) throws SAXException {
230 final String mName = "init";
231 log.finest(mName, "->");
232 if (pController.isComplex()) {
233 ComplexTypeSGChain chain = (ComplexTypeSGChain) pController.newComplexTypeSG();
234 complexTypeSG = new ComplexTypeSGImpl(chain);
235 complexTypeSG.init();
236 } else {
237 SimpleTypeSGChain chain = (SimpleTypeSGChain) pController.newSimpleTypeSG();
238 simpleTypeSG = new SimpleTypeSGImpl(chain);
239 simpleTypeSG.init();
240 }
241 log.finest(mName, "<-");
242 }
243
244 public ComplexTypeSG getComplexTypeSG(TypeSG pController) { return complexTypeSG; }
245 public SimpleTypeSG getSimpleTypeSG(TypeSG pController) { return simpleTypeSG; }
246
247 public void generate(TypeSG pController) throws SAXException {
248 final String mName = "generate";
249 log.finest(mName, "->", pController.getName());
250 if (pController.isComplex()) {
251 ComplexTypeSG myComplexTypeSG = pController.getComplexTypeSG();
252 myComplexTypeSG.getXMLInterface();
253 myComplexTypeSG.getXMLImplementation();
254 myComplexTypeSG.getXMLSerializer();
255 myComplexTypeSG.getXMLHandler(myComplexTypeSG.getClassContext().getXMLHandlerName());
256 } else {
257 pController.getSimpleTypeSG().generate();
258 }
259 log.finest(mName, "<-");
260 }
261
262 public void generate(TypeSG pController, JavaSource pSource) throws SAXException {
263 final String mName = "generate(JavaSource)";
264 log.finest(mName, "->", new Object []{pController.getName(), pSource.getQName()});
265 if (pController.isComplex()) {
266 } else {
267 pController.getSimpleTypeSG().generate(pSource);
268 }
269
270 log.finest(mName, "<-");
271 }
272
273 public JavaField getXMLField(TypeSG pController, JavaSource pSource,
274 String pFieldName, String pDefaultValue) throws SAXException {
275 if (pSource.isInterface()) {
276 return null;
277 } else {
278 JavaQName runtimeType;
279 if (pController.isComplex() && pFieldName.equals("value") && pController.getComplexTypeSG().hasSimpleContent()) {
280 SimpleContentSG obj = pController.getComplexTypeSG().getSimpleContentSG();
281 runtimeType = obj.getContentTypeSG().getRuntimeType();
282 if (pController.isRestriction()) {
283 if (pController.getRestrictedType().isExtension()) {
284 runtimeType = pController.getRestrictedType().getExtendedType().getRuntimeType();
285 }
286 }
287 }
288 else {
289 runtimeType = pController.getRuntimeType();
290 }
291 JavaField jf = pSource.newJavaField(pFieldName, runtimeType, JavaSource.PRIVATE);
292 if (!pController.isComplex()) {
293 Object o = pController.getSimpleTypeSG().getInitialValue(pSource);
294 if (o == null && pDefaultValue != null) {
295 o = pController.getSimpleTypeSG().getCastFromString(pDefaultValue);
296 }
297 if (o != null) {
298 jf.addLine(o);
299 }
300 }
301 return jf;
302 }
303 }
304
305 public JavaMethod getXMLGetMethod(TypeSG pController, JavaSource pSource,
306 String pFieldName, String pMethodName) throws SAXException {
307 JavaQName runtimeType;
308 if (pController.isComplex() && pFieldName.equals("value") && pController.getComplexTypeSG().hasSimpleContent()) {
309 SimpleContentSG obj = pController.getComplexTypeSG().getSimpleContentSG();
310 runtimeType = obj.getContentTypeSG().getRuntimeType();
311 if (pController.isRestriction()) {
312 if (pController.getRestrictedType().isExtension()) {
313 runtimeType = pController.getRestrictedType().getExtendedType().getRuntimeType();
314 }
315 }
316 }
317 else {
318 runtimeType = pController.getRuntimeType();
319 }
320 JavaMethod jm = pSource.newJavaMethod(pMethodName, runtimeType, JavaSource.PUBLIC);
321 if (!pSource.isInterface()) {
322 jm.addLine("return " + pFieldName + ";");
323 }
324 return jm;
325 }
326
327 public JavaMethod getXMLSetMethod(TypeSG pController, JavaSource pSource,
328 String pFieldName, String pParamName,
329 String pMethodName,
330 boolean pSetIsSet) throws SAXException {
331 if (pController.isComplex()) {
332 JavaMethod jm = pSource.newJavaMethod(pMethodName, JavaQNameImpl.VOID, JavaSource.PUBLIC);
333 JavaQName runtimeType;
334 if (pFieldName.equals("value") && pController.getComplexTypeSG().hasSimpleContent()) {
335 SimpleContentSG obj = pController.getComplexTypeSG().getSimpleContentSG();
336 runtimeType = obj.getContentTypeSG().getRuntimeType();
337 if (pController.isRestriction()) {
338 if (pController.getRestrictedType().isExtension()) {
339 runtimeType = pController.getRestrictedType().getExtendedType().getRuntimeType();
340 }
341 }
342 }
343 else {
344 runtimeType = pController.getRuntimeType();
345 }
346 DirectAccessible param = jm.addParam(runtimeType, pParamName);
347 if (!pSource.isInterface()) {
348 jm.addLine(pFieldName, " = ", param, ";");
349 }
350 return jm;
351 } else {
352 JavaMethod jm = pController.getSimpleTypeSG().getXMLSetMethod(pSource, pFieldName, pParamName, pMethodName);
353 if (pSetIsSet && pController.getRuntimeType().isPrimitive()) {
354 jm.addLine(getIsSetCheckFieldName(pFieldName), " = true;");
355 }
356 return jm;
357 }
358 }
359
360 private String getIsSetCheckFieldName(String pFieldName) {
361 return "has" + Character.toUpperCase(pFieldName.charAt(0)) + pFieldName.substring(1);
362 }
363
364
368 public JavaMethod getXMLIsSetMethod(TypeSG pController, JavaSource pSource,
369 String pFieldName, String pMethodName)
370 throws SAXException {
371 JavaMethod jm = pSource.newJavaMethod(pMethodName, BooleanSG.BOOLEAN_TYPE, JavaSource.PUBLIC);
372 if (!pSource.isInterface()) {
373 if (pController.getRuntimeType().isPrimitive()) {
374 JavaField jf = pSource.newJavaField(getIsSetCheckFieldName(pFieldName), BooleanSG.BOOLEAN_TYPE);
375 jm.addLine("return ", jf, ";");
376 } else {
377 jm.addLine("return (" + pFieldName + " != null);");
378 }
379 }
380 return jm;
381 }
382
383 public JavaQName getRuntimeType(TypeSG pController) throws SAXException {
384 if (pController.isComplex()) {
385 return pController.getComplexTypeSG().getClassContext().getXMLInterfaceName();
386 } else {
387 return pController.getSimpleTypeSG().getRuntimeType();
388 }
389 }
390
391 private SimpleTypeSGChain newSimpleTypeSGByJavaType(JAXBJavaType pJavaType,
392 SGFactory pFactory,
393 SchemaSG pSchema,
394 XSType pType)
395 throws SAXException {
396 JavaQName qName = JavaQNameImpl.getInstance(pJavaType.getName(), true);
397 if (BooleanSG.BOOLEAN_TYPE.equals(qName)) {
398 return new BooleanSG(pFactory, pSchema, pType);
399 } else if (BooleanSG.BOOLEAN_OBJECT_TYPE.equals(qName)) {
400 BooleanSG result = new BooleanSG(pFactory, pSchema, pType);
401 result.setNullable(true);
402 return result;
403 } else if (ByteSG.BYTE_TYPE.equals(qName)) {
404 return new ByteSG(pFactory, pSchema, pType);
405 } else if (ByteSG.BYTE_OBJECT_TYPE.equals(qName)) {
406 ByteSG result = new ByteSG(pFactory, pSchema, pType);
407 result.setNullable(true);
408 return result;
409 } else if (ShortSG.SHORT_TYPE.equals(qName)) {
410 return new ShortSG(pFactory, pSchema, pType);
411 } else if (ShortSG.SHORT_OBJECT_TYPE.equals(qName)) {
412 ShortSG result = new ShortSG(pFactory, pSchema, pType);
413 result.setNullable(true);
414 return result;
415 } else if (IntSG.INT_TYPE.equals(qName)) {
416 return new IntSG(pFactory, pSchema, pType);
417 } else if (IntSG.INT_OBJECT_TYPE.equals(qName)) {
418 IntSG result = new IntSG(pFactory, pSchema, pType);
419 result.setNullable(true);
420 return result;
421 } else if (LongSG.LONG_TYPE.equals(qName)) {
422 return new LongSG(pFactory, pSchema, pType);
423 } else if (LongSG.LONG_OBJECT_TYPE.equals(qName)) {
424 LongSG result = new LongSG(pFactory, pSchema, pType);
425 result.setNullable(true);
426 return result;
427 } else if (FloatSG.FLOAT_TYPE.equals(qName)) {
428 return new FloatSG(pFactory, pSchema, pType);
429 } else if (FloatSG.FLOAT_OBJECT_TYPE.equals(qName)) {
430 FloatSG result = new FloatSG(pFactory, pSchema, pType);
431 result.setNullable(true);
432 return result;
433 } else if (DoubleSG.DOUBLE_TYPE.equals(qName)) {
434 return new DoubleSG(pFactory, pSchema, pType);
435 } else if (DoubleSG.DOUBLE_OBJECT_TYPE.equals(qName)) {
436 DoubleSG result = new DoubleSG(pFactory, pSchema, pType);
437 result.setNullable(true);
438 return result;
439 } else if (StringSG.STRING_TYPE.equals(qName)) {
440 return new StringSG(pFactory, pSchema, pType);
441 } else if (IntegerSG.INTEGER_TYPE.equals(qName)) {
442 return new IntegerSG(pFactory, pSchema, pType);
443 } else if (DecimalSG.DECIMAL_TYPE.equals(qName)) {
444 return new DecimalSG(pFactory, pSchema, pType);
445 } else if (QNameSG.QNAME_TYPE.equals(qName)) {
446 return new QNameSG(pFactory, pSchema, pType);
447 } else if (DateTimeSG.CALENDAR_TYPE.equals(qName)) {
448 return new DateTimeSG(pFactory, pSchema, pType);
449 } else {
450 return null;
451 }
452 }
453
454 private SimpleTypeSGChain newGlobalAtomicTypeSG(SGFactory pFactory,
455 SchemaSG pSchema,
456 XSType pType)
457 throws SAXException {
458 if (!pType.isGlobal()) {
459 return null;
460 }
461 XsQName myName = pType.getName();
462 if (myName.equals(XSNotation.getInstance().getName()) ||
463 myName.equals(XSGYearMonth.getInstance().getName()) ||
464 myName.equals(XSGYear.getInstance().getName()) ||
465 myName.equals(XSGMonthDay.getInstance().getName()) ||
466 myName.equals(XSGMonth.getInstance().getName()) ||
467 myName.equals(XSGDay.getInstance().getName())) {
468 throw new SAXException ("The type " + myName + " is not supported.");
469 } else if (myName.equals(XSIDREF.getInstance().getName())) {
470 return new IDREFSG(pFactory, pSchema, pType);
471 } else if (myName.equals(XSID.getInstance().getName())) {
472 return new IDSG(pFactory, pSchema, pType);
473 } else if (myName.equals(XSByte.getInstance().getName())) {
474 return new ByteSG(pFactory, pSchema, pType);
475 } else if (myName.equals(XSShort.getInstance().getName())) {
476 return new ShortSG(pFactory, pSchema, pType);
477 } else if (myName.equals(XSInt.getInstance().getName())) {
478 return new IntSG(pFactory, pSchema, pType);
479 } else if (myName.equals(XSLong.getInstance().getName())) {
480 return new LongSG(pFactory, pSchema, pType);
481 } else if (myName.equals(XSUnsignedByte.getInstance().getName()) ||
482 myName.equals(XSUnsignedShort.getInstance().getName())) {
483 return new UnsignedShortSG(pFactory, pSchema, pType);
484 } else if (myName.equals(XSUnsignedInt.getInstance().getName())) {
485 return new UnsignedIntSG(pFactory, pSchema, pType);
486 } else if (myName.equals(XSInteger.getInstance().getName()) ||
487 myName.equals(XSNonPositiveInteger.getInstance().getName()) ||
488 myName.equals(XSNegativeInteger.getInstance().getName()) ||
489 myName.equals(XSUnsignedLong.getInstance().getName()) ||
490 myName.equals(XSPositiveInteger.getInstance().getName()) ||
491 myName.equals(XSNonNegativeInteger.getInstance().getName())) {
492 return new IntegerSG(pFactory, pSchema, pType);
493 } else if (myName.equals(XSDecimal.getInstance().getName())) {
494 return new DecimalSG(pFactory, pSchema, pType);
495 } else if (myName.equals(XSQName.getInstance().getName())) {
496 return new QNameSG(pFactory, pSchema, pType);
497 } else if (myName.equals(XSDouble.getInstance().getName())) {
498 return new DoubleSG(pFactory, pSchema, pType);
499 } else if (myName.equals(XSFloat.getInstance().getName())) {
500 return new FloatSG(pFactory, pSchema, pType);
501 } else if (myName.equals(XSHexBinary.getInstance().getName())) {
502 return new HexBinarySG(pFactory, pSchema, pType);
503 } else if (myName.equals(XSBase64Binary.getInstance().getName())) {
504 return new Base64BinarySG(pFactory, pSchema, pType);
505 } else if (myName.equals(XSBoolean.getInstance().getName())) {
506 return new BooleanSG(pFactory, pSchema, pType);
507 } else if (myName.equals(XSDate.getInstance().getName())) {
508 return new DateSG(pFactory, pSchema, pType);
509 } else if (myName.equals(XSDateTime.getInstance().getName())) {
510 return new DateTimeSG(pFactory, pSchema, pType);
511 } else if (myName.equals(XSTime.getInstance().getName())) {
512 return new TimeSG(pFactory, pSchema, pType);
513 } else if (myName.equals(XSDuration.getInstance().getName())) {
514 return new DurationSG(pFactory, pSchema, pType);
515 } else if (myName.equals(XSAnySimpleType.getInstance().getName()) ||
516 myName.equals(XSString.getInstance().getName()) ||
517 myName.equals(XSAnyURI.getInstance().getName()) ||
518 myName.equals(XSNormalizedString.getInstance().getName()) ||
519 myName.equals(XSToken.getInstance().getName()) ||
520 myName.equals(XSLanguage.getInstance().getName()) ||
521 myName.equals(XSName.getInstance().getName()) ||
522 myName.equals(XSNMToken.getInstance().getName()) ||
523 myName.equals(XSNCName.getInstance().getName()) ||
524 myName.equals(XSEntity.getInstance().getName())) {
525 return new StringSG(pFactory, pSchema, pType);
526 } else {
527 return null;
528 }
529 }
530
531 private SimpleTypeSGChain newAtomicTypeRestriction(TypeSG pController,
532 SGFactory pFactory,
533 SchemaSG pSchema,
534 XSType pType)
535 throws SAXException {
536 XSSimpleType simpleType = pType.getSimpleType();
537 SimpleTypeSGChain result = newSimpleTypeSG(pController, pFactory, pSchema, simpleType.getRestrictedType());
538 result = new SimpleTypeRestrictionSG(result, pType, simpleType);
539
540 if (simpleType.getEnumerations().length > 0) {
541 boolean generateTypesafeEnumClass = false;
542 String className = null;
543
544 if (simpleType instanceof JAXBSimpleType) {
545 JAXBSimpleType jaxbSimpleType = (JAXBSimpleType) simpleType;
546 JAXBTypesafeEnumClass jaxbTypesafeEnumClass = jaxbSimpleType.getJAXBTypesafeEnumClass();
547 if (jaxbTypesafeEnumClass != null) {
548 generateTypesafeEnumClass = true;
549 className = jaxbTypesafeEnumClass.getName();
550 }
551 }
552
553 if (!generateTypesafeEnumClass) {
554 XSEnumeration[] enumerations = simpleType.getEnumerations();
555 for (int i = 0; i < enumerations.length; i++) {
556 XSEnumeration enumeration = enumerations[i];
557 if (enumeration instanceof JAXBEnumeration) {
558 JAXBEnumeration jaxbEnumeration = (JAXBEnumeration) enumeration;
559 if (jaxbEnumeration.getJAXBTypesafeEnumMember() != null) {
560 generateTypesafeEnumClass = true;
561 break;
562 }
563 }
564 }
565 }
566
567 if (!generateTypesafeEnumClass && pType.isGlobal()) {
568 XsQName[] qNames = new XsQName[]{XSNMToken.getInstance().getName()};
569 XSSchema xsSchema = xsType.getXSSchema();
570 if (xsSchema instanceof JAXBSchema) {
571 JAXBSchema jaxbSchema = (JAXBSchema) xsSchema;
572 JAXBGlobalBindings globalBindings = jaxbSchema.getJAXBGlobalBindings();
573 if (globalBindings != null) {
574 qNames = globalBindings.getTypesafeEnumBase();
575 }
576 }
577
578 for (XSType restrType = xsType; !generateTypesafeEnumClass; ) {
579 restrType = restrType.getSimpleType().getRestrictedType();
580 if (restrType.isGlobal()) {
581 for (int i = 0; i < qNames.length; i++) {
582 if (qNames[i].equals(restrType.getName())) {
583 generateTypesafeEnumClass = true;
584 break;
585 }
586 }
587 if (XSAnySimpleType.getInstance().getName().equals(restrType.getName())) {
588 break;
589 }
590 }
591 }
592 }
593
594 JAXBSchemaBindings jaxbSchemaBindings;
595 if (xsType instanceof JAXBType) {
596 jaxbSchemaBindings = ((JAXBType) xsType).getJAXBSchemaBindings();
597 } else {
598 jaxbSchemaBindings = null;
599 }
600
601 if (generateTypesafeEnumClass) {
602 if (className == null) {
603 XsQName qName = pType.isGlobal() ? pType.getName() : pController.getName();
604 className = AbstractContext.getClassNameFromLocalName(pController.getLocator(),
605 qName.getLocalName(),
606 pSchema) + "Class";
607 }
608 JavaQName qName;
609 if (classContext == null) {
610 String packageName = AbstractContext.getPackageName(pSchema,
611 jaxbSchemaBindings,
612 pController.getLocator(),
613 pController.getName());
614 qName = JavaQNameImpl.getInstance(packageName, className);
615 } else {
616 JavaQName elementClassName = classContext.getXMLInterfaceName();
617 if (elementClassName == null) {
618 elementClassName = classContext.getXMLImplementationName();
619 }
620 qName = JavaQNameImpl.getInstance(elementClassName.getPackageName(), className);
621 }
622 result = new EnumerationSG(result, qName, pType);
623 }
624 }
625
626 return result;
627 }
628
629 private JAXBJavaType findJavaType(SchemaSG pSchema, XSType pType)
630 throws SAXException {
631 JAXBJavaType[] globalJavaTypes = pSchema.getJAXBJavaTypes();
632
633 for (XSType currentType = pType; currentType != null; ) {
634 if (currentType instanceof JAXBType) {
635 JAXBType jaxbType = (JAXBType) currentType;
636 JAXBJavaType jaxbJavaType = jaxbType.getJAXBJavaType();
637 if (jaxbJavaType == null) {
638 return jaxbJavaType;
639 }
640 }
641 for (int i = 0; i < globalJavaTypes.length; i++) {
642 if (globalJavaTypes[i].getXmlType().equals(currentType.getName())) {
643 return globalJavaTypes[i];
644 }
645 }
646 XSSimpleType simpleType = currentType.getSimpleType();
647 if (simpleType.isRestriction()) {
648 currentType = simpleType.getRestrictedType();
649 } else {
650 currentType = null;
651 }
652 }
653 return null;
654 }
655
656 private SimpleTypeSGChain newSimpleTypeSG(TypeSG pController, SGFactory pFactory,
657 SchemaSG pSchema, XSType pType) throws SAXException {
658 if (!pType.isSimple()) {
659 throw new IllegalStateException ("Expected a simple type");
660 }
661
662 JAXBJavaType javaType = findJavaType(pSchema, pType);
663 SimpleTypeSGChain result;
664 if (javaType == null || javaType.getName() == null) {
665 XSSimpleType simpleType = pType.getSimpleType();
666 JavaQName runtimeType;
667 if (simpleType.isAtomic()) {
668 result = newGlobalAtomicTypeSG(pFactory, pSchema, pType);
669 if (result == null) {
670 if (!simpleType.isRestriction()) {
671 throw new SAXParseException ("Atomic type must be either a builtin or a restriction of another atomic type",
672 pType.getLocator());
673 }
674 TypeSG type = pSchema.getType(simpleType.getRestrictedType().getName());
675 runtimeType = type.getSimpleTypeSG().getRuntimeType();
676 result = newAtomicTypeRestriction(pController, pFactory, pSchema, pType);
677 } else {
678 SimpleTypeSG simpleTypeSG = new SimpleTypeSGImpl(result);
679 simpleTypeSG.init();
680 runtimeType = simpleTypeSG.getRuntimeType();
681 }
682 if (javaType == null) {
683 JAXBJavaType[] globalJavaTypes = pSchema.getJAXBJavaTypes();
684 for (int i = 0; i < globalJavaTypes.length; i++) {
685 if (runtimeType.equals(globalJavaTypes[i].getName())) {
686 javaType = globalJavaTypes[i];
687 break;
688 }
689 }
690 }
691 } else if (simpleType.isList()) {
692 result = new ListTypeSGImpl(pFactory, pSchema, pType, classContext, pController.getName());
693 } else if (simpleType.isUnion()) {
694 result = new UnionTypeSGImpl(pFactory, pSchema, pType, classContext, pController.getName());
695 } else {
696 throw new IllegalStateException ("Simple type " + pType + " is neither of atomic, list, or union");
697 }
698 } else {
699 result = newSimpleTypeSGByJavaType(javaType, pFactory, pSchema, pType);
700 }
701
702 if (javaType != null &&
703 (javaType.getParseMethod() != null || javaType.getPrintMethod() != null)) {
704 result = new ParsePrintSG(result, javaType);
705 }
706 return result;
707 }
708
709 public Object newSimpleTypeSG(TypeSG pController) throws SAXException {
710 final String mName = "newSimpleTypeSG";
711 log.finest(mName, "->");
712 SchemaSG schema = pController.getSchema();
713 SimpleTypeSGChain result = newSimpleTypeSG(pController, schema.getFactory(), schema, xsType);
714 log.finest(mName, "<-", result);
715 return result;
716 }
717
718 public Object getProperty(TypeSG pController, String pName) {
719 if (properties == null) {
720 return null;
721 }
722 return properties.get(pName);
723 }
724
725 public void setProperty(TypeSG pController, String pName, Object pValue) {
726 if (properties == null) {
727 properties = new HashMap ();
728 }
729 properties.put(pName, pValue);
730 }
731
732 public XsSchemaHeader getSchemaHeader(TypeSG pController) {
733 return schemaHeader;
734 }
735 }
736 |
Popular Tags |
Java API By Example, From Geeks To Geeks.