1 /*
2 * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
3 */
4 /*
5 * Licensed to the Apache Software Foundation (ASF) under one or more
6 * contributor license agreements. See the NOTICE file distributed with
7 * this work for additional information regarding copyright ownership.
8 * The ASF licenses this file to You under the Apache License, Version 2.0
9 * (the "License"); you may not use this file except in compliance with
10 * the License. You may obtain a copy of the License at
11 *
12 * http://www.apache.org/licenses/LICENSE-2.0
13 *
14 * Unless required by applicable law or agreed to in writing, software
15 * distributed under the License is distributed on an "AS IS" BASIS,
16 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17 * See the License for the specific language governing permissions and
18 * limitations under the License.
19 */
20 /*
21 * $Id: DOMAdapter.java,v 1.2.4.1 2005/09/06 06:07:28 pvedula Exp $
22 */
23
24 package com.sun.org.apache.xalan.internal.xsltc.dom;
25
26 import com.sun.org.apache.xalan.internal.xsltc.DOM;
27 import com.sun.org.apache.xalan.internal.xsltc.DOMEnhancedForDTM;
28 import com.sun.org.apache.xalan.internal.xsltc.StripFilter;
29 import com.sun.org.apache.xalan.internal.xsltc.TransletException;
30 import com.sun.org.apache.xml.internal.dtm.DTM;
31 import com.sun.org.apache.xml.internal.dtm.DTMAxisIterator;
32 import com.sun.org.apache.xml.internal.serializer.SerializationHandler;
33 import java.util.Map;
34 import org.w3c.dom.Node;
35 import org.w3c.dom.NodeList;
36
37 /**
38 * @author Jacek Ambroziak
39 * @author Morten Jorgensen
40 */
41 public final class DOMAdapter implements DOM {
42
43 // Mutually exclusive casting of DOM interface to known implementations
44 private DOMEnhancedForDTM _enhancedDOM;
45
46 private DOM _dom;
47
48 private String[] _namesArray;
49 private String[] _urisArray;
50 private int[] _typesArray;
51 private String[] _namespaceArray;
52
53 // Cached mappings
54 private short[] _mapping = null;
55 private int[] _reverse = null;
56 private short[] _NSmapping = null;
57 private short[] _NSreverse = null;
58
59 private StripFilter _filter = null;
60
61 private int _multiDOMMask;
62
63 public DOMAdapter(DOM dom,
64 String[] namesArray,
65 String[] urisArray,
66 int[] typesArray,
67 String[] namespaceArray) {
68 if (dom instanceof DOMEnhancedForDTM){
69 _enhancedDOM = (DOMEnhancedForDTM) dom;
70 }
71
72 _dom = dom;
73 _namesArray = namesArray;
74 _urisArray = urisArray;
75 _typesArray = typesArray;
76 _namespaceArray = namespaceArray;
77 }
78
79 public void setupMapping(String[] names, String[] urisArray,
80 int[] typesArray, String[] namespaces) {
81 _namesArray = names;
82 _urisArray = urisArray;
83 _typesArray = typesArray;
84 _namespaceArray = namespaces;
85 }
86
87 public String[] getNamesArray() {
88 return _namesArray;
89 }
90
91 public String[] getUrisArray() {
92 return _urisArray;
93 }
94
95 public int[] getTypesArray() {
96 return _typesArray;
97 }
98
99 public String[] getNamespaceArray() {
100 return _namespaceArray;
101 }
102
103 public DOM getDOMImpl() {
104 return _dom;
105 }
106
107 private short[] getMapping() {
108 if (_mapping == null) {
109 if (_enhancedDOM != null) {
110 _mapping = _enhancedDOM.getMapping(_namesArray, _urisArray,
111 _typesArray);
112 }
113 }
114 return _mapping;
115 }
116
117 private int[] getReverse() {
118 if (_reverse == null) {
119 if (_enhancedDOM != null) {
120 _reverse = _enhancedDOM.getReverseMapping(_namesArray,
121 _urisArray,
122 _typesArray);
123 }
124 }
125 return _reverse;
126 }
127
128 private short[] getNSMapping() {
129 if (_NSmapping == null) {
130 if (_enhancedDOM != null) {
131 _NSmapping = _enhancedDOM.getNamespaceMapping(_namespaceArray);
132 }
133 }
134 return _NSmapping;
135 }
136
137 private short[] getNSReverse() {
138 if (_NSreverse == null) {
139 if (_enhancedDOM != null) {
140 _NSreverse = _enhancedDOM
141 .getReverseNamespaceMapping(_namespaceArray);
142 }
143 }
144 return _NSreverse;
145 }
146
147 /**
148 * Returns singleton iterator containg the document root
149 */
150 public DTMAxisIterator getIterator() {
151 return _dom.getIterator();
152 }
153
154 public String getStringValue() {
155 return _dom.getStringValue();
156 }
157
158 public DTMAxisIterator getChildren(final int node) {
159 if (_enhancedDOM != null) {
160 return _enhancedDOM.getChildren(node);
161 }
162 else {
163 DTMAxisIterator iterator = _dom.getChildren(node);
164 return iterator.setStartNode(node);
165 }
166 }
167
168 public void setFilter(StripFilter filter) {
169 _filter = filter;
170 }
171
172 public DTMAxisIterator getTypedChildren(final int type) {
173 final int[] reverse = getReverse();
174
175 if (_enhancedDOM != null) {
176 return _enhancedDOM.getTypedChildren(reverse[type]);
177 }
178 else {
179 return _dom.getTypedChildren(type);
180 }
181 }
182
183 public DTMAxisIterator getNamespaceAxisIterator(final int axis,
184 final int ns) {
185 return _dom.getNamespaceAxisIterator(axis, getNSReverse()[ns]);
186 }
187
188 public DTMAxisIterator getAxisIterator(final int axis) {
189 if (_enhancedDOM != null) {
190 return _enhancedDOM.getAxisIterator(axis);
191 }
192 else {
193 return _dom.getAxisIterator(axis);
194 }
195 }
196
197 public DTMAxisIterator getTypedAxisIterator(final int axis,
198 final int type) {
199 final int[] reverse = getReverse();
200 if (_enhancedDOM != null) {
201 return _enhancedDOM.getTypedAxisIterator(axis, reverse[type]);
202 } else {
203 return _dom.getTypedAxisIterator(axis, type);
204 }
205 }
206
207 public int getMultiDOMMask() {
208 return _multiDOMMask;
209 }
210
211 public void setMultiDOMMask(int mask) {
212 _multiDOMMask = mask;
213 }
214
215 public DTMAxisIterator getNthDescendant(int type, int n,
216 boolean includeself) {
217 return _dom.getNthDescendant(getReverse()[type], n, includeself);
218 }
219
220 public DTMAxisIterator getNodeValueIterator(DTMAxisIterator iterator,
221 int type, String value,
222 boolean op) {
223 return _dom.getNodeValueIterator(iterator, type, value, op);
224 }
225
226 public DTMAxisIterator orderNodes(DTMAxisIterator source, int node) {
227 return _dom.orderNodes(source, node);
228 }
229
230 public int getExpandedTypeID(final int node) {
231 final short[] mapping = getMapping();
232 final int type;
233 if (_enhancedDOM != null) {
234 type = mapping[_enhancedDOM.getExpandedTypeID2(node)];
235 }
236 else {
237 if(null != mapping)
238 {
239 type = mapping[_dom.getExpandedTypeID(node)];
240 }
241 else
242 {
243 type = _dom.getExpandedTypeID(node);
244 }
245 }
246 return type;
247 }
248
249 public int getNamespaceType(final int node) {
250 return getNSMapping()[_dom.getNSType(node)];
251 }
252
253 public int getNSType(int node) {
254 return _dom.getNSType(node);
255 }
256
257 public int getParent(final int node) {
258 return _dom.getParent(node);
259 }
260
261 public int getAttributeNode(final int type, final int element) {
262 return _dom.getAttributeNode(getReverse()[type], element);
263 }
264
265 public String getNodeName(final int node) {
266 if (node == DTM.NULL) {
267 return "";
268 }
269 return _dom.getNodeName(node);
270 }
271
272 public String getNodeNameX(final int node)
273 {
274 if (node == DTM.NULL) {
275 return "";
276 }
277 return _dom.getNodeNameX(node);
278 }
279
280 public String getNamespaceName(final int node)
281 {
282 if (node == DTM.NULL) {
283 return "";
284 }
285 return _dom.getNamespaceName(node);
286 }
287
288 public String getStringValueX(final int node)
289 {
290 if (_enhancedDOM != null) {
291 return _enhancedDOM.getStringValueX(node);
292 }
293 else {
294 if (node == DTM.NULL) {
295 return "";
296 }
297 return _dom.getStringValueX(node);
298 }
299 }
300
301 public void copy(final int node, SerializationHandler handler)
302 throws TransletException
303 {
304 _dom.copy(node, handler);
305 }
306
307 public void copy(DTMAxisIterator nodes,SerializationHandler handler)
308 throws TransletException
309 {
310 _dom.copy(nodes, handler);
311 }
312
313 public String shallowCopy(final int node, SerializationHandler handler)
314 throws TransletException
315 {
316 if (_enhancedDOM != null) {
317 return _enhancedDOM.shallowCopy(node, handler);
318 }
319 else {
320 return _dom.shallowCopy(node, handler);
321 }
322 }
323
324 public boolean lessThan(final int node1, final int node2)
325 {
326 return _dom.lessThan(node1, node2);
327 }
328
329 public void characters(final int textNode, SerializationHandler handler)
330 throws TransletException
331 {
332 if (_enhancedDOM != null) {
333 _enhancedDOM.characters(textNode, handler);
334 }
335 else {
336 _dom.characters(textNode, handler);
337 }
338 }
339
340 public Node makeNode(int index)
341 {
342 return _dom.makeNode(index);
343 }
344
345 public Node makeNode(DTMAxisIterator iter)
346 {
347 return _dom.makeNode(iter);
348 }
349
350 public NodeList makeNodeList(int index)
351 {
352 return _dom.makeNodeList(index);
353 }
354
355 public NodeList makeNodeList(DTMAxisIterator iter)
356 {
357 return _dom.makeNodeList(iter);
358 }
359
360 public String getLanguage(int node)
361 {
362 return _dom.getLanguage(node);
363 }
364
365 public int getSize()
366 {
367 return _dom.getSize();
368 }
369
370 public void setDocumentURI(String uri)
371 {
372 if (_enhancedDOM != null) {
373 _enhancedDOM.setDocumentURI(uri);
374 }
375 }
376
377 public String getDocumentURI()
378 {
379 if (_enhancedDOM != null) {
380 return _enhancedDOM.getDocumentURI();
381 }
382 else {
383 return "";
384 }
385 }
386
387 public String getDocumentURI(int node)
388 {
389 return _dom.getDocumentURI(node);
390 }
391
392 public int getDocument()
393 {
394 return _dom.getDocument();
395 }
396
397 public boolean isElement(final int node)
398 {
399 return(_dom.isElement(node));
400 }
401
402 public boolean isAttribute(final int node)
403 {
404 return(_dom.isAttribute(node));
405 }
406
407 public int getNodeIdent(int nodeHandle)
408 {
409 return _dom.getNodeIdent(nodeHandle);
410 }
411
412 public int getNodeHandle(int nodeId)
413 {
414 return _dom.getNodeHandle(nodeId);
415 }
416
417 /**
418 * Return a instance of a DOM class to be used as an RTF
419 */
420 public DOM getResultTreeFrag(int initSize, int rtfType)
421 {
422 if (_enhancedDOM != null) {
423 return _enhancedDOM.getResultTreeFrag(initSize, rtfType);
424 }
425 else {
426 return _dom.getResultTreeFrag(initSize, rtfType);
427 }
428 }
429
430 /**
431 * Return a instance of a DOM class to be used as an RTF
432 */
433 public DOM getResultTreeFrag(int initSize, int rtfType,
434 boolean addToManager)
435 {
436 if (_enhancedDOM != null) {
437 return _enhancedDOM.getResultTreeFrag(initSize, rtfType,
438 addToManager);
439 }
440 else {
441 return _dom.getResultTreeFrag(initSize, rtfType, addToManager);
442 }
443 }
444
445
446 /**
447 * Returns a SerializationHandler class wrapped in a SAX adapter.
448 */
449 public SerializationHandler getOutputDomBuilder()
450 {
451 return _dom.getOutputDomBuilder();
452 }
453
454 public String lookupNamespace(int node, String prefix)
455 throws TransletException
456 {
457 return _dom.lookupNamespace(node, prefix);
458 }
459
460 public String getUnparsedEntityURI(String entity) {
461 return _dom.getUnparsedEntityURI(entity);
462 }
463
464 public Map<String, Integer> getElementsWithIDs() {
465 return _dom.getElementsWithIDs();
466 }
467 }