OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [libjava/] [classpath/] [gnu/] [xml/] [dom/] [DomNodeIterator.java] - Blame information for rev 769

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 769 jeremybenn 
/* DomNodeIterator.java --
2 
   Copyright (C) 2004 Free Software Foundation, Inc.
3 
 
4 
This file is part of GNU Classpath.
5 
 
6 
GNU Classpath is free software; you can redistribute it and/or modify
7 
it under the terms of the GNU General Public License as published by
8 
the Free Software Foundation; either version 2, or (at your option)
9 
any later version.
10 
 
11 
GNU Classpath is distributed in the hope that it will be useful, but
12 
WITHOUT ANY WARRANTY; without even the implied warranty of
13 
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14 
General Public License for more details.
15 
 
16 
You should have received a copy of the GNU General Public License
17 
along with GNU Classpath; see the file COPYING.  If not, write to the
18 
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
19 
02110-1301 USA.
20 
 
21 
Linking this library statically or dynamically with other modules is
22 
making a combined work based on this library.  Thus, the terms and
23 
conditions of the GNU General Public License cover the whole
24 
combination.
25 
 
26 
As a special exception, the copyright holders of this library give you
27 
permission to link this library with independent modules to produce an
28 
executable, regardless of the license terms of these independent
29 
modules, and to copy and distribute the resulting executable under
30 
terms of your choice, provided that you also meet, for each linked
31 
independent module, the terms and conditions of the license of that
32 
module.  An independent module is a module which is not derived from
33 
or based on this library.  If you modify this library, you may extend
34 
this exception to your version of the library, but you are not
35 
obligated to do so.  If you do not wish to do so, delete this
36 
exception statement from your version. */
37 
package gnu.xml.dom;
38 
 
39 
import org.w3c.dom.DOMException;
40 
import org.w3c.dom.Node;
41 
import org.w3c.dom.traversal.NodeFilter;
42 
import org.w3c.dom.traversal.NodeIterator;
43 
import org.w3c.dom.traversal.TreeWalker;
44 
 
45 
/**
46 
 * Node iterator and tree walker.
47 
 *
48 
 * @author <a href='mailto:dog@gnu.org'>Chris Burdess</a>
49 
 */
50 
public class DomNodeIterator
51 
  implements NodeIterator, TreeWalker
52 
{
53 
 
54 
  Node root;
55 
  final int whatToShow;
56 
  final NodeFilter filter;
57 
  final boolean entityReferenceExpansion;
58 
  final boolean walk;
59 
  Node current;
60 
 
61 
  public DomNodeIterator(Node root, int whatToShow, NodeFilter filter,
62 
                         boolean entityReferenceExpansion, boolean walk)
63 
  {
64 
    if (root == null)
65 
      {
66 
        throw new DOMException(DOMException.NOT_SUPPORTED_ERR, "null root");
67 
      }
68 
    this.root = root;
69 
    this.whatToShow = whatToShow;
70 
    this.filter = filter;
71 
    this.entityReferenceExpansion = entityReferenceExpansion;
72 
    this.walk = walk;
73 
    current = root;
74 
  }
75 
 
76 
  public Node getRoot()
77 
  {
78 
    return root;
79 
  }
80 
 
81 
  public int getWhatToShow()
82 
  {
83 
    return whatToShow;
84 
  }
85 
 
86 
  public NodeFilter getFilter()
87 
  {
88 
    return filter;
89 
  }
90 
 
91 
  public boolean getExpandEntityReferences()
92 
  {
93 
    return entityReferenceExpansion;
94 
  }
95 
 
96 
  public Node nextNode()
97 
    throws DOMException
98 
  {
99 
    if (root == null)
100 
      {
101 
        throw new DOMException(DOMException.INVALID_STATE_ERR, "null root");
102 
      }
103 
    Node ret;
104 
    do
105 
      {
106 
        if (current.equals(root))
107 
          {
108 
            ret = root.getFirstChild();
109 
          }
110 
        else if (walk)
111 
          {
112 
            ret = current.getFirstChild();
113 
            if (ret == null)
114 
              {
115 
                ret = current.getNextSibling();
116 
              }
117 
            if (ret == null)
118 
              {
119 
                Node tmp = current;
120 
                ret = tmp.getParentNode();
121 
                while (!ret.equals(root) && tmp.equals(ret.getLastChild()))
122 
                  {
123 
                    tmp = ret;
124 
                    ret = tmp.getParentNode();
125 
                  }
126 
                if (ret.equals(root))
127 
                  {
128 
                    ret = null;
129 
                  }
130 
                else
131 
                  {
132 
                    ret = ret.getNextSibling();
133 
                  }
134 
              }
135 
          }
136 
        else
137 
          {
138 
            ret = current.getNextSibling();
139 
          }
140 
        current = (ret == null) ? current : ret;
141 
      }
142 
    while (!accept(ret));
143 
 
144 
    return ret;
145 
  }
146 
 
147 
  public Node previousNode()
148 
    throws DOMException
149 
  {
150 
    if (root == null)
151 
      {
152 
        throw new DOMException(DOMException.INVALID_STATE_ERR, "null root");
153 
      }
154 
    Node ret;
155 
    do
156 
      {
157 
        if (current.equals(root))
158 
          {
159 
            ret = current.getLastChild();
160 
          }
161 
        else if (walk)
162 
          {
163 
            ret = current.getLastChild();
164 
            if (ret == null)
165 
              {
166 
                ret = current.getPreviousSibling();
167 
              }
168 
            if (ret == null)
169 
              {
170 
                Node tmp = current;
171 
                ret = tmp.getParentNode();
172 
                while (!ret.equals(root) && tmp.equals(ret.getFirstChild()))
173 
                  {
174 
                    tmp = ret;
175 
                    ret = tmp.getParentNode();
176 
                  }
177 
                if (ret.equals(root))
178 
                  {
179 
                    ret = null;
180 
                  }
181 
                else
182 
                  {
183 
                    ret = ret.getPreviousSibling();
184 
                  }
185 
              }
186 
          }
187 
        else
188 
          {
189 
            ret = current.getPreviousSibling();
190 
          }
191 
      }
192 
    while (!accept(ret));
193 
    current = (ret == null) ? current : ret;
194 
    return ret;
195 
  }
196 
 
197 
  public Node getCurrentNode()
198 
  {
199 
    return current;
200 
  }
201 
 
202 
  public void setCurrentNode(Node current)
203 
    throws DOMException
204 
  {
205 
    if (current == null)
206 
      {
207 
        throw new DOMException(DOMException.NOT_SUPPORTED_ERR, "null root");
208 
      }
209 
    this.current = current;
210 
  }
211 
 
212 
  public Node parentNode()
213 
  {
214 
    Node ret = current.getParentNode();
215 
    if (!accept (ret))
216 
      {
217 
        ret = null;
218 
      }
219 
    current = (ret == null) ? current : ret;
220 
    return ret;
221 
  }
222 
 
223 
  public Node firstChild ()
224 
  {
225 
    Node ret = current.getFirstChild();
226 
    while (!accept(ret))
227 
      {
228 
        ret = ret.getNextSibling();
229 
      }
230 
    current = (ret == null) ? current : ret;
231 
    return ret;
232 
  }
233 
 
234 
  public Node lastChild()
235 
  {
236 
    Node ret = current.getLastChild();
237 
    while (!accept(ret))
238 
      {
239 
        ret = ret.getPreviousSibling();
240 
      }
241 
    current = (ret == null) ? current : ret;
242 
    return ret;
243 
  }
244 
 
245 
  public Node previousSibling()
246 
  {
247 
    Node ret = current.getPreviousSibling();
248 
    while (!accept(ret))
249 
      {
250 
        ret = ret.getPreviousSibling();
251 
      }
252 
    current = (ret == null) ? current : ret;
253 
    return ret;
254 
  }
255 
 
256 
  public Node nextSibling()
257 
  {
258 
    Node ret = current.getNextSibling();
259 
    while (!accept(ret))
260 
      {
261 
        ret = ret.getNextSibling();
262 
      }
263 
    current = (ret == null) ? current : ret;
264 
    return ret;
265 
  }
266 
 
267 
  public void detach()
268 
  {
269 
    root = null;
270 
  }
271 
 
272 
  boolean accept(Node node)
273 
  {
274 
    if (node == null)
275 
      {
276 
        return true;
277 
      }
278 
    boolean ret;
279 
    switch (node.getNodeType())
280 
      {
281 
      case Node.ATTRIBUTE_NODE:
282 
        ret = (whatToShow & NodeFilter.SHOW_ATTRIBUTE) != 0;
283 
        break;
284 
      case Node.CDATA_SECTION_NODE:
285 
        ret = (whatToShow & NodeFilter.SHOW_CDATA_SECTION) != 0;
286 
        break;
287 
      case Node.COMMENT_NODE:
288 
        ret = (whatToShow & NodeFilter.SHOW_COMMENT) != 0;
289 
        break;
290 
      case Node.DOCUMENT_NODE:
291 
        ret = (whatToShow & NodeFilter.SHOW_DOCUMENT) != 0;
292 
        break;
293 
      case Node.DOCUMENT_FRAGMENT_NODE:
294 
        ret = (whatToShow & NodeFilter.SHOW_DOCUMENT_FRAGMENT) != 0;
295 
        break;
296 
      case Node.DOCUMENT_TYPE_NODE:
297 
        ret = (whatToShow & NodeFilter.SHOW_DOCUMENT_TYPE) != 0;
298 
        break;
299 
      case Node.ELEMENT_NODE:
300 
        ret = (whatToShow & NodeFilter.SHOW_ELEMENT) != 0;
301 
        break;
302 
      case Node.ENTITY_NODE:
303 
        ret = (whatToShow & NodeFilter.SHOW_ENTITY) != 0;
304 
        break;
305 
      case Node.ENTITY_REFERENCE_NODE:
306 
        ret = (whatToShow & NodeFilter.SHOW_ENTITY_REFERENCE) != 0;
307 
        ret = ret && entityReferenceExpansion;
308 
        break;
309 
      case Node.NOTATION_NODE:
310 
        ret = (whatToShow & NodeFilter.SHOW_NOTATION) != 0;
311 
        break;
312 
      case Node.PROCESSING_INSTRUCTION_NODE:
313 
        ret = (whatToShow & NodeFilter.SHOW_PROCESSING_INSTRUCTION) != 0;
314 
        break;
315 
      case Node.TEXT_NODE:
316 
        ret = (whatToShow & NodeFilter.SHOW_TEXT) != 0;
317 
        break;
318 
      default:
319 
        ret = true;
320 
      }
321 
    if (ret && filter != null)
322 
      {
323 
        ret = (filter.acceptNode(node) == NodeFilter.FILTER_ACCEPT);
324 
      }
325 
    return ret;
326 
  }
327 
 
328 
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.