1 /*
2 * reserved comment block
3 * DO NOT REMOVE OR ALTER!
4 */
5 // DOMCatalogReader.java - Read XML Catalog files
6
7 /*
8 * Copyright 2001-2004 The Apache Software Foundation or its licensors,
9 * as applicable.
10 *
11 * Licensed under the Apache License, Version 2.0 (the "License");
12 * you may not use this file except in compliance with the License.
13 * You may obtain a copy of the License at
14 *
15 * http://www.apache.org/licenses/LICENSE-2.0
16 *
17 * Unless required by applicable law or agreed to in writing, software
18 * distributed under the License is distributed on an "AS IS" BASIS,
19 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
20 * See the License for the specific language governing permissions and
21 * limitations under the License.
22 */
23
24 package com.sun.org.apache.xml.internal.resolver.readers;
25
26 import com.sun.org.apache.xml.internal.resolver.Catalog;
27 import com.sun.org.apache.xml.internal.resolver.CatalogException;
28 import com.sun.org.apache.xml.internal.resolver.helpers.Namespaces;
29 import java.io.IOException;
30 import java.io.InputStream;
31 import java.net.MalformedURLException;
32 import java.net.URL;
33 import java.net.URLConnection;
34 import java.util.Hashtable;
35 import javax.xml.parsers.DocumentBuilder;
36 import javax.xml.parsers.DocumentBuilderFactory;
37 import javax.xml.parsers.ParserConfigurationException;
38 import org.w3c.dom.*;
39 import org.xml.sax.SAXException;
40 import sun.reflect.misc.ReflectUtil;
41
42 /**
43 * A DOM-based CatalogReader.
44 *
45 * <p>This class is used to read XML Catalogs using the DOM. This reader
46 * has an advantage over the SAX-based reader that it can analyze the
47 * DOM tree rather than simply a series of SAX events. It has the disadvantage
48 * that it requires all of the code necessary to build and walk a DOM
49 * tree.</p>
50 *
51 * <p>Since the choice of CatalogReaders (in the InputStream case) can only
52 * be made on the basis of MIME type, the following problem occurs: only
53 * one CatalogReader can exist for all XML mime types. In order to get
54 * around this problem, the DOMCatalogReader relies on a set of external
55 * CatalogParsers to actually build the catalog.</p>
56 *
57 * <p>The selection of CatalogParsers is made on the basis of the QName
58 * of the root element of the document.</p>
59 *
60 * <p>This class requires the <a href="http://java.sun.com/aboutJava/communityprocess/final/jsr005/index.html">Java API for XML Parsing</a>.</p>
61 *
62 * @see Catalog
63 * @see CatalogReader
64 * @see SAXCatalogReader
65 * @see TextCatalogReader
66 * @see DOMCatalogParser
67 *
68 * @author Norman Walsh
69 * <a href="mailto:Norman.Walsh@Sun.COM">Norman.Walsh@Sun.COM</a>
70 *
71 */
72 public class DOMCatalogReader implements CatalogReader {
73 /**
74 * Mapping table from QNames to CatalogParser classes.
75 *
76 * <p>Each key in this hash table has the form "elementname"
77 * or "{namespaceuri}elementname". The former is used if the
78 * namespace URI is null.</p>
79 */
80 protected Hashtable namespaceMap = new Hashtable();
81
82 /**
83 * Add a new parser to the reader.
84 *
85 * <p>This method associates the specified parserClass with the
86 * namespaceURI/rootElement names specified.</p>
87 *
88 * @param namespaceURI The namespace URI. <em>Not</em> the prefix.
89 * @param rootElement The name of the root element.
90 * @param parserClass The name of the parserClass to instantiate
91 * for this kind of catalog.
92 */
93 public void setCatalogParser(String namespaceURI,
94 String rootElement,
95 String parserClass) {
96 if (namespaceURI == null) {
97 namespaceMap.put(rootElement, parserClass);
98 } else {
99 namespaceMap.put("{"+namespaceURI+"}"+rootElement, parserClass);
100 }
101 }
102
103 /**
104 * Get the name of the parser class for a given catalog type.
105 *
106 * <p>This method returns the parserClass associated with the
107 * namespaceURI/rootElement names specified.</p>
108 *
109 * @param namespaceURI The namespace URI. <em>Not</em> the prefix.
110 * @param rootElement The name of the root element.
111 * @return The parser class.
112 */
113 public String getCatalogParser(String namespaceURI,
114 String rootElement) {
115 if (namespaceURI == null) {
116 return (String) namespaceMap.get(rootElement);
117 } else {
118 return (String) namespaceMap.get("{"+namespaceURI+"}"+rootElement);
119 }
120 }
121
122 /**
123 * Null constructor; something for subclasses to call.
124 */
125 public DOMCatalogReader() { }
126
127 /**
128 * Read a catalog from an input stream.
129 *
130 * <p>This class reads a catalog from an input stream:</p>
131 *
132 * <ul>
133 * <li>Based on the QName of the root element, it determines which
134 * parser to instantiate for this catalog.</li>
135 * <li>It constructs a DOM Document from the catalog and</li>
136 * <li>For each child of the root node, it calls the parser's
137 * parseCatalogEntry method. This method is expected to make
138 * appropriate calls back into the catalog to add entries for the
139 * entries in the catalog. It is free to do this in whatever manner
140 * is appropriate (perhaps using just the node passed in, perhaps
141 * wandering arbitrarily throughout the tree).</li>
142 * </ul>
143 *
144 * @param catalog The catalog for which this reader is called.
145 * @param is The input stream that is to be read.
146 * @throws IOException if the URL cannot be read.
147 * @throws UnknownCatalogFormatException if the catalog format is
148 * not recognized.
149 * @throws UnparseableCatalogException if the catalog cannot be parsed.
150 * (For example, if it is supposed to be XML and isn't well-formed or
151 * if the parser class cannot be instantiated.)
152 */
153 public void readCatalog(Catalog catalog, InputStream is)
154 throws IOException, CatalogException {
155
156 DocumentBuilderFactory factory = null;
157 DocumentBuilder builder = null;
158
159 factory = DocumentBuilderFactory.newInstance();
160 factory.setNamespaceAware(false);
161 factory.setValidating(false);
162 try {
163 builder = factory.newDocumentBuilder();
164 } catch (ParserConfigurationException pce) {
165 throw new CatalogException(CatalogException.UNPARSEABLE);
166 }
167
168 Document doc = null;
169
170 try {
171 doc = builder.parse(is);
172 } catch (SAXException se) {
173 throw new CatalogException(CatalogException.UNKNOWN_FORMAT);
174 }
175
176 Element root = doc.getDocumentElement();
177
178 String namespaceURI = Namespaces.getNamespaceURI(root);
179 String localName = Namespaces.getLocalName(root);
180
181 String domParserClass = getCatalogParser(namespaceURI,
182 localName);
183
184 if (domParserClass == null) {
185 if (namespaceURI == null) {
186 catalog.getCatalogManager().debug.message(1, "No Catalog parser for "
187 + localName);
188 } else {
189 catalog.getCatalogManager().debug.message(1, "No Catalog parser for "
190 + "{" + namespaceURI + "}"
191 + localName);
192 }
193 return;
194 }
195
196 DOMCatalogParser domParser = null;
197
198 try {
199 domParser = (DOMCatalogParser) ReflectUtil.forName(domParserClass).newInstance();
200 } catch (ClassNotFoundException cnfe) {
201 catalog.getCatalogManager().debug.message(1, "Cannot load XML Catalog Parser class", domParserClass);
202 throw new CatalogException(CatalogException.UNPARSEABLE);
203 } catch (InstantiationException ie) {
204 catalog.getCatalogManager().debug.message(1, "Cannot instantiate XML Catalog Parser class", domParserClass);
205 throw new CatalogException(CatalogException.UNPARSEABLE);
206 } catch (IllegalAccessException iae) {
207 catalog.getCatalogManager().debug.message(1, "Cannot access XML Catalog Parser class", domParserClass);
208 throw new CatalogException(CatalogException.UNPARSEABLE);
209 } catch (ClassCastException cce ) {
210 catalog.getCatalogManager().debug.message(1, "Cannot cast XML Catalog Parser class", domParserClass);
211 throw new CatalogException(CatalogException.UNPARSEABLE);
212 }
213
214 Node node = root.getFirstChild();
215 while (node != null) {
216 domParser.parseCatalogEntry(catalog, node);
217 node = node.getNextSibling();
218 }
219 }
220
221 /**
222 * Read the catalog behind the specified URL.
223 *
224 * @see #readCatalog(Catalog, InputStream)
225 *
226 * @param catalog The catalog for which we are reading.
227 * @param fileUrl The URL of the document that should be read.
228 *
229 * @throws MalformedURLException if the specified URL cannot be
230 * turned into a URL object.
231 * @throws IOException if the URL cannot be read.
232 * @throws UnknownCatalogFormatException if the catalog format is
233 * not recognized.
234 * @throws UnparseableCatalogException if the catalog cannot be parsed.
235 * (For example, if it is supposed to be XML and isn't well-formed.)
236 */
237 public void readCatalog(Catalog catalog, String fileUrl)
238 throws MalformedURLException, IOException, CatalogException {
239 URL url = new URL(fileUrl);
240 URLConnection urlCon = url.openConnection();
241 readCatalog(catalog, urlCon.getInputStream());
242 }
243 }