001 //$HeadURL: svn+ssh://jwilden@svn.wald.intevation.org/deegree/base/branches/2.5_testing/src/org/deegree/framework/xml/schema/XMLSchema.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.HashMap;
040 import java.util.Map;
041
042 import org.deegree.datatypes.QualifiedName;
043 import org.deegree.framework.log.ILogger;
044 import org.deegree.framework.log.LoggerFactory;
045
046 /**
047 * Represents an XML schema document.
048 *
049 * @author <a href="mailto:schneider@lat-lon.de">Markus Schneider </a>
050 * @author last edited by: $Author: mschneider $
051 *
052 * @version $Revision: 18195 $, $Date: 2009-06-18 17:55:39 +0200 (Do, 18 Jun 2009) $
053 */
054 public class XMLSchema {
055
056 private final static ILogger LOG = LoggerFactory.getLogger( XMLSchema.class );
057
058 private URI targetNamespace;
059
060 // keys: QualifiedName (element names), values: ElementDeclaration
061 private Map<QualifiedName, ElementDeclaration> elementMap = new HashMap<QualifiedName, ElementDeclaration>();
062
063 // keys: QualifiedName (type names), values: TypeDeclaration
064 private Map<QualifiedName, TypeDeclaration> typeMap = new HashMap<QualifiedName, TypeDeclaration>();
065
066 // keys: QualifiedName (type names), values: ComplexTypeDeclaration
067 private Map<QualifiedName, ComplexTypeDeclaration> complexTypeMap = new HashMap<QualifiedName, ComplexTypeDeclaration>();
068
069 // keys: QualifiedName (type names), values: SimpleTypeDeclaration
070 private Map<QualifiedName, SimpleTypeDeclaration> simpleTypeMap = new HashMap<QualifiedName, SimpleTypeDeclaration>();
071
072 /**
073 * Creates a new <code>XMLSchema</code> instance from the given parameters.
074 *
075 * @param targetNamespace
076 * @param simpleTypes
077 * @param complexTypes
078 * @param elementDeclarations
079 * @throws XMLSchemaException
080 */
081 public XMLSchema( URI targetNamespace, SimpleTypeDeclaration[] simpleTypes,
082 ComplexTypeDeclaration[] complexTypes, ElementDeclaration[] elementDeclarations )
083 throws XMLSchemaException {
084 this.targetNamespace = targetNamespace;
085 for ( int i = 0; i < elementDeclarations.length; i++ ) {
086 elementMap.put( elementDeclarations[i].getName(), elementDeclarations[i] );
087 }
088 for ( int i = 0; i < simpleTypes.length; i++ ) {
089 simpleTypeMap.put( simpleTypes[i].getName(), simpleTypes[i] );
090 typeMap.put( simpleTypes[i].getName(), simpleTypes[i] );
091 }
092 for ( int i = 0; i < complexTypes.length; i++ ) {
093 complexTypeMap.put( complexTypes[i].getName(), complexTypes[i] );
094 typeMap.put( complexTypes[i].getName(), complexTypes[i] );
095 }
096 resolveReferences();
097 }
098
099 /**
100 * Returns the target namespace of the schema document.
101 *
102 * @return the target namespace
103 */
104 public URI getTargetNamespace() {
105 return this.targetNamespace;
106 }
107
108 /**
109 * Returns all <code>ElementDeclaration</code>s that are defined in the schema.
110 *
111 * @return all ElementDeclarations that are defined in the schema
112 */
113 public ElementDeclaration[] getElementDeclarations() {
114 return this.elementMap.values().toArray( new ElementDeclaration[this.elementMap.size()] );
115 }
116
117 /**
118 * Returns all <code>SimpleTypeDeclaration</code>s that are defined in the schema.
119 *
120 * @return all SimpleTypeDeclarations that are defined in the schema
121 */
122 public SimpleTypeDeclaration[] getSimpleTypeDeclarations() {
123 return this.simpleTypeMap.values().toArray(
124 new SimpleTypeDeclaration[this.simpleTypeMap.size()] );
125 }
126
127 /**
128 * Returns all <code>ComplexTypeDeclaration</code>s that are defined in the schema.
129 *
130 * @return all ComplexTypeDeclarations that are defined in the schema
131 */
132 public ComplexTypeDeclaration[] getComplexTypeDeclarations() {
133 return this.complexTypeMap.values().toArray(
134 new ComplexTypeDeclaration[this.complexTypeMap.size()] );
135 }
136
137 /**
138 * Looks up the <code>ElementDeclaration</code> for the given <code>QualifiedName</code>.
139 *
140 * @param qName
141 * the QualifiedName to look up
142 * @return the ElementDeclaration, if an element with the given name is defined in the schema,
143 * null otherwise
144 */
145 public ElementDeclaration getElementDeclaration( QualifiedName qName ) {
146 return this.elementMap.get( qName );
147 }
148
149 /**
150 * Looks up the <code>TypeDeclaration</code> for the given <code>QualifiedName</code>.
151 *
152 * @param qName
153 * the QualifiedName to look up
154 * @return the TypeDeclaration, if a type with the given name is defined in the schema, null
155 * otherwise
156 */
157 public TypeDeclaration getTypeDeclaration( QualifiedName qName ) {
158 return this.typeMap.get( qName );
159 }
160
161 /**
162 * Looks up the <code>SimpleTypeDeclaration</code> for the given <code>QualifiedName</code>.
163 *
164 * @param qName
165 * the QualifiedName to look up
166 * @return the SimpleTypeDeclaration, if a simple type with the given name is defined in the
167 * schema, null otherwise
168 */
169 public SimpleTypeDeclaration getSimpleTypeDeclaration( QualifiedName qName ) {
170 return this.simpleTypeMap.get( qName );
171 }
172
173 /**
174 * Looks up the <code>ComplexTypeDeclaration</code> for the given <code>QualifiedName</code>.
175 *
176 * @param qName
177 * the QualifiedName to look up
178 * @return the ComplexTypeDeclaration, if a complex type with the given name is defined in the
179 * schema, null otherwise
180 */
181 public ComplexTypeDeclaration getComplexTypeDeclaration( QualifiedName qName ) {
182 return this.complexTypeMap.get( qName );
183 }
184
185 /**
186 * Looks up the <code>ElementDeclaration</code> for the given local name (without namespace).
187 *
188 * @param name
189 * the (unqualified) name to look up
190 * @return the ElementDeclaration, if an element with the given name is defined in the schema,
191 * null otherwise
192 */
193 public ElementDeclaration getElementDeclaration( String name ) {
194 return getElementDeclaration( new QualifiedName( name, this.targetNamespace ) );
195 }
196
197 /**
198 * Looks up the <code>TypeDeclaration</code> for the given local name (without namespace).
199 *
200 * @param name
201 * the (unqualified) name to look up
202 * @return the TypeDeclaration, if a type with the given name is defined in the schema, null
203 * otherwise
204 */
205 public TypeDeclaration getTypeDeclaration( String name ) {
206 return getTypeDeclaration( new QualifiedName( name, this.targetNamespace ) );
207 }
208
209 /**
210 * Looks up the <code>SimpleTypeDeclaration</code> for the given local name (without
211 * namespace).
212 *
213 * @param name
214 * the (unqualified) name to look up
215 * @return the SimpleTypeDeclaration, if a simple type with the given name is defined in the
216 * schema, null otherwise
217 */
218 public SimpleTypeDeclaration getSimpleTypeDeclaration( String name ) {
219 return getSimpleTypeDeclaration( new QualifiedName( name, this.targetNamespace ) );
220 }
221
222 /**
223 * Looks up the <code>ComplexTypeDeclaration</code> for the given local name (without
224 * namespace).
225 *
226 * @param name
227 * the (unqualified) name to look up
228 * @return the ComplexTypeDeclaration, if a complex type with the given name is defined in the
229 * schema, null otherwise
230 */
231 public ComplexTypeDeclaration getComplexTypeDeclaration( String name ) {
232 return getComplexTypeDeclaration( new QualifiedName( name, this.targetNamespace ) );
233 }
234
235 private void resolveReferences()
236 throws UnresolvableReferenceException {
237 LOG.logDebug( "Resolving references for namespace '" + this.targetNamespace + "'." );
238 for( ElementDeclaration elemDec : elementMap.values() ){
239 resolveReferences( elemDec );
240 }
241 for( TypeDeclaration tDec : typeMap.values() ){
242 resolveReferences( tDec );
243 }
244 }
245
246 private void resolveReferences( ElementDeclaration element )
247 throws UnresolvableReferenceException {
248 LOG.logDebug( "Resolving references in element declaration '"
249 + element.getName().getLocalName() + "'." );
250 ElementReference substitutionGroup = element.getSubstitutionGroup();
251 if ( substitutionGroup != null ) {
252 resolveElement( substitutionGroup );
253 }
254 TypeReference typeReference = element.getType();
255 resolveType( typeReference );
256 }
257
258 private void resolveReferences( TypeDeclaration typeDeclaration )
259 throws UnresolvableReferenceException {
260 LOG.logDebug( "Resolving references in type declaration '"
261 + typeDeclaration.getName().getLocalName() + "'." );
262 if ( typeDeclaration instanceof SimpleTypeDeclaration ) {
263 LOG.logDebug( "SimpleType." );
264 SimpleTypeDeclaration simpleType = (SimpleTypeDeclaration) typeDeclaration;
265 TypeReference typeReference = simpleType.getRestrictionBaseType();
266 if ( typeReference != null ) {
267 LOG.logDebug( "restriction base='" + typeReference.getName() + "'" );
268 try {
269 resolveType( typeReference );
270 } catch ( XMLSchemaException e ) {
271 throw new UndefinedXSDTypeException( "Declaration of type '"
272 + typeDeclaration.getName()
273 + "' derives type '"
274 + typeReference.getName()
275 + "' which is not a defined simple type." );
276 }
277 }
278 } else {
279 LOG.logDebug( "ComplexType." );
280 ComplexTypeDeclaration complexType = (ComplexTypeDeclaration) typeDeclaration;
281 TypeReference typeReference = complexType.getExtensionBaseType();
282 if ( typeReference != null ) {
283 LOG.logDebug( "extension base='" + typeReference.getName() + "'" );
284 try {
285 resolveType( typeReference );
286 } catch ( XMLSchemaException e ) {
287 throw new UndefinedXSDTypeException( "Declaration of type '"
288 + typeDeclaration.getName()
289 + "' derives type '"
290 + typeReference.getName()
291 + "' which is not a defined complex type." );
292 }
293 }
294 ElementDeclaration[] elements = complexType.getExplicitElements();
295 for ( int i = 0; i < elements.length; i++ ) {
296 resolveReferences( elements[i] );
297 }
298 }
299 }
300
301 private void resolveElement( ElementReference elementReference )
302 throws UndefinedElementException {
303 if ( !elementReference.isResolved() ) {
304 LOG.logDebug( "Resolving reference to element '"
305 + elementReference.getName().getLocalName() + "'." );
306 if ( elementReference.getName().isInNamespace( this.targetNamespace ) ) {
307 ElementDeclaration element = elementMap.get( elementReference.getName() );
308 if ( element == null ) {
309 LOG.logDebug( "Cannot be resolved!" );
310 throw new UndefinedElementException( "Element '" + elementReference.getName()
311 + "' is not defined." );
312 }
313 LOG.logDebug( "OK." );
314 elementReference.resolve( element );
315 } else {
316 LOG.logDebug( "Skipped (not in target namespace)." );
317 elementReference.resolve();
318 }
319 }
320 }
321
322 private void resolveType( TypeReference typeReference )
323 throws UnresolvableReferenceException {
324 if ( !typeReference.isResolved() ) {
325 if ( typeReference.isAnonymous() ) {
326 LOG.logDebug( "Inline type..." );
327 // type is defined inline
328 TypeDeclaration type = typeReference.getTypeDeclaration();
329 typeReference.resolve();
330 if ( type instanceof ComplexTypeDeclaration ) {
331 ComplexTypeDeclaration complexType = (ComplexTypeDeclaration) type;
332 ElementDeclaration[] subElements = complexType.getExplicitElements();
333 for ( int i = 0; i < subElements.length; i++ ) {
334 resolveReferences( subElements[i] );
335 }
336 }
337 } else {
338 LOG.logDebug( "Resolving reference to type: '" + typeReference.getName() + "'..." );
339 if ( typeReference.getName().isInNamespace( this.targetNamespace ) ) {
340 TypeDeclaration type = typeMap.get( typeReference.getName() );
341 if ( type == null ) {
342 LOG.logDebug( "Cannot be resolved!" );
343 throw new UndefinedXSDTypeException( "Type '" + typeReference.getName()
344 + "' is not a defined type." );
345 }
346 LOG.logDebug( "OK." );
347 typeReference.resolve( type );
348 } else {
349 LOG.logDebug( "Skipped (not in target / schema namespace)." );
350 }
351 }
352 }
353 }
354
355 @Override
356 public String toString() {
357 StringBuffer sb = new StringBuffer( "XML Schema targetNamespace='" );
358 sb.append( targetNamespace );
359 sb.append( "'\n" );
360 sb.append( "\n*** " );
361 sb.append( elementMap.size() );
362 sb.append( " global element declarations ***\n" );
363 for( ElementDeclaration elemDec : elementMap.values() ){
364 sb.append( elemDec.toString( "" ) );
365 }
366 sb.append( "\n*** " );
367 sb.append( simpleTypeMap.size() );
368 sb.append( " global simple type declarations ***\n" );
369 for( SimpleTypeDeclaration type : simpleTypeMap.values() ){
370 sb.append( type.toString( "" ) );
371 }
372 sb.append( "\n*** " );
373 sb.append( complexTypeMap.size() );
374 sb.append( " global complex type declarations ***\n" );
375 for( ComplexTypeDeclaration type : complexTypeMap.values() ){
376 sb.append( type.toString( "" ) );
377 }
378 return sb.toString();
379 }
380 }