View Javadoc

1   /*
2    * Copyright 1999-2004 The Apache Software Foundation
3    *
4    * Licensed under the Apache License, Version 2.0 (the "License");
5    * you may not use this file except in compliance with the License.
6    * You may obtain a copy of the License at
7    *
8    *     http://www.apache.org/licenses/LICENSE-2.0
9    *
10   * Unless required by applicable law or agreed to in writing, software
11   * distributed under the License is distributed on an "AS IS" BASIS,
12   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13   * See the License for the specific language governing permissions and
14   * limitations under the License.
15   */
16  package org.apache.commons.jxpath.ri.model.jdom;
17  
18  import java.util.ArrayList;
19  import java.util.Collections;
20  import java.util.List;
21  
22  import org.apache.commons.jxpath.ri.QName;
23  import org.apache.commons.jxpath.ri.model.NodeIterator;
24  import org.apache.commons.jxpath.ri.model.NodePointer;
25  import org.jdom.Attribute;
26  import org.jdom.Element;
27  import org.jdom.Namespace;
28  
29  /***
30   * An iterator of attributes of a DOM Node.
31   *
32   * @author Dmitri Plotnikov
33   * @version $Revision: 1.6 $ $Date: 2004/02/29 14:17:40 $
34   */
35  public class JDOMAttributeIterator implements NodeIterator {
36      private NodePointer parent;
37      private QName name;
38      private List attributes;
39      private int position = 0;
40  
41      public JDOMAttributeIterator(NodePointer parent, QName name) {
42          this.parent = parent;
43          this.name = name;
44          if (parent.getNode() instanceof Element) {
45              Element element = (Element) parent.getNode();
46              String prefix = name.getPrefix();
47              Namespace ns;
48              if (prefix != null) {
49                  if (prefix.equals("xml")) {
50                      ns = Namespace.XML_NAMESPACE;
51                  }
52                  else {
53                      ns = element.getNamespace(prefix);
54                      if (ns == null) {
55                          // TBD: no attributes
56                          attributes = Collections.EMPTY_LIST;
57                          return;
58                      }
59                  }
60              }
61              else {
62                  ns = Namespace.NO_NAMESPACE;
63              }
64  
65              String lname = name.getName();
66              if (!lname.equals("*")) {
67                  attributes = new ArrayList();
68                  if (ns != null) {
69                      Attribute attr = element.getAttribute(lname, ns);
70                      if (attr != null) {
71                          attributes.add(attr);
72                      }
73                  }
74              }
75              else {
76                  attributes = new ArrayList();
77                  List allAttributes = element.getAttributes();
78                  for (int i = 0; i < allAttributes.size(); i++) {
79                      Attribute attr = (Attribute) allAttributes.get(i);
80                      if (attr.getNamespace().equals(ns)) {
81                          attributes.add(attr);
82                      }
83                  }
84              }
85          }
86      }
87  
88      /*
89      private boolean testAttr(Attr attr, QName testName) {
90          String nodePrefix = DOMNodePointer.getPrefix(attr);
91          String nodeLocalName = DOMNodePointer.getLocalName(attr);
92  
93          if (nodePrefix != null && nodePrefix.equals("xmlns")) {
94              return false;
95          }
96  
97          if (nodePrefix == null && nodeLocalName.equals("xmlns")) {
98              return false;
99          }
100 
101         String testLocalName = name.getName();
102         if (testLocalName.equals("*") || testLocalName.equals(nodeLocalName)) {
103             String testPrefix = testName.getPrefix();
104 
105             if (equalStrings(testPrefix, nodePrefix)) {
106                 return true;
107             }
108 
109             String testNS = null;
110             if (testPrefix != null) {
111                 testNS = parent.getNamespaceURI(testPrefix);
112             }
113 
114             String nodeNS = null;
115             if (nodePrefix != null) {
116                 nodeNS = parent.getNamespaceURI(nodePrefix);
117             }
118             return equalStrings(testNS, nodeNS);
119         }
120         return false;
121     }
122 
123     private static boolean equalStrings(String s1, String s2) {
124         if (s1 == null && s2 != null) {
125             return false;
126         }
127         if (s1 != null && !s1.equals(s2)) {
128             return false;
129         }
130         return true;
131     }
132 
133     private Attr getAttribute(Element element, QName name) {
134         String testPrefix = name.getPrefix();
135         String testNS = null;
136 
137         if (testPrefix != null) {
138             testNS = parent.getNamespaceURI(testPrefix);
139         }
140 
141         if (testNS != null) {
142             Attr attr = element.getAttributeNodeNS(testNS, name.getName());
143             if (attr == null) {
144                 // This may mean that the parser does not support NS for
145                 // attributes, example - the version of Crimson bundled
146                 // with JDK 1.4.0
147                 NamedNodeMap nnm = element.getAttributes();
148                 for (int i = 0; i < nnm.getLength(); i++) {
149                     attr = (Attr)nnm.item(i);
150                     if (testAttr(attr, name)) {
151                         return attr;
152                     }
153                 }
154             }
155             return attr;
156         }
157         else {
158             return element.getAttributeNode(name.getName());
159         }
160     }
161 */
162     public NodePointer getNodePointer() {
163         if (position == 0) {
164             if (!setPosition(1)) {
165                 return null;
166             }
167             position = 0;
168         }
169         int index = position - 1;
170         if (index < 0) {
171             index = 0;
172         }
173         return new JDOMAttributePointer(
174             parent,
175             (Attribute) attributes.get(index));
176     }
177 
178     public int getPosition() {
179         return position;
180     }
181 
182     public boolean setPosition(int position) {
183         if (attributes == null) {
184             return false;
185         }
186         this.position = position;
187         return position >= 1 && position <= attributes.size();
188     }
189 }