blob: fd54fe6fb66a67870f02e26bfd3c2aaea4e6b34d (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
|
/*
* reserved comment block
* DO NOT REMOVE OR ALTER!
*/
/*
* Copyright 1999-2002,2004 The Apache Software Foundation.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/*
* WARNING: because java doesn't support multi-inheritance some code is
* duplicated. If you're changing this file you probably want to change
* DeferredElementImpl.java at the same time.
*
*/
package com.sun.org.apache.xerces.internal.dom;
import com.sun.org.apache.xerces.internal.xni.NamespaceContext;
import com.sun.org.apache.xerces.internal.xs.XSTypeDefinition;
import org.w3c.dom.NamedNodeMap;
/**
* DeferredElementNSImpl is to ElementNSImpl, what DeferredElementImpl is to
* ElementImpl.
*
* @xerces.internal
*
* @see DeferredElementImpl
*/
public class DeferredElementNSImpl
extends ElementNSImpl
implements DeferredNode {
//
// Constants
//
/** Serialization version. */
static final long serialVersionUID = -5001885145370927385L;
//
// Data
//
/** Node index. */
protected transient int fNodeIndex;
//
// Constructors
//
/**
* This is the deferred constructor. Only the fNodeIndex is given here. All
* other data, can be requested from the ownerDocument via the index.
*/
DeferredElementNSImpl(DeferredDocumentImpl ownerDoc, int nodeIndex) {
super(ownerDoc, null);
fNodeIndex = nodeIndex;
needsSyncChildren(true);
} // <init>(DocumentImpl,int)
//
// DeferredNode methods
//
/** Returns the node index. */
public final int getNodeIndex() {
return fNodeIndex;
}
//
// Protected methods
//
/** Synchronizes the data (name and value) for fast nodes. */
protected final void synchronizeData() {
// no need to sync in the future
needsSyncData(false);
// fluff data
DeferredDocumentImpl ownerDocument =
(DeferredDocumentImpl) this.ownerDocument;
// we don't want to generate any event for this so turn them off
boolean orig = ownerDocument.mutationEvents;
ownerDocument.mutationEvents = false;
name = ownerDocument.getNodeName(fNodeIndex);
// extract local part from QName
int index = name.indexOf(':');
if (index < 0) {
localName = name;
}
else {
localName = name.substring(index + 1);
}
namespaceURI = ownerDocument.getNodeURI(fNodeIndex);
type = (XSTypeDefinition)ownerDocument.getTypeInfo(fNodeIndex);
// attributes
setupDefaultAttributes();
int attrIndex = ownerDocument.getNodeExtra(fNodeIndex);
if (attrIndex != -1) {
NamedNodeMap attrs = getAttributes();
boolean seenSchemaDefault = false;
do {
AttrImpl attr = (AttrImpl) ownerDocument.getNodeObject(attrIndex);
// Take special care of schema defaulted attributes. Calling the
// non-namespace aware setAttributeNode() method could overwrite
// another attribute with the same local name.
if (!attr.getSpecified() && (seenSchemaDefault ||
(attr.getNamespaceURI() != null &&
attr.getNamespaceURI() != NamespaceContext.XMLNS_URI &&
attr.getName().indexOf(':') < 0))) {
seenSchemaDefault = true;
attrs.setNamedItemNS(attr);
}
else {
attrs.setNamedItem(attr);
}
attrIndex = ownerDocument.getPrevSibling(attrIndex);
} while (attrIndex != -1);
}
// set mutation events flag back to its original value
ownerDocument.mutationEvents = orig;
} // synchronizeData()
/**
* Synchronizes the node's children with the internal structure.
* Fluffing the children at once solves a lot of work to keep
* the two structures in sync. The problem gets worse when
* editing the tree -- this makes it a lot easier.
*/
protected final void synchronizeChildren() {
DeferredDocumentImpl ownerDocument =
(DeferredDocumentImpl) ownerDocument();
ownerDocument.synchronizeChildren(this, fNodeIndex);
} // synchronizeChildren()
} // class DeferredElementImpl
|
