Java > Open Source Codes > org > dom4j > datatype > SchemaParser


1 /*
2  * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
3  *
4  * This software is open source.
5  * See the bottom of this file for the licence.
6  */
7
8 package org.dom4j.datatype;
9
10 import com.sun.msv.datatype.xsd.DatatypeFactory;
11 import com.sun.msv.datatype.xsd.TypeIncubator;
12 import com.sun.msv.datatype.xsd.XSDatatype;
13
14 import java.util.HashMap ;
15 import java.util.Iterator ;
16 import java.util.Map ;
17
18 import org.dom4j.Attribute;
19 import org.dom4j.Document;
20 import org.dom4j.DocumentFactory;
21 import org.dom4j.Element;
22 import org.dom4j.Namespace;
23 import org.dom4j.QName;
24 import org.dom4j.io.SAXReader;
25 import org.dom4j.util.AttributeHelper;
26
27 import org.relaxng.datatype.DatatypeException;
28 import org.relaxng.datatype.ValidationContext;
29
30 import org.xml.sax.EntityResolver ;
31 import org.xml.sax.InputSource ;
32
33 /**
34  * <p>
35  * <code>SchemaParser</code> reads an XML Schema Document.
36  * </p>
37  *
38  * @author <a HREF="mailto:jstrachan@apache.org">James Strachan </a>
39  * @author Yuxin Ruan
40  * @version $Revision: 1.19 $
41  */
42 public class SchemaParser {
43     private static final Namespace XSD_NAMESPACE = Namespace.get("xsd",
44             "http://www.w3.org/2001/XMLSchema");
45
46     // Use QNames for the elements
47 private static final QName XSD_ELEMENT = QName
48             .get("element", XSD_NAMESPACE);
49
50     private static final QName XSD_ATTRIBUTE = QName.get("attribute",
51             XSD_NAMESPACE);
52
53     private static final QName XSD_SIMPLETYPE = QName.get("simpleType",
54             XSD_NAMESPACE);
55
56     private static final QName XSD_COMPLEXTYPE = QName.get("complexType",
57             XSD_NAMESPACE);
58
59     private static final QName XSD_RESTRICTION = QName.get("restriction",
60             XSD_NAMESPACE);
61
62     private static final QName XSD_SEQUENCE = QName.get("sequence",
63             XSD_NAMESPACE);
64
65     private static final QName XSD_CHOICE = QName.get("choice", XSD_NAMESPACE);
66
67     private static final QName XSD_ALL = QName.get("all", XSD_NAMESPACE);
68
69     private static final QName XSD_INCLUDE = QName
70             .get("include", XSD_NAMESPACE);
71
72     /** Document factory used to register Element specific factories */
73     private DatatypeDocumentFactory documentFactory;
74
75     /**
76      * Cache of <code>XSDatatype</code> instances loaded or created during
77      * this build
78      */
79     private Map dataTypeCache = new HashMap ();
80
81     /** NamedTypeResolver */
82     private NamedTypeResolver namedTypeResolver;
83
84     /** target namespace */
85     private Namespace targetNamespace;
86
87     public SchemaParser() {
88         this(DatatypeDocumentFactory.singleton);
89     }
90
91     public SchemaParser(DatatypeDocumentFactory documentFactory) {
92         this.documentFactory = documentFactory;
93         this.namedTypeResolver = new NamedTypeResolver(documentFactory);
94     }
95
96     /**
97      * Parses the given schema document
98      *
99      * @param schemaDocument
100      * is the document of the XML Schema
101      */
102     public void build(Document schemaDocument) {
103         this.targetNamespace = null;
104         internalBuild(schemaDocument);
105     }
106
107     public void build(Document schemaDocument, Namespace namespace) {
108         this.targetNamespace = namespace;
109         internalBuild(schemaDocument);
110     }
111
112     private synchronized void internalBuild(Document schemaDocument) {
113         Element root = schemaDocument.getRootElement();
114
115         if (root != null) {
116             // handle schema includes
117 Iterator includeIter = root.elementIterator(XSD_INCLUDE);
118
119             while (includeIter.hasNext()) {
120                 Element includeElement = (Element) includeIter.next();
121                 String inclSchemaInstanceURI = includeElement
122                         .attributeValue("schemaLocation");
123                 EntityResolver resolver = schemaDocument.getEntityResolver();
124
125                 try {
126                     if (resolver == null) {
127                         String msg = "No EntityResolver available";
128                         throw new InvalidSchemaException(msg);
129                     }
130
131                     InputSource inputSource = resolver.resolveEntity(null,
132                             inclSchemaInstanceURI);
133
134                     if (inputSource == null) {
135                         String msg = "Could not resolve the schema URI: "
136                                 + inclSchemaInstanceURI;
137                         throw new InvalidSchemaException(msg);
138                     }
139
140                     SAXReader reader = new SAXReader();
141                     Document inclSchemaDocument = reader.read(inputSource);
142                     build(inclSchemaDocument);
143                 } catch (Exception e) {
144                     System.out.println("Failed to load schema: "
145                             + inclSchemaInstanceURI);
146                     System.out.println("Caught: " + e);
147                     e.printStackTrace();
148                     throw new InvalidSchemaException("Failed to load schema: "
149                             + inclSchemaInstanceURI);
150                 }
151             }
152
153             // handle elements
154 Iterator iter = root.elementIterator(XSD_ELEMENT);
155
156             while (iter.hasNext()) {
157                 onDatatypeElement((Element) iter.next(), documentFactory);
158             }
159
160             // handle named simple types
161 iter = root.elementIterator(XSD_SIMPLETYPE);
162
163             while (iter.hasNext()) {
164                 onNamedSchemaSimpleType((Element) iter.next());
165             }
166
167             // hanlde named complex types
168 iter = root.elementIterator(XSD_COMPLEXTYPE);
169
170             while (iter.hasNext()) {
171                 onNamedSchemaComplexType((Element) iter.next());
172             }
173
174             namedTypeResolver.resolveNamedTypes();
175         }
176     }
177
178     // Implementation methods
179 // -------------------------------------------------------------------------
180
181     /**
182      * processes an XML Schema &lt;element&gt; tag
183      *
184      * @param xsdElement
185      * DOCUMENT ME!
186      * @param parentFactory
187      * DOCUMENT ME!
188      */
189     private void onDatatypeElement(Element xsdElement,
190             DocumentFactory parentFactory) {
191         String name = xsdElement.attributeValue("name");
192         String type = xsdElement.attributeValue("type");
193         QName qname = getQName(name);
194
195         DatatypeElementFactory factory = getDatatypeElementFactory(qname);
196
197         if (type != null) {
198             // register type with this element name
199 XSDatatype dataType = getTypeByName(type);
200
201             if (dataType != null) {
202                 factory.setChildElementXSDatatype(qname, dataType);
203             } else {
204                 QName typeQName = getQName(type);
205                 namedTypeResolver.registerTypedElement(xsdElement, typeQName,
206                         parentFactory);
207             }
208
209             return;
210         }
211
212         // handle element types derrived from simpleTypes
213 Element xsdSimpleType = xsdElement.element(XSD_SIMPLETYPE);
214
215         if (xsdSimpleType != null) {
216             XSDatatype dataType = loadXSDatatypeFromSimpleType(xsdSimpleType);
217
218             if (dataType != null) {
219                 factory.setChildElementXSDatatype(qname, dataType);
220             }
221         }
222
223         Element schemaComplexType = xsdElement.element(XSD_COMPLEXTYPE);
224
225         if (schemaComplexType != null) {
226             onSchemaComplexType(schemaComplexType, factory);
227         }
228
229         Iterator iter = xsdElement.elementIterator(XSD_ATTRIBUTE);
230
231         if (iter.hasNext()) {
232             do {
233                 onDatatypeAttribute(xsdElement, factory, (Element) iter
234                         .next());
235             } while (iter.hasNext());
236         }
237     }
238
239     /**
240      * processes an named XML Schema &lt;complexTypegt; tag
241      *
242      * @param schemaComplexType
243      * DOCUMENT ME!
244      */
245     private void onNamedSchemaComplexType(Element schemaComplexType) {
246         Attribute nameAttr = schemaComplexType.attribute("name");
247
248         if (nameAttr == null) {
249             return;
250         }
251
252         String name = nameAttr.getText();
253         QName qname = getQName(name);
254
255         DatatypeElementFactory factory = getDatatypeElementFactory(qname);
256
257         onSchemaComplexType(schemaComplexType, factory);
258         namedTypeResolver.registerComplexType(qname, factory);
259     }
260
261     /**
262      * processes an XML Schema &lt;complexTypegt; tag
263      *
264      * @param schemaComplexType
265      * DOCUMENT ME!
266      * @param elementFactory
267      * DOCUMENT ME!
268      */
269     private void onSchemaComplexType(Element schemaComplexType,
270             DatatypeElementFactory elementFactory) {
271         Iterator iter = schemaComplexType.elementIterator(XSD_ATTRIBUTE);
272
273         while (iter.hasNext()) {
274             Element xsdAttribute = (Element) iter.next();
275             String name = xsdAttribute.attributeValue("name");
276             QName qname = getQName(name);
277
278             XSDatatype dataType = dataTypeForXsdAttribute(xsdAttribute);
279
280             if (dataType != null) {
281                 // register the XSDatatype for the given Attribute
282 // #### should both these be done?
283 // elementFactory.setChildElementXSDatatype( qname, dataType );
284 elementFactory.setAttributeXSDatatype(qname, dataType);
285             }
286         }
287
288         // handle sequence definition
289 Element schemaSequence = schemaComplexType.element(XSD_SEQUENCE);
290
291         if (schemaSequence != null) {
292             onChildElements(schemaSequence, elementFactory);
293         }
294
295         // handle choice definition
296 Element schemaChoice = schemaComplexType.element(XSD_CHOICE);
297
298         if (schemaChoice != null) {
299             onChildElements(schemaChoice, elementFactory);
300         }
301
302         // handle all definition
303 Element schemaAll = schemaComplexType.element(XSD_ALL);
304
305         if (schemaAll != null) {
306             onChildElements(schemaAll, elementFactory);
307         }
308     }
309
310     private void onChildElements(Element element, DatatypeElementFactory fact) {
311         Iterator iter = element.elementIterator(XSD_ELEMENT);
312
313         while (iter.hasNext()) {
314             Element xsdElement = (Element) iter.next();
315             onDatatypeElement(xsdElement, fact);
316         }
317     }
318
319     /**
320      * processes an XML Schema &lt;attribute&gt; tag
321      *
322      * @param xsdElement
323      * DOCUMENT ME!
324      * @param elementFactory
325      * DOCUMENT ME!
326      * @param xsdAttribute
327      * DOCUMENT ME!
328      */
329     private void onDatatypeAttribute(Element xsdElement,
330             DatatypeElementFactory elementFactory, Element xsdAttribute) {
331         String name = xsdAttribute.attributeValue("name");
332         QName qname = getQName(name);
333         XSDatatype dataType = dataTypeForXsdAttribute(xsdAttribute);
334
335         if (dataType != null) {
336             // register the XSDatatype for the given Attribute
337 elementFactory.setAttributeXSDatatype(qname, dataType);
338         } else {
339             String type = xsdAttribute.attributeValue("type");
340             System.out.println("Warning: Couldn't find XSDatatype for type: "
341                     + type + " attribute: " + name);
342         }
343     }
344
345     /**
346      * processes an XML Schema &lt;attribute&gt; tag
347      *
348      * @param xsdAttribute
349      * DOCUMENT ME!
350      *
351      * @return DOCUMENT ME!
352      *
353      * @throws InvalidSchemaException
354      * DOCUMENT ME!
355      */
356     private XSDatatype dataTypeForXsdAttribute(Element xsdAttribute) {
357         String type = xsdAttribute.attributeValue("type");
358         XSDatatype dataType = null;
359
360         if (type != null) {
361             dataType = getTypeByName(type);
362         } else {
363             // must parse the <simpleType> element
364 Element xsdSimpleType = xsdAttribute.element(XSD_SIMPLETYPE);
365
366             if (xsdSimpleType == null) {
367                 String name = xsdAttribute.attributeValue("name");
368                 String msg = "The attribute: " + name
369                         + " has no type attribute and does not contain a "
370                         + "<simpleType/> element";
371                 throw new InvalidSchemaException(msg);
372             }
373
374             dataType = loadXSDatatypeFromSimpleType(xsdSimpleType);
375         }
376
377         return dataType;
378     }
379
380     /**
381      * processes an named XML Schema &lt;simpleTypegt; tag
382      *
383      * @param schemaSimpleType
384      * DOCUMENT ME!
385      */
386     private void onNamedSchemaSimpleType(Element schemaSimpleType) {
387         Attribute nameAttr = schemaSimpleType.attribute("name");
388
389         if (nameAttr == null) {
390             return;
391         }
392
393         String name = nameAttr.getText();
394         QName qname = getQName(name);
395         XSDatatype datatype = loadXSDatatypeFromSimpleType(schemaSimpleType);
396         namedTypeResolver.registerSimpleType(qname, datatype);
397     }
398
399     /**
400      * Loads a XSDatatype object from a &lt;simpleType&gt; attribute schema
401      * element
402      *
403      * @param xsdSimpleType
404      * DOCUMENT ME!
405      *
406      * @return DOCUMENT ME!
407      */
408     private XSDatatype loadXSDatatypeFromSimpleType(Element xsdSimpleType) {
409         Element xsdRestriction = xsdSimpleType.element(XSD_RESTRICTION);
410
411         if (xsdRestriction != null) {
412             String base = xsdRestriction.attributeValue("base");
413
414             if (base != null) {
415                 XSDatatype baseType = getTypeByName(base);
416
417                 if (baseType == null) {
418                     onSchemaError("Invalid base type: " + base
419                             + " when trying to build restriction: "
420                             + xsdRestriction);
421                 } else {
422                     return deriveSimpleType(baseType, xsdRestriction);
423                 }
424             } else {
425                 // simpleType and base are mutually exclusive and you
426 // must have one within a <restriction> tag
427 Element xsdSubType = xsdSimpleType.element(XSD_SIMPLETYPE);
428
429                 if (xsdSubType == null) {
430                     String msg = "The simpleType element: " + xsdSimpleType
431                             + " must contain a base attribute or simpleType"
432                             + " element";
433                     onSchemaError(msg);
434                 } else {
435                     return loadXSDatatypeFromSimpleType(xsdSubType);
436                 }
437             }
438         } else {
439             onSchemaError("No <restriction>. Could not create XSDatatype for"
440                     + " simpleType: " + xsdSimpleType);
441         }
442
443         return null;
444     }
445
446     /**
447      * Derives a new type from a base type and a set of restrictions
448      *
449      * @param baseType
450      * DOCUMENT ME!
451      * @param xsdRestriction
452      * DOCUMENT ME!
453      *
454      * @return DOCUMENT ME!
455      */
456     private XSDatatype deriveSimpleType(XSDatatype baseType,
457             Element xsdRestriction) {
458         TypeIncubator incubator = new TypeIncubator(baseType);
459         ValidationContext context = null;
460
461         try {
462             for (Iterator iter = xsdRestriction.elementIterator(); iter
463                     .hasNext();) {
464                 Element element = (Element) iter.next();
465                 String name = element.getName();
466                 String value = element.attributeValue("value");
467                 boolean fixed = AttributeHelper.booleanValue(element, "fixed");
468
469                 // add facet
470 incubator.addFacet(name, value, fixed, context);
471             }
472
473             // derive a new type by those facets
474 String newTypeName = null;
475
476             return incubator.derive("", newTypeName);
477         } catch (DatatypeException e) {
478             onSchemaError("Invalid restriction: " + e.getMessage()
479                     + " when trying to build restriction: " + xsdRestriction);
480
481             return null;
482         }
483     }
484
485     /**
486      * DOCUMENT ME!
487      *
488      * @param name
489      * The name of the element
490      *
491      * @return the <code>DatatypeElementFactory</code> for the given element
492      * QName, creating one if it does not already exist
493      */
494     private DatatypeElementFactory getDatatypeElementFactory(QName name) {
495         DatatypeElementFactory factory = documentFactory
496                 .getElementFactory(name);
497
498         if (factory == null) {
499             factory = new DatatypeElementFactory(name);
500             name.setDocumentFactory(factory);
501         }
502
503         return factory;
504     }
505
506     private XSDatatype getTypeByName(String type) {
507         XSDatatype dataType = (XSDatatype) dataTypeCache.get(type);
508
509         if (dataType == null) {
510             // first check to see if it is a built-in type
511 // maybe a prefix is being used
512 int idx = type.indexOf(':');
513
514             if (idx >= 0) {
515                 String localName = type.substring(idx + 1);
516
517                 try {
518                     dataType = DatatypeFactory.getTypeByName(localName);
519                 } catch (DatatypeException e) {
520                 }
521             }
522
523             if (dataType == null) {
524                 try {
525                     dataType = DatatypeFactory.getTypeByName(type);
526                 } catch (DatatypeException e) {
527                 }
528             }
529
530             if (dataType == null) {
531                 // it's no built-in type, maybe it's a type we defined ourself
532 QName typeQName = getQName(type);
533                 dataType = (XSDatatype) namedTypeResolver.simpleTypeMap
534                         .get(typeQName);
535             }
536
537             if (dataType != null) {
538                 // store in cache for later
539 dataTypeCache.put(type, dataType);
540             }
541         }
542
543         return dataType;
544     }
545
546     private QName getQName(String name) {
547         if (targetNamespace == null) {
548             return documentFactory.createQName(name);
549         } else {
550             return documentFactory.createQName(name, targetNamespace);
551         }
552     }
553
554     /**
555      * Called when there is a problem with the schema and the builder cannot
556      * handle the XML Schema Data Types correctly
557      *
558      * @param message
559      * DOCUMENT ME!
560      *
561      * @throws InvalidSchemaException
562      * DOCUMENT ME!
563      */
564     private void onSchemaError(String message) {
565         // Some users may wish to disable exception throwing
566 // and instead use some kind of listener for errors and continue
567 // System.out.println( "WARNING: " + message );
568 throw new InvalidSchemaException(message);
569     }
570 }
571
572 /*
573  * Redistribution and use of this software and associated documentation
574  * ("Software"), with or without modification, are permitted provided that the
575  * following conditions are met:
576  *
577  * 1. Redistributions of source code must retain copyright statements and
578  * notices. Redistributions must also contain a copy of this document.
579  *
580  * 2. Redistributions in binary form must reproduce the above copyright notice,
581  * this list of conditions and the following disclaimer in the documentation
582  * and/or other materials provided with the distribution.
583  *
584  * 3. The name "DOM4J" must not be used to endorse or promote products derived
585  * from this Software without prior written permission of MetaStuff, Ltd. For
586  * written permission, please contact dom4j-info@metastuff.com.
587  *
588  * 4. Products derived from this Software may not be called "DOM4J" nor may
589  * "DOM4J" appear in their names without prior written permission of MetaStuff,
590  * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
591  *
592  * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
593  *
594  * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
595  * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
596  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
597  * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
598  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
599  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
600  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
601  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
602  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
603  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
604  * POSSIBILITY OF SUCH DAMAGE.
605  *
606  * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
607  */
608

A to Z: JavaDoc & Examples

---

Daily Java News & Articles

---

Open Source Projects

---

Open Source Codes

---

Free Computer Books

---

Remove Frame

---

Popular Tags