SimpleDOMTraversal


1   /*
2    * Enhydra Java Application Server Project
3    * 
4    * The contents of this file are subject to the Enhydra Public License
5    * Version 1.1 (the "License"); you may not use this file except in
6    * compliance with the License. You may obtain a copy of the License on
7    * the Enhydra web site ( http://www.enhydra.org/ ).
8    * 
9    * Software distributed under the License is distributed on an "AS IS"
10   * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See 
11   * the License for the specific terms governing rights and limitations
12   * under the License.
13   * 
14   * The Initial Developer of the Enhydra Application Server is Lutris
15   * Technologies, Inc. The Enhydra Application Server and portions created
16   * by Lutris Technologies, Inc. are Copyright Lutris Technologies, Inc.
17   * All Rights Reserved.
18   * 
19   * Contributor(s):
20   * 
21   * $Id: SimpleDOMTraversal.java,v 1.2 2005/01/26 08:29:24 jkjome Exp $
22   */
23  
24  package org.enhydra.xml.dom;
25  
26  import org.enhydra.xml.lazydom.LazyDOMSimpleTraversal;
27  import org.w3c.dom.Document  ;
28  import org.w3c.dom.DocumentType  ;
29  import org.w3c.dom.Element  ;
30  import org.w3c.dom.NamedNodeMap  ;
31  import org.w3c.dom.Node  ;
32  
33  //FIXME: Makes so it doesn't expand, but LazyDOM counts on this.
34  
35  /**
36   * Simple DOM traverser that calls a handler for every node in the DOM tree.
37   */
38  public class SimpleDOMTraversal {
39      /**
40       * Interface for node callback object.
41       */
42      public interface Handler {
43          /**
44           * Handler called for each Node.
45           */
46          public void handleNode(Node   node);
47      }
48  
49      /** Handler object for the traversal */
50      protected Handler fHandler;
51  
52      /**
53       * Constructor.
54       * @param handler The object that will be called to handle each
55       *  node.
56       */
57      public SimpleDOMTraversal(SimpleDOMTraversal.Handler handler) {
58          fHandler = handler;
59      }
60  
61      /**
62       * Traverse a DOM tree or subtree.
63       *
64       * @param root The root of the DOM tree or subtree that is to
65       *  be traversed.
66       */
67      public void traverse(Node   root) {
68          processNode(root);
69      }
70  
71      /**
72       * Process the children of a node.  
73       */
74      protected void processChildren(Node   node) {
75          //FIXME: Xerces sometimes has DocumentType objects as children (bug?)
76          for (Node   child = node.getFirstChild(); child != null;
77               child = child.getNextSibling()) {
78              if (!(child instanceof DocumentType  )) {
79                  processNode(child);
80              }
81          }
82      }
83      
84      /**
85       * Process the attributes of an element.
86       */
87      protected void processAttributes(Node   node) {
88          NamedNodeMap   attrMap = node.getAttributes();
89          int len = attrMap.getLength();
90          for (int i = 0; i < len; i++) {
91              processNode(attrMap.item(i));
92          }
93      }
94  
95      /**
96       * Process a DocumentType attribute of a Document node, if it exists.
97       */
98      public void processDocumentType(Document   document) {
99          DocumentType   docType = document.getDoctype();
100         if (docType != null) {
101             processNode(docType);
102         }
103     }
104 
105     /**
106      * Process the contents of a DocumentType node,
107      */
108     protected void processDocumentTypeContents(DocumentType   documentType) {
109         processNamedNodeMap(documentType.getEntities());
110         processNamedNodeMap(documentType.getNotations());
111     }
112 
113     /**
114      * Process contents of a NamedNodeMap.
115      */
116     private void processNamedNodeMap(NamedNodeMap   nodeMap) {
117         if (nodeMap != null) {
118             int len = nodeMap.getLength();
119             for (int i = 0; i < len; i++) {
120                 processNode(nodeMap.item(i));
121             }
122         }
123     }
124 
125     /**
126      * Processing based on node type.  All nodes go through here.
127      */
128     protected void processNode(Node   node) {
129         fHandler.handleNode(node);
130         if (node instanceof Document  ) {
131             processDocumentType((Document  )node);
132         } else if (node instanceof DocumentType  ) {
133             DocumentType   docType = (DocumentType  )node;
134             processNamedNodeMap(docType.getEntities());
135             processNamedNodeMap(docType.getNotations());
136         } else if (node instanceof Element  ) {
137             processAttributes(node);
138         }
139 
140         processChildren(node);
141     }
142 
143     /**
144      * Factory method to create a traverser based on the type of
145      * a document.
146      */
147     public static SimpleDOMTraversal getTraverser(SimpleDOMTraversal.Handler handler,
148                                                   Node   node) {
149         /* 
150          * Find the document to determine type.  The LazyDOM traverser is only
151          * used on instance documents.  If a template DOM node is specified,
152          * the template LazyDocument is traverse as any other done.
153          */
154         if (DOMOps.isLazyDOMInstance(DOMOps.getDocument(node))) {
155             return new LazyDOMSimpleTraversal(handler);
156         } else {
157             return new SimpleDOMTraversal(handler);
158         }
159     }
160 }
161
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Free Books Free Magazines
Popular Tags