|
0
|
1 /*--
|
|
|
2
|
|
|
3 $Id: DOMBuilder.java,v 1.60 2007/11/10 05:29:00 jhunter Exp $
|
|
|
4
|
|
|
5 Copyright (C) 2000-2007 Jason Hunter & Brett McLaughlin.
|
|
|
6 All rights reserved.
|
|
|
7
|
|
|
8 Redistribution and use in source and binary forms, with or without
|
|
|
9 modification, are permitted provided that the following conditions
|
|
|
10 are met:
|
|
|
11
|
|
|
12 1. Redistributions of source code must retain the above copyright
|
|
|
13 notice, this list of conditions, and the following disclaimer.
|
|
|
14
|
|
|
15 2. Redistributions in binary form must reproduce the above copyright
|
|
|
16 notice, this list of conditions, and the disclaimer that follows
|
|
|
17 these conditions in the documentation and/or other materials
|
|
|
18 provided with the distribution.
|
|
|
19
|
|
|
20 3. The name "JDOM" must not be used to endorse or promote products
|
|
|
21 derived from this software without prior written permission. For
|
|
|
22 written permission, please contact <request_AT_jdom_DOT_org>.
|
|
|
23
|
|
|
24 4. Products derived from this software may not be called "JDOM", nor
|
|
|
25 may "JDOM" appear in their name, without prior written permission
|
|
|
26 from the JDOM Project Management <request_AT_jdom_DOT_org>.
|
|
|
27
|
|
|
28 In addition, we request (but do not require) that you include in the
|
|
|
29 end-user documentation provided with the redistribution and/or in the
|
|
|
30 software itself an acknowledgement equivalent to the following:
|
|
|
31 "This product includes software developed by the
|
|
|
32 JDOM Project (http://www.jdom.org/)."
|
|
|
33 Alternatively, the acknowledgment may be graphical using the logos
|
|
|
34 available at http://www.jdom.org/images/logos.
|
|
|
35
|
|
|
36 THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
|
|
|
37 WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
|
|
38 OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
|
39 DISCLAIMED. IN NO EVENT SHALL THE JDOM AUTHORS OR THE PROJECT
|
|
|
40 CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
|
41 SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
|
42 LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
|
|
|
43 USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
|
|
44 ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
|
|
|
45 OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
|
|
|
46 OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
|
47 SUCH DAMAGE.
|
|
|
48
|
|
|
49 This software consists of voluntary contributions made by many
|
|
|
50 individuals on behalf of the JDOM Project and was originally
|
|
|
51 created by Jason Hunter <jhunter_AT_jdom_DOT_org> and
|
|
|
52 Brett McLaughlin <brett_AT_jdom_DOT_org>. For more information
|
|
|
53 on the JDOM Project, please see <http://www.jdom.org/>.
|
|
|
54
|
|
|
55 */
|
|
|
56
|
|
|
57 package org.jdom.input;
|
|
|
58
|
|
|
59 import org.jdom.*;
|
|
|
60 import org.jdom.Document;
|
|
|
61 import org.jdom.Element;
|
|
|
62 import org.w3c.dom.*;
|
|
|
63
|
|
|
64 /**
|
|
|
65 * Builds a JDOM {@link org.jdom.Document org.jdom.Document} from a pre-existing
|
|
|
66 * DOM {@link org.w3c.dom.Document org.w3c.dom.Document}. Also handy for testing
|
|
|
67 * builds from files to sanity check {@link SAXBuilder}.
|
|
|
68 *
|
|
|
69 * @version $Revision: 1.60 $, $Date: 2007/11/10 05:29:00 $
|
|
|
70 * @author Brett McLaughlin
|
|
|
71 * @author Jason Hunter
|
|
|
72 * @author Philip Nelson
|
|
|
73 * @author Kevin Regan
|
|
|
74 * @author Yusuf Goolamabbas
|
|
|
75 * @author Dan Schaffer
|
|
|
76 * @author Bradley S. Huffman
|
|
|
77 */
|
|
|
78 public class DOMBuilder {
|
|
|
79
|
|
|
80 private static final String CVS_ID =
|
|
|
81 "@(#) $RCSfile: DOMBuilder.java,v $ $Revision: 1.60 $ $Date: 2007/11/10 05:29:00 $ $Name: jdom_1_1_1 $";
|
|
|
82
|
|
|
83 /** Adapter class to use */
|
|
|
84 private String adapterClass;
|
|
|
85
|
|
|
86 /** The factory for creating new JDOM objects */
|
|
|
87 private JDOMFactory factory = new DefaultJDOMFactory();
|
|
|
88
|
|
|
89 /**
|
|
|
90 * This creates a new DOMBuilder which will attempt to first locate
|
|
|
91 * a parser via JAXP, then will try to use a set of default parsers.
|
|
|
92 * The underlying parser will not validate.
|
|
|
93 */
|
|
|
94 public DOMBuilder() {
|
|
|
95 }
|
|
|
96
|
|
|
97 /**
|
|
|
98 * This creates a new DOMBuilder using the specified DOMAdapter
|
|
|
99 * implementation as a way to choose the underlying parser.
|
|
|
100 * The underlying parser will not validate.
|
|
|
101 *
|
|
|
102 * @param adapterClass <code>String</code> name of class
|
|
|
103 * to use for DOM building.
|
|
|
104 */
|
|
|
105 public DOMBuilder(String adapterClass) {
|
|
|
106 this.adapterClass = adapterClass;
|
|
|
107 }
|
|
|
108
|
|
|
109 /*
|
|
|
110 * This sets a custom JDOMFactory for the builder. Use this to build
|
|
|
111 * the tree with your own subclasses of the JDOM classes.
|
|
|
112 *
|
|
|
113 * @param factory <code>JDOMFactory</code> to use
|
|
|
114 */
|
|
|
115 public void setFactory(JDOMFactory factory) {
|
|
|
116 this.factory = factory;
|
|
|
117 }
|
|
|
118
|
|
|
119 /**
|
|
|
120 * Returns the current {@link org.jdom.JDOMFactory} in use.
|
|
|
121 * @return the factory in use
|
|
|
122 */
|
|
|
123 public JDOMFactory getFactory() {
|
|
|
124 return factory;
|
|
|
125 }
|
|
|
126
|
|
|
127 /**
|
|
|
128 * This will build a JDOM tree from an existing DOM tree.
|
|
|
129 *
|
|
|
130 * @param domDocument <code>org.w3c.dom.Document</code> object
|
|
|
131 * @return <code>Document</code> - JDOM document object.
|
|
|
132 */
|
|
|
133 public Document build(org.w3c.dom.Document domDocument) {
|
|
|
134 Document doc = factory.document(null);
|
|
|
135 buildTree(domDocument, doc, null, true);
|
|
|
136 return doc;
|
|
|
137 }
|
|
|
138
|
|
|
139 /**
|
|
|
140 * This will build a JDOM Element from an existing DOM Element
|
|
|
141 *
|
|
|
142 * @param domElement <code> org.w3c.dom.Element</code> object
|
|
|
143 * @return <code>Element</code> - JDOM Element object
|
|
|
144 */
|
|
|
145 public org.jdom.Element build(org.w3c.dom.Element domElement) {
|
|
|
146 Document doc = factory.document(null);
|
|
|
147 buildTree(domElement, doc, null, true);
|
|
|
148 return doc.getRootElement();
|
|
|
149 }
|
|
|
150
|
|
|
151 /**
|
|
|
152 * This takes a DOM <code>Node</code> and builds up
|
|
|
153 * a JDOM tree, recursing until the DOM tree is exhausted
|
|
|
154 * and the JDOM tree results.
|
|
|
155 *
|
|
|
156 * @param node <code>Code</node> to examine.
|
|
|
157 * @param doc JDOM <code>Document</code> being built.
|
|
|
158 * @param current <code>Element</code> that is current parent.
|
|
|
159 * @param atRoot <code>boolean</code> indicating whether at root level.
|
|
|
160 */
|
|
|
161 private void buildTree(Node node,
|
|
|
162 Document doc,
|
|
|
163 Element current,
|
|
|
164 boolean atRoot) {
|
|
|
165 // Recurse through the tree
|
|
|
166 switch (node.getNodeType()) {
|
|
|
167 case Node.DOCUMENT_NODE:
|
|
|
168 NodeList nodes = node.getChildNodes();
|
|
|
169 for (int i=0, size=nodes.getLength(); i<size; i++) {
|
|
|
170 buildTree(nodes.item(i), doc, current, true);
|
|
|
171 }
|
|
|
172 break;
|
|
|
173
|
|
|
174 case Node.ELEMENT_NODE:
|
|
|
175 String nodeName = node.getNodeName();
|
|
|
176 String prefix = "";
|
|
|
177 String localName = nodeName;
|
|
|
178 int colon = nodeName.indexOf(':');
|
|
|
179 if (colon >= 0) {
|
|
|
180 prefix = nodeName.substring(0, colon);
|
|
|
181 localName = nodeName.substring(colon + 1);
|
|
|
182 }
|
|
|
183
|
|
|
184 // Get element's namespace
|
|
|
185 Namespace ns = null;
|
|
|
186 String uri = node.getNamespaceURI();
|
|
|
187 if (uri == null) {
|
|
|
188 ns = (current == null) ? Namespace.NO_NAMESPACE
|
|
|
189 : current.getNamespace(prefix);
|
|
|
190 }
|
|
|
191 else {
|
|
|
192 ns = Namespace.getNamespace(prefix, uri);
|
|
|
193 }
|
|
|
194
|
|
|
195 Element element = factory.element(localName, ns);
|
|
|
196
|
|
|
197 if (atRoot) {
|
|
|
198 // If at root, set as document root
|
|
|
199 doc.setRootElement(element); // XXX should we use a factory call?
|
|
|
200 } else {
|
|
|
201 // else add to parent element
|
|
|
202 factory.addContent(current, element);
|
|
|
203 }
|
|
|
204
|
|
|
205 // Add namespaces
|
|
|
206 NamedNodeMap attributeList = node.getAttributes();
|
|
|
207 int attsize = attributeList.getLength();
|
|
|
208
|
|
|
209 for (int i = 0; i < attsize; i++) {
|
|
|
210 Attr att = (Attr) attributeList.item(i);
|
|
|
211
|
|
|
212 String attname = att.getName();
|
|
|
213 if (attname.startsWith("xmlns")) {
|
|
|
214 String attPrefix = "";
|
|
|
215 colon = attname.indexOf(':');
|
|
|
216 if (colon >= 0) {
|
|
|
217 attPrefix = attname.substring(colon + 1);
|
|
|
218 }
|
|
|
219
|
|
|
220 String attvalue = att.getValue();
|
|
|
221
|
|
|
222 Namespace declaredNS =
|
|
|
223 Namespace.getNamespace(attPrefix, attvalue);
|
|
|
224
|
|
|
225 // Add as additional namespaces if it's different
|
|
|
226 // than this element's namespace (perhaps we should
|
|
|
227 // also have logic not to mark them as additional if
|
|
|
228 // it's been done already, but it probably doesn't
|
|
|
229 // matter)
|
|
|
230 if (prefix.equals(attPrefix)) {
|
|
|
231 element.setNamespace(declaredNS);
|
|
|
232 }
|
|
|
233 else {
|
|
|
234 factory.addNamespaceDeclaration(element, declaredNS);
|
|
|
235 }
|
|
|
236 }
|
|
|
237 }
|
|
|
238
|
|
|
239 // Add attributes
|
|
|
240 for (int i = 0; i < attsize; i++) {
|
|
|
241 Attr att = (Attr) attributeList.item(i);
|
|
|
242
|
|
|
243 String attname = att.getName();
|
|
|
244
|
|
|
245 if ( !attname.startsWith("xmlns")) {
|
|
|
246 String attPrefix = "";
|
|
|
247 String attLocalName = attname;
|
|
|
248 colon = attname.indexOf(':');
|
|
|
249 if (colon >= 0) {
|
|
|
250 attPrefix = attname.substring(0, colon);
|
|
|
251 attLocalName = attname.substring(colon + 1);
|
|
|
252 }
|
|
|
253
|
|
|
254 String attvalue = att.getValue();
|
|
|
255
|
|
|
256 // Get attribute's namespace
|
|
|
257 Namespace attns = null;
|
|
|
258 if ("".equals(attPrefix)) {
|
|
|
259 attns = Namespace.NO_NAMESPACE;
|
|
|
260 }
|
|
|
261 else {
|
|
|
262 attns = element.getNamespace(attPrefix);
|
|
|
263 }
|
|
|
264
|
|
|
265 Attribute attribute =
|
|
|
266 factory.attribute(attLocalName, attvalue, attns);
|
|
|
267 factory.setAttribute(element, attribute);
|
|
|
268 }
|
|
|
269 }
|
|
|
270
|
|
|
271 // Recurse on child nodes
|
|
|
272 // The list should never be null nor should it ever contain
|
|
|
273 // null nodes, but some DOM impls are broken
|
|
|
274 NodeList children = node.getChildNodes();
|
|
|
275 if (children != null) {
|
|
|
276 int size = children.getLength();
|
|
|
277 for (int i = 0; i < size; i++) {
|
|
|
278 Node item = children.item(i);
|
|
|
279 if (item != null) {
|
|
|
280 buildTree(item, doc, element, false);
|
|
|
281 }
|
|
|
282 }
|
|
|
283 }
|
|
|
284 break;
|
|
|
285
|
|
|
286 case Node.TEXT_NODE:
|
|
|
287 String data = node.getNodeValue();
|
|
|
288 factory.addContent(current, factory.text(data));
|
|
|
289 break;
|
|
|
290
|
|
|
291 case Node.CDATA_SECTION_NODE:
|
|
|
292 String cdata = node.getNodeValue();
|
|
|
293 factory.addContent(current, factory.cdata(cdata));
|
|
|
294 break;
|
|
|
295
|
|
|
296
|
|
|
297 case Node.PROCESSING_INSTRUCTION_NODE:
|
|
|
298 if (atRoot) {
|
|
|
299 factory.addContent(doc,
|
|
|
300 factory.processingInstruction(node.getNodeName(),
|
|
|
301 node.getNodeValue()));
|
|
|
302 } else {
|
|
|
303 factory.addContent(current,
|
|
|
304 factory.processingInstruction(node.getNodeName(),
|
|
|
305 node.getNodeValue()));
|
|
|
306 }
|
|
|
307 break;
|
|
|
308
|
|
|
309 case Node.COMMENT_NODE:
|
|
|
310 if (atRoot) {
|
|
|
311 factory.addContent(doc, factory.comment(node.getNodeValue()));
|
|
|
312 } else {
|
|
|
313 factory.addContent(current, factory.comment(node.getNodeValue()));
|
|
|
314 }
|
|
|
315 break;
|
|
|
316
|
|
|
317 case Node.ENTITY_REFERENCE_NODE:
|
|
|
318 EntityRef entity = factory.entityRef(node.getNodeName());
|
|
|
319 factory.addContent(current, entity);
|
|
|
320 break;
|
|
|
321
|
|
|
322 case Node.ENTITY_NODE:
|
|
|
323 // ??
|
|
|
324 break;
|
|
|
325
|
|
|
326 case Node.DOCUMENT_TYPE_NODE:
|
|
|
327 DocumentType domDocType = (DocumentType)node;
|
|
|
328 String publicID = domDocType.getPublicId();
|
|
|
329 String systemID = domDocType.getSystemId();
|
|
|
330 String internalDTD = domDocType.getInternalSubset();
|
|
|
331
|
|
|
332 DocType docType = factory.docType(domDocType.getName());
|
|
|
333 docType.setPublicID(publicID);
|
|
|
334 docType.setSystemID(systemID);
|
|
|
335 docType.setInternalSubset(internalDTD);
|
|
|
336
|
|
|
337 factory.addContent(doc, docType);
|
|
|
338 break;
|
|
|
339 }
|
|
|
340 }
|
|
|
341 }
|
