1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18 package org.apache.commons.jxpath.ri;
19
20 import java.io.Serializable;
21 import java.util.HashMap;
22
23 import org.apache.commons.jxpath.Pointer;
24 import org.apache.commons.jxpath.ri.model.NodeIterator;
25 import org.apache.commons.jxpath.ri.model.NodePointer;
26
27
28
29
30 public class NamespaceResolver implements Cloneable, Serializable {
31
32 private static final long serialVersionUID = 1085590057838651311L;
33
34
35
36
37
38
39
40
41
42 protected static String getPrefix(final NodePointer pointer, final String namespaceURI) {
43 NodePointer currentPointer = pointer;
44 while (currentPointer != null) {
45 final NodeIterator ni = currentPointer.namespaceIterator();
46 for (int position = 1; ni != null && ni.setPosition(position); position++) {
47 final NodePointer nsPointer = ni.getNodePointer();
48 final String uri = nsPointer.getNamespaceURI();
49 if (uri.equals(namespaceURI)) {
50 final String prefix = nsPointer.getName().getName();
51 if (!"".equals(prefix)) {
52 return prefix;
53 }
54 }
55 }
56 currentPointer = currentPointer.getParent();
57 }
58 return null;
59 }
60
61
62 protected final NamespaceResolver parent;
63
64
65 protected HashMap<String, String> namespaceMap = new HashMap<>();
66
67
68 protected HashMap<String, String> reverseMap = new HashMap<>();
69
70
71 protected NodePointer pointer;
72
73
74
75
76 private boolean sealed;
77
78
79
80
81 public NamespaceResolver() {
82 this(null);
83 }
84
85
86
87
88
89
90 public NamespaceResolver(final NamespaceResolver parent) {
91 this.parent = parent;
92 }
93
94 @Override
95 public Object clone() {
96 try {
97 final NamespaceResolver result = (NamespaceResolver) super.clone();
98 result.sealed = false;
99 return result;
100 } catch (final CloneNotSupportedException e) {
101
102 e.printStackTrace();
103 return null;
104 }
105 }
106
107
108
109
110
111
112
113
114 protected synchronized String getExternallyRegisteredNamespaceURI(final String prefix) {
115 final String uri = namespaceMap.get(prefix);
116 return uri == null && parent != null ? parent.getExternallyRegisteredNamespaceURI(prefix) : uri;
117 }
118
119
120
121
122
123
124
125
126 protected synchronized String getExternallyRegisteredPrefix(final String namespaceURI) {
127 final String prefix = reverseMap.get(namespaceURI);
128 return prefix == null && parent != null ? parent.getExternallyRegisteredPrefix(namespaceURI) : prefix;
129 }
130
131
132
133
134
135
136 public Pointer getNamespaceContextPointer() {
137 if (pointer == null && parent != null) {
138 return parent.getNamespaceContextPointer();
139 }
140 return pointer;
141 }
142
143
144
145
146
147
148
149
150 public synchronized String getNamespaceURI(final String prefix) {
151 final String uri = getExternallyRegisteredNamespaceURI(prefix);
152 return uri == null && pointer != null ? pointer.getNamespaceURI(prefix) : uri;
153 }
154
155
156
157
158
159
160
161 public synchronized String getPrefix(final String namespaceURI) {
162 final String prefix = getExternallyRegisteredPrefix(namespaceURI);
163 return prefix == null && pointer != null ? getPrefix(pointer, namespaceURI) : prefix;
164 }
165
166
167
168
169
170
171 public boolean isSealed() {
172 return sealed;
173 }
174
175
176
177
178
179
180
181 public synchronized void registerNamespace(final String prefix, final String namespaceURI) {
182 if (isSealed()) {
183 throw new IllegalStateException("Cannot register namespaces on a sealed NamespaceResolver");
184 }
185 namespaceMap.put(prefix, namespaceURI);
186 reverseMap.put(namespaceURI, prefix);
187 }
188
189
190
191
192 public void seal() {
193 sealed = true;
194 if (parent != null) {
195 parent.seal();
196 }
197 }
198
199
200
201
202
203
204 public void setNamespaceContextPointer(final NodePointer pointer) {
205 this.pointer = pointer;
206 }
207 }