DOMBuilder


1   /*--
2   
3    $Id: DOMBuilder.java,v 1.59 2004/09/03 06:03:41 jhunter Exp $
4   
5    Copyright (C) 2000-2004 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.59 $, $Date: 2004/09/03 06:03:41 $
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.59 $ $Date: 2004/09/03 06:03:41 $ $Name:  $";
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 }
342
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Popular Tags