001    //$HeadURL: svn+ssh://jwilden@svn.wald.intevation.org/deegree/base/branches/2.5_testing/src/org/deegree/framework/xml/schema/XSDocument.java $
002    /*----------------------------------------------------------------------------
003     This file is part of deegree, http://deegree.org/
004     Copyright (C) 2001-2009 by:
005       Department of Geography, University of Bonn
006     and
007       lat/lon GmbH
008    
009     This library is free software; you can redistribute it and/or modify it under
010     the terms of the GNU Lesser General Public License as published by the Free
011     Software Foundation; either version 2.1 of the License, or (at your option)
012     any later version.
013     This library is distributed in the hope that it will be useful, but WITHOUT
014     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
015     FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
016     details.
017     You should have received a copy of the GNU Lesser General Public License
018     along with this library; if not, write to the Free Software Foundation, Inc.,
019     59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
020    
021     Contact information:
022    
023     lat/lon GmbH
024     Aennchenstr. 19, 53177 Bonn
025     Germany
026     http://lat-lon.de/
027    
028     Department of Geography, University of Bonn
029     Prof. Dr. Klaus Greve
030     Postfach 1147, 53001 Bonn
031     Germany
032     http://www.geographie.uni-bonn.de/deegree/
033    
034     e-mail: info@deegree.org
035    ----------------------------------------------------------------------------*/
036    package org.deegree.framework.xml.schema;
037    
038    import java.net.URI;
039    import java.util.List;
040    
041    import org.deegree.datatypes.QualifiedName;
042    import org.deegree.framework.log.ILogger;
043    import org.deegree.framework.log.LoggerFactory;
044    import org.deegree.framework.xml.XMLFragment;
045    import org.deegree.framework.xml.XMLParsingException;
046    import org.deegree.framework.xml.XMLTools;
047    import org.w3c.dom.Element;
048    import org.w3c.dom.Node;
049    
050    /**
051     * Parser for XML schema documents.
052     *
053     * @author <a href="mailto:schneider@lat-lon.de">Markus Schneider </a>
054     * @author <a href="mailto:deshmukh@lat-lon.de">Anup Deshmukh </a>
055     * @author last edited by: $Author: mschneider $
056     *
057     * @version $Revision: 18195 $, $Date: 2009-06-18 17:55:39 +0200 (Do, 18 Jun 2009) $
058     */
059    public class XSDocument extends XMLFragment {
060    
061        private static final long serialVersionUID = 4371672452129797159L;
062    
063        private URI targetNamespace;
064    
065        private final ILogger LOG = LoggerFactory.getLogger( XSDocument.class );
066    
067        /**
068         * Returns the class representation of the underlying schema document.
069         *
070         * @return class representation of the underlying schema document
071         * @throws XMLParsingException
072         * @throws XMLSchemaException
073         */
074        public XMLSchema parseXMLSchema()
075                                throws XMLParsingException, XMLSchemaException {
076            SimpleTypeDeclaration[] simpleTypes = extractSimpleTypeDeclarations();
077            ComplexTypeDeclaration[] complexTypes = extractComplexTypeDeclarations();
078            ElementDeclaration[] elementDeclarations = extractElementDeclarations();
079            return new XMLSchema( getTargetNamespace(), simpleTypes, complexTypes, elementDeclarations );
080        }
081    
082        /**
083         * Returns the target namespace of the underlying schema document.
084         *
085         * @return target namespace of the underlying schema document
086         * @throws XMLParsingException
087         */
088        public synchronized URI getTargetNamespace()
089                                throws XMLParsingException {
090            if ( this.targetNamespace == null ) {
091                this.targetNamespace = XMLTools.getNodeAsURI( this.getRootElement(), "@targetNamespace", nsContext, null );
092            }
093            return this.targetNamespace;
094        }
095    
096        /**
097         * Extracts all global (top-level) simple type declarations from the underlying schema document.
098         *
099         * @return all global (top-level) simple type declarations
100         * @throws XMLParsingException
101         *             if the document is not a valid XML Schema document or does not match the
102         *             limitations of this class
103         */
104        public SimpleTypeDeclaration[] extractSimpleTypeDeclarations()
105                                throws XMLParsingException {
106            List<Element> simpleTypeElements = XMLTools.getElements( this.getRootElement(), getFullName( "simpleType" ),
107                                                                     nsContext );
108            LOG.logDebug( "Found " + simpleTypeElements.size() + " simple type declarations." );
109            SimpleTypeDeclaration[] simpleTypeDeclarations = new SimpleTypeDeclaration[simpleTypeElements.size()];
110            for ( int i = 0; i < simpleTypeDeclarations.length; i++ ) {
111                simpleTypeDeclarations[i] = parseSimpleTypeDeclaration( simpleTypeElements.get( i ) );
112            }
113            return simpleTypeDeclarations;
114        }
115    
116        /**
117         * Extracts all global (top-level) complex type declarations from the underlying schema
118         * document.
119         *
120         * @return all global (top-level) complex type declarations
121         * @throws XMLParsingException
122         *             if the document is not a valid XML Schema document or does not match the
123         *             limitations of this class
124         */
125        public ComplexTypeDeclaration[] extractComplexTypeDeclarations()
126                                throws XMLParsingException {
127            List<Element> complexTypeElements = XMLTools.getElements( this.getRootElement(), getFullName( "complexType" ),
128                                                                      nsContext );
129            LOG.logDebug( "Found " + complexTypeElements.size() + " complex type declarations." );
130            ComplexTypeDeclaration[] complexTypeDeclarations = new ComplexTypeDeclaration[complexTypeElements.size()];
131            for ( int i = 0; i < complexTypeDeclarations.length; i++ ) {
132                complexTypeDeclarations[i] = parseComplexTypeDeclaration( complexTypeElements.get( i ) );
133            }
134            return complexTypeDeclarations;
135        }
136    
137        /**
138         * Extracts all global (top-level) element declarations from the underlying schema document.
139         *
140         * @return all global (top-level) element declarations
141         * @throws XMLParsingException
142         *             if the document is not a valid XML Schema document or does not match the
143         *             limitations of this class
144         */
145        public ElementDeclaration[] extractElementDeclarations()
146                                throws XMLParsingException {
147            List<Element> complexTypeElements = XMLTools.getElements( this.getRootElement(), getFullName( "element" ),
148                                                                      nsContext );
149            LOG.logDebug( "Found " + complexTypeElements.size() + " element declarations." );
150            ElementDeclaration[] elementDeclarations = new ElementDeclaration[complexTypeElements.size()];
151            for ( int i = 0; i < elementDeclarations.length; i++ ) {
152                elementDeclarations[i] = parseElementDeclaration( complexTypeElements.get( i ) );
153            }
154            return elementDeclarations;
155        }
156    
157        /**
158         * Returns the root element of the complex type declaration for the given name.
159         *
160         * @param name
161         *            the name of the complex type declaration to look up (w/o namespace)
162         * @return the root element of the complex type declaration or null, if the requested complex
163         *         type is not declared
164         */
165        public Element getComplexTypeDeclaration( String name ) {
166            String xPath = getFullName( "complexType[name=\"]" ) + name + "\"]";
167            Element element = null;
168            try {
169                element = (Element) XMLTools.getNode( getRootElement(), xPath, nsContext );
170            } catch ( XMLParsingException e ) {
171                // happens if requested complex type is not declared
172            }
173            return element;
174        }
175    
176        /**
177         * Parses the given <code>Element</code> as an 'xs:element' declaration.
178         *
179         * @param element
180         *            'xs:element' declaration to be parsed
181         * @return object representation of the declaration
182         * @throws XMLParsingException
183         *             if the document is not a valid XML Schema document or does not match the
184         *             limitations of this class
185         */
186        protected ElementDeclaration parseElementDeclaration( Element element )
187                                throws XMLParsingException {
188    
189            QualifiedName name = new QualifiedName( XMLTools.getRequiredNodeAsString( element, "@name", nsContext ),
190                                                    getTargetNamespace() );
191    
192            if ( name.getLocalName().length() == 0 ) {
193                String msg = "Error in schema document. Empty name (\"\") in element declaration " + "found.";
194                throw new XMLSchemaException( msg );
195            }
196    
197            LOG.logDebug( "Parsing element declaration '" + name + "'." );
198    
199            boolean isAbstract = XMLTools.getNodeAsBoolean( element, "@abstract", nsContext, false );
200    
201            TypeReference typeReference = null;
202            Node typeNode = XMLTools.getNode( element,
203                                              "@type|xs:simpleType/xs:restriction/@base|xs:simpleType/xs:extension/@base",
204                                              nsContext );
205            if ( typeNode != null ) {
206                typeReference = new TypeReference( parseQualifiedName( typeNode ) );
207            } else {
208                // inline type declaration
209                Element elem = (Element) XMLTools.getRequiredNode( element, getFullName( "complexType" ), nsContext );
210                TypeDeclaration type = parseComplexTypeDeclaration( elem );
211                typeReference = new TypeReference( type );
212            }
213    
214            int minOccurs = XMLTools.getNodeAsInt( element, "@minOccurs", nsContext, 1 );
215            int maxOccurs = -1;
216            String maxOccursString = XMLTools.getNodeAsString( element, "@maxOccurs", nsContext, "1" );
217            if ( !"unbounded".equals( maxOccursString ) ) {
218                try {
219                    maxOccurs = Integer.parseInt( maxOccursString );
220                } catch ( NumberFormatException e ) {
221                    throw new XMLParsingException( "Invalid value ('" + maxOccursString + "') in 'maxOccurs' attribute. "
222                                                   + "Must be a valid integer value or 'unbounded'." );
223                }
224            }
225    
226            QualifiedName substitutionGroup = null;
227            Node substitutionGroupNode = XMLTools.getNode( element, "@substitutionGroup", nsContext );
228            if ( substitutionGroupNode != null ) {
229                substitutionGroup = parseQualifiedName( substitutionGroupNode );
230            }
231    
232            return new ElementDeclaration( name, isAbstract, typeReference, minOccurs, maxOccurs, substitutionGroup );
233        }
234    
235        /**
236         * Parses the given <code>Element</code> as an 'xs:simpleType' declaration.
237         * <p>
238         * The following limitations apply:
239         * <ul>
240         * <li>the type must be defined using 'restriction' (of a basic xsd type)</li>
241         * <li>the content model (enumeration, ...) is not evaluated</li>
242         * </ul>
243         * </p>
244         *
245         * @param element
246         *            'xs:simpleType' declaration to be parsed
247         * @return object representation of the declaration
248         * @throws XMLParsingException
249         *             if the document is not a valid XML Schema document or does not match the
250         *             limitations of this class
251         */
252        protected SimpleTypeDeclaration parseSimpleTypeDeclaration( Element element )
253                                throws XMLParsingException {
254    
255            QualifiedName name = null;
256            String localName = XMLTools.getNodeAsString( element, "@name", nsContext, null );
257            if ( localName != null ) {
258                name = new QualifiedName( localName, getTargetNamespace() );
259                if ( localName.length() == 0 ) {
260                    String msg = "Error in schema document. Empty name (\"\") in simpleType " + "declaration found.";
261                    throw new XMLSchemaException( msg );
262                }
263            }
264    
265            LOG.logDebug( "Parsing simple type declaration '" + name + "'." );
266    
267            Node restrictionBaseNode = XMLTools.getRequiredNode( element, getFullName( "restriction/@base" ), nsContext );
268            TypeReference restrictionBase = new TypeReference( parseQualifiedName( restrictionBaseNode ) );
269    
270            return new SimpleTypeDeclaration( name, restrictionBase );
271        }
272    
273        /**
274         * Parses the given <code>Element</code> as an 'xs:complexType' declaration.
275         *
276         * @param element
277         *            'xs:complexType' declaration to be parsed
278         * @return object representation of the declaration
279         * @throws XMLParsingException
280         *             if the document is not a valid XML Schema document or does not match the
281         *             limitations of this class
282         */
283        protected ComplexTypeDeclaration parseComplexTypeDeclaration( Element element )
284                                throws XMLParsingException {
285    
286            QualifiedName name = null;
287            String localName = XMLTools.getNodeAsString( element, "@name", nsContext, null );
288            if ( localName != null ) {
289                name = new QualifiedName( localName, getTargetNamespace() );
290                if ( localName.length() == 0 ) {
291                    String msg = "Error in schema document. Empty name (\"\") for complexType " + "declaration found.";
292                    throw new XMLSchemaException( msg );
293                }
294            }
295            LOG.logDebug( "Parsing complex type declaration '" + name + "'." );
296    
297            List<Element> subElementList = null;
298            TypeReference extensionBase = null;
299            Node extensionBaseNode = XMLTools.getNode( element, getFullName( "complexContent/" )
300                                                                + getFullName( "extension/@base" ), nsContext );
301            if ( extensionBaseNode != null ) {
302                extensionBase = new TypeReference( parseQualifiedName( extensionBaseNode ) );
303                subElementList = XMLTools.getElements( element, getFullName( "complexContent/" )
304                                                                + getFullName( "extension/" ) + getFullName( "sequence/" )
305                                                                + getFullName( "element" ), nsContext );
306            } else {
307                subElementList = XMLTools.getRequiredElements( element, getFullName( "sequence/" )
308                                                                        + getFullName( "element" ), nsContext );
309            }
310    
311            ElementDeclaration[] subElements = new ElementDeclaration[subElementList.size()];
312            for ( int i = 0; i < subElements.length; i++ ) {
313                Element subElement = subElementList.get( i );
314                subElements[i] = parseElementDeclaration( subElement );
315            }
316    
317            return new ComplexTypeDeclaration( name, extensionBase, subElements );
318        }
319    
320        /**
321         * Prepends the prefix of the RootElement to the given local name.
322         * <p>
323         * If the prefix of the RootElement is empty, "xs:" is prepended.
324         *
325         * @param localName
326         *            to this the prefix will be prepended
327         * @return prefix + localName
328         */
329        protected String getFullName( String localName ) {
330            String ret;
331            Element root = this.getRootElement();
332            String prefix = root.getPrefix();
333    
334            if ( prefix != null && prefix.length() > 0 ) {
335                URI uri = nsContext.getURI( prefix );
336                if ( null == uri ) {
337                    String nsUri = root.lookupNamespaceURI( prefix );
338                    try {
339                        nsContext.addNamespace( prefix, new URI( nsUri ) ); // synchronized ???
340                    } catch ( Exception exc ) {
341                        LOG.logError( "failed to add namespace: " + nsUri, exc );
342                    }
343                }
344                ret = prefix + ':' + localName;
345            } else {
346                // fallback
347                ret = "xs:" + localName;
348            }
349            return ret;
350        }
351    }