1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19 package org.apache.wss4j.policy;
20
21 import javax.xml.namespace.QName;
22 import javax.xml.stream.XMLStreamException;
23 import javax.xml.stream.XMLStreamWriter;
24
25 import org.w3c.dom.Attr;
26 import org.w3c.dom.Document;
27 import org.w3c.dom.Element;
28 import org.w3c.dom.NamedNodeMap;
29 import org.w3c.dom.Node;
30 import org.w3c.dom.Text;
31
32 public final class SPUtils {
33
34 private SPUtils() {
35 }
36
37 public static boolean hasChildElements(Element element) {
38 Node firstChild = element.getFirstChild();
39 while (firstChild != null) {
40 if (firstChild.getNodeType() == Node.ELEMENT_NODE) {
41 return true;
42 }
43 firstChild = firstChild.getNextSibling();
44 }
45 return false;
46 }
47
48 public static Element getFirstPolicyChildElement(Element element) {
49 Element policy = getFirstChildElement(element, SPConstants.P_LOCALNAME);
50 if (policy != null && org.apache.neethi.Constants.isPolicyNS(policy.getNamespaceURI())) {
51 return policy;
52 }
53 return null;
54 }
55
56 public static boolean hasChildElementWithName(Element element, QName elementName) {
57 Element child = SPUtils.getFirstChildElement(element, elementName);
58 return child != null;
59 }
60
61 public static Element getFirstChildElement(Node parent, String childNodeName) {
62 Node node = parent.getFirstChild();
63 while (node != null && (Node.ELEMENT_NODE != node.getNodeType()
64 || !node.getLocalName().equals(childNodeName))) {
65 node = node.getNextSibling();
66 }
67 return (Element) node;
68 }
69
70 public static Element getFirstChildElement(Node parent, QName childNodeName) {
71 Node node = parent.getFirstChild();
72 while (node != null && (Node.ELEMENT_NODE != node.getNodeType()
73 || !isNodeEqualToQName(node, childNodeName))) {
74 node = node.getNextSibling();
75 }
76 return (Element) node;
77 }
78
79 private static boolean isNodeEqualToQName(Node node, QName nodeName) {
80 return (node.getNamespaceURI() == null && nodeName.getNamespaceURI() == null
81 || node.getNamespaceURI() != null
82 && node.getNamespaceURI().equals(nodeName.getNamespaceURI()))
83 && node.getLocalName().equals(nodeName.getLocalPart());
84 }
85
86 public static String getFirstChildElementText(Node parent, QName childNodeName) {
87 Element element = getFirstChildElement(parent, childNodeName);
88 return element != null ? element.getTextContent() : null;
89 }
90
91 public static Element getFirstChildElement(Node parent) {
92 Node node = parent.getFirstChild();
93 while (node != null && Node.ELEMENT_NODE != node.getNodeType()) {
94 node = node.getNextSibling();
95 }
96 return (Element) node;
97 }
98
99 public static Element getNextSiblingElement(Node node) {
100 Node n = node.getNextSibling();
101 while (n != null && Node.ELEMENT_NODE != n.getNodeType()) {
102 n = n.getNextSibling();
103 }
104 return (Element) n;
105 }
106
107 public static boolean isOptional(Element element) {
108 Attr attr = findOptionalAttribute(element);
109 if (attr != null) {
110 String v = attr.getValue();
111 return "true".equalsIgnoreCase(v) || "1".equals(v);
112 }
113 return false;
114 }
115
116 public static Attr findOptionalAttribute(Element element) {
117 NamedNodeMap attributes = element.getAttributes();
118 for (int x = 0; x < attributes.getLength(); x++) {
119 Attr attr = (Attr) attributes.item(x);
120 QName qName = new QName(attr.getNamespaceURI(), attr.getLocalName());
121 if (org.apache.neethi.Constants.isOptionalAttribute(qName)) {
122 return attr;
123 }
124 }
125 return null;
126 }
127
128 public static boolean isIgnorable(Element element) throws IllegalArgumentException {
129 Attr attr = findIgnorableAttribute(element);
130 if (attr != null) {
131 String value = attr.getValue();
132 if ("true".equalsIgnoreCase(value) || "1".equals(value)) {
133 if (SP13Constants.SP_NS.equals(element.getNamespaceURI())) {
134 throw new IllegalArgumentException("Ignorable attribute not allowed.");
135 }
136 return true;
137 }
138 }
139 return false;
140 }
141
142 public static Attr findIgnorableAttribute(Element element) {
143 NamedNodeMap attributes = element.getAttributes();
144 for (int x = 0; x < attributes.getLength(); x++) {
145 Attr attr = (Attr) attributes.item(x);
146 QName qName = new QName(attr.getNamespaceURI(), attr.getLocalName());
147 if (org.apache.neethi.Constants.isIgnorableAttribute(qName)) {
148 return attr;
149 }
150 }
151 return null;
152 }
153
154 public static String getAttribute(Element element, QName attName) {
155 Attr attr;
156 if (attName.getNamespaceURI() == null || attName.getNamespaceURI().length() == 0) {
157 attr = element.getAttributeNode(attName.getLocalPart());
158 } else {
159 attr = element.getAttributeNodeNS(attName.getNamespaceURI(), attName.getLocalPart());
160 }
161 return attr == null ? null : attr.getValue().trim();
162 }
163
164 public static QName getElementQName(Element element) {
165 return new QName(element.getNamespaceURI(), element.getLocalName(), element.getPrefix());
166 }
167
168 public static void serialize(Node node, XMLStreamWriter xmlStreamWriter) throws XMLStreamException {
169 if (node.getNodeType() == Node.DOCUMENT_NODE) {
170 Document document = (Document) node;
171 serialize(document.getDocumentElement(), xmlStreamWriter);
172 }
173 if (node.getNodeType() == Node.ELEMENT_NODE) {
174 Element element = (Element) node;
175 xmlStreamWriter.writeStartElement(element.getPrefix(), element.getLocalName(), element.getNamespaceURI());
176 NamedNodeMap namedNodeMap = element.getAttributes();
177 for (int i = 0; i < namedNodeMap.getLength(); i++) {
178 Attr attr = (Attr) namedNodeMap.item(i);
179 String prefix = attr.getPrefix();
180 if (prefix != null && "xmlns".equals(prefix)) {
181 xmlStreamWriter.writeNamespace(attr.getLocalName(), attr.getValue());
182 } else if (prefix == null && "xmlns".equals(attr.getLocalName())) {
183 xmlStreamWriter.writeDefaultNamespace(attr.getValue());
184 } else {
185 xmlStreamWriter.writeAttribute(prefix,
186 attr.getNamespaceURI(),
187 attr.getLocalName(),
188 attr.getValue());
189 }
190 }
191
192 if (element.getPrefix() != null) {
193 String ns = xmlStreamWriter.getNamespaceContext().getNamespaceURI(element.getPrefix());
194 if (ns == null) {
195 xmlStreamWriter.writeNamespace(element.getPrefix(), element.getNamespaceURI());
196 }
197 }
198 Node firstChild = element.getFirstChild();
199 while (firstChild != null) {
200 serialize(firstChild, xmlStreamWriter);
201 firstChild = firstChild.getNextSibling();
202 }
203 xmlStreamWriter.writeEndElement();
204 } else if (node.getNodeType() == Node.TEXT_NODE) {
205 Text text = (Text) node;
206 xmlStreamWriter.writeCharacters(text.getData());
207 }
208 }
209 }