| 1 |  |  | 
| 2 |  |  | 
| 3 |  |  | 
| 4 |  |  | 
| 5 |  |  | 
| 6 |  |  | 
| 7 |  |  | 
| 8 |  | package org.dom4j.tree; | 
| 9 |  |  | 
| 10 |  | import java.util.ArrayList; | 
| 11 |  | import java.util.Iterator; | 
| 12 |  | import java.util.List; | 
| 13 |  |  | 
| 14 |  | import org.dom4j.Attribute; | 
| 15 |  | import org.dom4j.Branch; | 
| 16 |  | import org.dom4j.Document; | 
| 17 |  | import org.dom4j.DocumentFactory; | 
| 18 |  | import org.dom4j.Element; | 
| 19 |  | import org.dom4j.IllegalAddException; | 
| 20 |  | import org.dom4j.Namespace; | 
| 21 |  | import org.dom4j.Node; | 
| 22 |  | import org.dom4j.ProcessingInstruction; | 
| 23 |  | import org.dom4j.QName; | 
| 24 |  |  | 
| 25 |  |  | 
| 26 |  |  | 
| 27 |  |  | 
| 28 |  |  | 
| 29 |  |  | 
| 30 |  |  | 
| 31 |  |  | 
| 32 |  |  | 
| 33 |  |  | 
| 34 |  | public class DefaultElement extends AbstractElement { | 
| 35 |  |  | 
| 36 |  | private static final transient DocumentFactory DOCUMENT_FACTORY = | 
| 37 |  | DocumentFactory.getInstance(); | 
| 38 |  |  | 
| 39 |  |  | 
| 40 |  | private QName qname; | 
| 41 |  |  | 
| 42 |  |  | 
| 43 |  |  | 
| 44 |  |  | 
| 45 |  |  | 
| 46 |  |  | 
| 47 |  |  | 
| 48 |  | private Branch parentBranch; | 
| 49 |  |  | 
| 50 |  |  | 
| 51 |  |  | 
| 52 |  |  | 
| 53 |  |  | 
| 54 |  |  | 
| 55 |  | private Object content; | 
| 56 |  |  | 
| 57 |  |  | 
| 58 |  | private Object attributes; | 
| 59 |  |  | 
| 60 | 1 | public DefaultElement(String name) { | 
| 61 | 1 | this.qname = DOCUMENT_FACTORY.createQName(name); | 
| 62 |  | } | 
| 63 |  |  | 
| 64 | 96007 | public DefaultElement(QName qname) { | 
| 65 | 96007 | this.qname = qname; | 
| 66 |  | } | 
| 67 |  |  | 
| 68 | 0 | public DefaultElement(QName qname, int attributeCount) { | 
| 69 | 0 | this.qname = qname; | 
| 70 |  |  | 
| 71 | 0 | if (attributeCount > 1) { | 
| 72 | 0 | this.attributes = new ArrayList(attributeCount); | 
| 73 |  | } | 
| 74 |  | } | 
| 75 |  |  | 
| 76 | 0 | public DefaultElement(String name, Namespace namespace) { | 
| 77 | 0 | this.qname = DOCUMENT_FACTORY.createQName(name, namespace); | 
| 78 |  | } | 
| 79 |  |  | 
| 80 | 131539 | public Element getParent() { | 
| 81 | 131539 | Element result = null; | 
| 82 |  |  | 
| 83 | 131539 | if (parentBranch instanceof Element) { | 
| 84 | 35288 | result = (Element) parentBranch; | 
| 85 |  | } | 
| 86 |  |  | 
| 87 | 131539 | return result; | 
| 88 |  | } | 
| 89 |  |  | 
| 90 | 94507 | public void setParent(Element parent) { | 
| 91 | 94507 | if (parentBranch instanceof Element || (parent != null)) { | 
| 92 | 92978 | parentBranch = parent; | 
| 93 |  | } | 
| 94 |  | } | 
| 95 |  |  | 
| 96 | 13010 | public Document getDocument() { | 
| 97 | 13010 | if (parentBranch instanceof Document) { | 
| 98 | 6597 | return (Document) parentBranch; | 
| 99 | 6413 | } else if (parentBranch instanceof Element) { | 
| 100 | 117 | Element parent = (Element) parentBranch; | 
| 101 |  |  | 
| 102 | 117 | return parent.getDocument(); | 
| 103 |  | } | 
| 104 |  |  | 
| 105 | 6296 | return null; | 
| 106 |  | } | 
| 107 |  |  | 
| 108 | 15752 | public void setDocument(Document document) { | 
| 109 | 15752 | if (parentBranch instanceof Document || (document != null)) { | 
| 110 | 12600 | parentBranch = document; | 
| 111 |  | } | 
| 112 |  | } | 
| 113 |  |  | 
| 114 | 10 | public boolean supportsParent() { | 
| 115 | 10 | return true; | 
| 116 |  | } | 
| 117 |  |  | 
| 118 | 619575 | public QName getQName() { | 
| 119 | 619575 | return qname; | 
| 120 |  | } | 
| 121 |  |  | 
| 122 | 1502 | public void setQName(QName name) { | 
| 123 | 1502 | this.qname = name; | 
| 124 |  | } | 
| 125 |  |  | 
| 126 | 183 | public String getText() { | 
| 127 | 183 | final Object contentShadow = content; | 
| 128 |  |  | 
| 129 | 183 | if (contentShadow instanceof List) { | 
| 130 | 80 | return super.getText(); | 
| 131 |  | } else { | 
| 132 | 103 | if (contentShadow != null) { | 
| 133 | 93 | return getContentAsText(contentShadow); | 
| 134 |  | } else { | 
| 135 | 10 | return ""; | 
| 136 |  | } | 
| 137 |  | } | 
| 138 |  | } | 
| 139 |  |  | 
| 140 | 8 | public String getStringValue() { | 
| 141 | 8 | final Object contentShadow = content; | 
| 142 |  |  | 
| 143 | 8 | if (contentShadow instanceof List) { | 
| 144 | 6 | List list = (List) contentShadow; | 
| 145 |  |  | 
| 146 | 6 | int size = list.size(); | 
| 147 |  |  | 
| 148 | 6 | if (size > 0) { | 
| 149 | 6 | if (size == 1) { | 
| 150 |  |  | 
| 151 | 4 | return getContentAsStringValue(list.get(0)); | 
| 152 |  | } else { | 
| 153 | 2 | StringBuffer buffer = new StringBuffer(); | 
| 154 |  |  | 
| 155 | 2 | for (int i = 0; i < size; i++) { | 
| 156 | 9 | Object node = list.get(i); | 
| 157 |  |  | 
| 158 | 9 | String string = getContentAsStringValue(node); | 
| 159 |  |  | 
| 160 | 9 | if (string.length() > 0) { | 
| 161 | 7 | if (USE_STRINGVALUE_SEPARATOR) { | 
| 162 | 0 | if (buffer.length() > 0) { | 
| 163 | 0 | buffer.append(' '); | 
| 164 |  | } | 
| 165 |  | } | 
| 166 |  |  | 
| 167 | 7 | buffer.append(string); | 
| 168 |  | } | 
| 169 |  | } | 
| 170 |  |  | 
| 171 | 2 | return buffer.toString(); | 
| 172 |  | } | 
| 173 |  | } | 
| 174 |  | } else { | 
| 175 | 2 | if (contentShadow != null) { | 
| 176 | 0 | return getContentAsStringValue(contentShadow); | 
| 177 |  | } | 
| 178 |  | } | 
| 179 |  |  | 
| 180 | 2 | return ""; | 
| 181 |  | } | 
| 182 |  |  | 
| 183 | 129 | public Object clone() { | 
| 184 | 129 | DefaultElement answer = (DefaultElement) super.clone(); | 
| 185 |  |  | 
| 186 | 129 | if (answer != this) { | 
| 187 | 129 | answer.content = null; | 
| 188 |  |  | 
| 189 | 129 | answer.attributes = null; | 
| 190 |  |  | 
| 191 | 129 | answer.appendAttributes(this); | 
| 192 |  |  | 
| 193 | 129 | answer.appendContent(this); | 
| 194 |  | } | 
| 195 |  |  | 
| 196 | 129 | return answer; | 
| 197 |  | } | 
| 198 |  |  | 
| 199 | 8764 | public Namespace getNamespaceForPrefix(String prefix) { | 
| 200 | 8764 | if (prefix == null) { | 
| 201 | 9 | prefix = ""; | 
| 202 |  | } | 
| 203 |  |  | 
| 204 | 8764 | if (prefix.equals(getNamespacePrefix())) { | 
| 205 | 3721 | return getNamespace(); | 
| 206 | 5043 | } else if (prefix.equals("xml")) { | 
| 207 | 0 | return Namespace.XML_NAMESPACE; | 
| 208 |  | } else { | 
| 209 | 5043 | final Object contentShadow = content; | 
| 210 |  |  | 
| 211 | 5043 | if (contentShadow instanceof List) { | 
| 212 | 5040 | List list = (List) contentShadow; | 
| 213 |  |  | 
| 214 | 5040 | int size = list.size(); | 
| 215 |  |  | 
| 216 | 5040 | for (int i = 0; i < size; i++) { | 
| 217 | 5100 | Object object = list.get(i); | 
| 218 |  |  | 
| 219 | 5100 | if (object instanceof Namespace) { | 
| 220 | 5055 | Namespace namespace = (Namespace) object; | 
| 221 |  |  | 
| 222 | 5055 | if (prefix.equals(namespace.getPrefix())) { | 
| 223 | 5023 | return namespace; | 
| 224 |  | } | 
| 225 |  | } | 
| 226 |  | } | 
| 227 | 3 | } else if (contentShadow instanceof Namespace) { | 
| 228 | 0 | Namespace namespace = (Namespace) contentShadow; | 
| 229 |  |  | 
| 230 | 0 | if (prefix.equals(namespace.getPrefix())) { | 
| 231 | 0 | return namespace; | 
| 232 |  | } | 
| 233 |  | } | 
| 234 |  | } | 
| 235 |  |  | 
| 236 | 20 | Element parent = getParent(); | 
| 237 |  |  | 
| 238 | 20 | if (parent != null) { | 
| 239 | 19 | Namespace answer = parent.getNamespaceForPrefix(prefix); | 
| 240 |  |  | 
| 241 | 19 | if (answer != null) { | 
| 242 | 19 | return answer; | 
| 243 |  | } | 
| 244 |  | } | 
| 245 |  |  | 
| 246 | 1 | if ((prefix == null) || (prefix.length() <= 0)) { | 
| 247 | 0 | return Namespace.NO_NAMESPACE; | 
| 248 |  | } | 
| 249 |  |  | 
| 250 | 1 | return null; | 
| 251 |  | } | 
| 252 |  |  | 
| 253 | 9 | public Namespace getNamespaceForURI(String uri) { | 
| 254 | 9 | if ((uri == null) || (uri.length() <= 0)) { | 
| 255 | 0 | return Namespace.NO_NAMESPACE; | 
| 256 | 9 | } else if (uri.equals(getNamespaceURI())) { | 
| 257 | 0 | return getNamespace(); | 
| 258 |  | } else { | 
| 259 | 9 | final Object contentShadow = content; | 
| 260 |  |  | 
| 261 | 9 | if (contentShadow instanceof List) { | 
| 262 | 9 | List list = (List) contentShadow; | 
| 263 |  |  | 
| 264 | 9 | int size = list.size(); | 
| 265 |  |  | 
| 266 | 9 | for (int i = 0; i < size; i++) { | 
| 267 | 21 | Object object = list.get(i); | 
| 268 |  |  | 
| 269 | 21 | if (object instanceof Namespace) { | 
| 270 | 12 | Namespace namespace = (Namespace) object; | 
| 271 |  |  | 
| 272 | 12 | if (uri.equals(namespace.getURI())) { | 
| 273 | 6 | return namespace; | 
| 274 |  | } | 
| 275 |  | } | 
| 276 |  | } | 
| 277 | 0 | } else if (contentShadow instanceof Namespace) { | 
| 278 | 0 | Namespace namespace = (Namespace) contentShadow; | 
| 279 |  |  | 
| 280 | 0 | if (uri.equals(namespace.getURI())) { | 
| 281 | 0 | return namespace; | 
| 282 |  | } | 
| 283 |  | } | 
| 284 |  |  | 
| 285 | 3 | Element parent = getParent(); | 
| 286 |  |  | 
| 287 | 3 | if (parent != null) { | 
| 288 | 3 | return parent.getNamespaceForURI(uri); | 
| 289 |  | } | 
| 290 |  |  | 
| 291 | 0 | return null; | 
| 292 |  | } | 
| 293 |  | } | 
| 294 |  |  | 
| 295 | 9903 | public List declaredNamespaces() { | 
| 296 | 9903 | BackedList answer = createResultList(); | 
| 297 |  |  | 
| 298 |  |  | 
| 299 |  |  | 
| 300 |  |  | 
| 301 |  |  | 
| 302 |  |  | 
| 303 | 9903 | final Object contentShadow = content; | 
| 304 |  |  | 
| 305 | 9903 | if (contentShadow instanceof List) { | 
| 306 | 9903 | List list = (List) contentShadow; | 
| 307 |  |  | 
| 308 | 9903 | int size = list.size(); | 
| 309 |  |  | 
| 310 | 9903 | for (int i = 0; i < size; i++) { | 
| 311 | 31929 | Object object = list.get(i); | 
| 312 |  |  | 
| 313 | 31929 | if (object instanceof Namespace) { | 
| 314 | 821 | answer.addLocal(object); | 
| 315 |  | } | 
| 316 |  | } | 
| 317 |  | } else { | 
| 318 | 0 | if (contentShadow instanceof Namespace) { | 
| 319 | 0 | answer.addLocal(contentShadow); | 
| 320 |  | } | 
| 321 |  | } | 
| 322 |  |  | 
| 323 | 9903 | return answer; | 
| 324 |  | } | 
| 325 |  |  | 
| 326 | 15 | public List additionalNamespaces() { | 
| 327 | 15 | final Object contentShadow = content; | 
| 328 |  |  | 
| 329 | 15 | if (contentShadow instanceof List) { | 
| 330 | 13 | List list = (List) contentShadow; | 
| 331 |  |  | 
| 332 | 13 | int size = list.size(); | 
| 333 |  |  | 
| 334 | 13 | BackedList answer = createResultList(); | 
| 335 |  |  | 
| 336 | 13 | for (int i = 0; i < size; i++) { | 
| 337 | 89 | Object object = list.get(i); | 
| 338 |  |  | 
| 339 | 89 | if (object instanceof Namespace) { | 
| 340 | 25 | Namespace namespace = (Namespace) object; | 
| 341 |  |  | 
| 342 | 25 | if (!namespace.equals(getNamespace())) { | 
| 343 | 13 | answer.addLocal(namespace); | 
| 344 |  | } | 
| 345 |  | } | 
| 346 |  | } | 
| 347 |  |  | 
| 348 | 13 | return answer; | 
| 349 |  | } else { | 
| 350 | 2 | if (contentShadow instanceof Namespace) { | 
| 351 | 1 | Namespace namespace = (Namespace) contentShadow; | 
| 352 |  |  | 
| 353 | 1 | if (namespace.equals(getNamespace())) { | 
| 354 | 1 | return createEmptyList(); | 
| 355 |  | } | 
| 356 |  |  | 
| 357 | 0 | return createSingleResultList(namespace); | 
| 358 |  | } else { | 
| 359 | 1 | return createEmptyList(); | 
| 360 |  | } | 
| 361 |  | } | 
| 362 |  | } | 
| 363 |  |  | 
| 364 | 0 | public List additionalNamespaces(String defaultNamespaceURI) { | 
| 365 | 0 | final Object contentShadow = content; | 
| 366 |  |  | 
| 367 | 0 | if (contentShadow instanceof List) { | 
| 368 | 0 | List list = (List) contentShadow; | 
| 369 |  |  | 
| 370 | 0 | BackedList answer = createResultList(); | 
| 371 |  |  | 
| 372 | 0 | int size = list.size(); | 
| 373 |  |  | 
| 374 | 0 | for (int i = 0; i < size; i++) { | 
| 375 | 0 | Object object = list.get(i); | 
| 376 |  |  | 
| 377 | 0 | if (object instanceof Namespace) { | 
| 378 | 0 | Namespace namespace = (Namespace) object; | 
| 379 |  |  | 
| 380 | 0 | if (!defaultNamespaceURI.equals(namespace.getURI())) { | 
| 381 | 0 | answer.addLocal(namespace); | 
| 382 |  | } | 
| 383 |  | } | 
| 384 |  | } | 
| 385 |  |  | 
| 386 | 0 | return answer; | 
| 387 |  | } else { | 
| 388 | 0 | if (contentShadow instanceof Namespace) { | 
| 389 | 0 | Namespace namespace = (Namespace) contentShadow; | 
| 390 |  |  | 
| 391 | 0 | if (!defaultNamespaceURI.equals(namespace.getURI())) { | 
| 392 | 0 | return createSingleResultList(namespace); | 
| 393 |  | } | 
| 394 |  | } | 
| 395 |  | } | 
| 396 |  |  | 
| 397 | 0 | return createEmptyList(); | 
| 398 |  | } | 
| 399 |  |  | 
| 400 |  |  | 
| 401 | 0 | public List processingInstructions() { | 
| 402 | 0 | final Object contentShadow = content; | 
| 403 |  |  | 
| 404 | 0 | if (contentShadow instanceof List) { | 
| 405 | 0 | List list = (List) contentShadow; | 
| 406 |  |  | 
| 407 | 0 | BackedList answer = createResultList(); | 
| 408 |  |  | 
| 409 | 0 | int size = list.size(); | 
| 410 |  |  | 
| 411 | 0 | for (int i = 0; i < size; i++) { | 
| 412 | 0 | Object object = list.get(i); | 
| 413 |  |  | 
| 414 | 0 | if (object instanceof ProcessingInstruction) { | 
| 415 | 0 | answer.addLocal(object); | 
| 416 |  | } | 
| 417 |  | } | 
| 418 |  |  | 
| 419 | 0 | return answer; | 
| 420 |  | } else { | 
| 421 | 0 | if (contentShadow instanceof ProcessingInstruction) { | 
| 422 | 0 | return createSingleResultList(contentShadow); | 
| 423 |  | } | 
| 424 |  |  | 
| 425 | 0 | return createEmptyList(); | 
| 426 |  | } | 
| 427 |  | } | 
| 428 |  |  | 
| 429 | 0 | public List processingInstructions(String target) { | 
| 430 | 0 | final Object shadow = content; | 
| 431 |  |  | 
| 432 | 0 | if (shadow instanceof List) { | 
| 433 | 0 | List list = (List) shadow; | 
| 434 |  |  | 
| 435 | 0 | BackedList answer = createResultList(); | 
| 436 |  |  | 
| 437 | 0 | int size = list.size(); | 
| 438 |  |  | 
| 439 | 0 | for (int i = 0; i < size; i++) { | 
| 440 | 0 | Object object = list.get(i); | 
| 441 |  |  | 
| 442 | 0 | if (object instanceof ProcessingInstruction) { | 
| 443 | 0 | ProcessingInstruction pi = (ProcessingInstruction) object; | 
| 444 |  |  | 
| 445 | 0 | if (target.equals(pi.getName())) { | 
| 446 | 0 | answer.addLocal(pi); | 
| 447 |  | } | 
| 448 |  | } | 
| 449 |  | } | 
| 450 |  |  | 
| 451 | 0 | return answer; | 
| 452 |  | } else { | 
| 453 | 0 | if (shadow instanceof ProcessingInstruction) { | 
| 454 | 0 | ProcessingInstruction pi = (ProcessingInstruction) shadow; | 
| 455 |  |  | 
| 456 | 0 | if (target.equals(pi.getName())) { | 
| 457 | 0 | return createSingleResultList(pi); | 
| 458 |  | } | 
| 459 |  | } | 
| 460 |  |  | 
| 461 | 0 | return createEmptyList(); | 
| 462 |  | } | 
| 463 |  | } | 
| 464 |  |  | 
| 465 | 0 | public ProcessingInstruction processingInstruction(String target) { | 
| 466 | 0 | final Object shadow = content; | 
| 467 |  |  | 
| 468 | 0 | if (shadow instanceof List) { | 
| 469 | 0 | List list = (List) shadow; | 
| 470 |  |  | 
| 471 | 0 | int size = list.size(); | 
| 472 |  |  | 
| 473 | 0 | for (int i = 0; i < size; i++) { | 
| 474 | 0 | Object object = list.get(i); | 
| 475 |  |  | 
| 476 | 0 | if (object instanceof ProcessingInstruction) { | 
| 477 | 0 | ProcessingInstruction pi = (ProcessingInstruction) object; | 
| 478 |  |  | 
| 479 | 0 | if (target.equals(pi.getName())) { | 
| 480 | 0 | return pi; | 
| 481 |  | } | 
| 482 |  | } | 
| 483 |  | } | 
| 484 |  | } else { | 
| 485 | 0 | if (shadow instanceof ProcessingInstruction) { | 
| 486 | 0 | ProcessingInstruction pi = (ProcessingInstruction) shadow; | 
| 487 |  |  | 
| 488 | 0 | if (target.equals(pi.getName())) { | 
| 489 | 0 | return pi; | 
| 490 |  | } | 
| 491 |  | } | 
| 492 |  | } | 
| 493 |  |  | 
| 494 | 0 | return null; | 
| 495 |  | } | 
| 496 |  |  | 
| 497 | 0 | public boolean removeProcessingInstruction(String target) { | 
| 498 | 0 | final Object shadow = content; | 
| 499 |  |  | 
| 500 | 0 | if (shadow instanceof List) { | 
| 501 | 0 | List list = (List) shadow; | 
| 502 |  |  | 
| 503 | 0 | for (Iterator iter = list.iterator(); iter.hasNext();) { | 
| 504 | 0 | Object object = iter.next(); | 
| 505 |  |  | 
| 506 | 0 | if (object instanceof ProcessingInstruction) { | 
| 507 | 0 | ProcessingInstruction pi = (ProcessingInstruction) object; | 
| 508 |  |  | 
| 509 | 0 | if (target.equals(pi.getName())) { | 
| 510 | 0 | iter.remove(); | 
| 511 |  |  | 
| 512 | 0 | return true; | 
| 513 |  | } | 
| 514 |  | } | 
| 515 |  | } | 
| 516 |  | } else { | 
| 517 | 0 | if (shadow instanceof ProcessingInstruction) { | 
| 518 | 0 | ProcessingInstruction pi = (ProcessingInstruction) shadow; | 
| 519 |  |  | 
| 520 | 0 | if (target.equals(pi.getName())) { | 
| 521 | 0 | this.content = null; | 
| 522 |  |  | 
| 523 | 0 | return true; | 
| 524 |  | } | 
| 525 |  | } | 
| 526 |  | } | 
| 527 |  |  | 
| 528 | 0 | return false; | 
| 529 |  | } | 
| 530 |  |  | 
| 531 | 125 | public Element element(String name) { | 
| 532 | 125 | final Object contentShadow = content; | 
| 533 |  |  | 
| 534 | 125 | if (contentShadow instanceof List) { | 
| 535 | 30 | List list = (List) contentShadow; | 
| 536 |  |  | 
| 537 | 30 | int size = list.size(); | 
| 538 |  |  | 
| 539 | 82 | for (int i = 0; i < size; i++) { | 
| 540 | 82 | Object object = list.get(i); | 
| 541 |  |  | 
| 542 | 82 | if (object instanceof Element) { | 
| 543 | 36 | Element element = (Element) object; | 
| 544 |  |  | 
| 545 | 36 | if (name.equals(element.getName())) { | 
| 546 | 30 | return element; | 
| 547 |  | } | 
| 548 |  | } | 
| 549 |  | } | 
| 550 |  | } else { | 
| 551 | 95 | if (contentShadow instanceof Element) { | 
| 552 | 6 | Element element = (Element) contentShadow; | 
| 553 |  |  | 
| 554 | 6 | if (name.equals(element.getName())) { | 
| 555 | 6 | return element; | 
| 556 |  | } | 
| 557 |  | } | 
| 558 |  | } | 
| 559 |  |  | 
| 560 | 89 | return null; | 
| 561 |  | } | 
| 562 |  |  | 
| 563 | 2965 | public Element element(QName qName) { | 
| 564 | 2965 | final Object contentShadow = content; | 
| 565 |  |  | 
| 566 | 2965 | if (contentShadow instanceof List) { | 
| 567 | 2705 | List list = (List) contentShadow; | 
| 568 |  |  | 
| 569 | 2705 | int size = list.size(); | 
| 570 |  |  | 
| 571 | 2705 | for (int i = 0; i < size; i++) { | 
| 572 | 21262 | Object object = list.get(i); | 
| 573 |  |  | 
| 574 | 21262 | if (object instanceof Element) { | 
| 575 | 11680 | Element element = (Element) object; | 
| 576 |  |  | 
| 577 | 11680 | if (qName.equals(element.getQName())) { | 
| 578 | 2290 | return element; | 
| 579 |  | } | 
| 580 |  | } | 
| 581 |  | } | 
| 582 |  | } else { | 
| 583 | 260 | if (contentShadow instanceof Element) { | 
| 584 | 1 | Element element = (Element) contentShadow; | 
| 585 |  |  | 
| 586 | 1 | if (qName.equals(element.getQName())) { | 
| 587 | 1 | return element; | 
| 588 |  | } | 
| 589 |  | } | 
| 590 |  | } | 
| 591 |  |  | 
| 592 | 674 | return null; | 
| 593 |  | } | 
| 594 |  |  | 
| 595 | 0 | public Element element(String name, Namespace namespace) { | 
| 596 | 0 | return element(getDocumentFactory().createQName(name, namespace)); | 
| 597 |  | } | 
| 598 |  |  | 
| 599 | 2 | public void setContent(List content) { | 
| 600 | 2 | contentRemoved(); | 
| 601 |  |  | 
| 602 | 2 | if (content instanceof ContentListFacade) { | 
| 603 | 2 | content = ((ContentListFacade) content).getBackingList(); | 
| 604 |  | } | 
| 605 |  |  | 
| 606 | 2 | if (content == null) { | 
| 607 | 0 | this.content = null; | 
| 608 |  | } else { | 
| 609 | 2 | int size = content.size(); | 
| 610 |  |  | 
| 611 | 2 | List newContent = createContentList(size); | 
| 612 |  |  | 
| 613 | 2 | for (int i = 0; i < size; i++) { | 
| 614 | 7 | Object object = content.get(i); | 
| 615 |  |  | 
| 616 | 7 | if (object instanceof Node) { | 
| 617 | 7 | Node node = (Node) object; | 
| 618 | 7 | Element parent = node.getParent(); | 
| 619 |  |  | 
| 620 | 7 | if ((parent != null) && (parent != this)) { | 
| 621 | 2 | node = (Node) node.clone(); | 
| 622 |  | } | 
| 623 |  |  | 
| 624 | 7 | newContent.add(node); | 
| 625 | 7 | childAdded(node); | 
| 626 | 0 | } else if (object != null) { | 
| 627 | 0 | String text = object.toString(); | 
| 628 | 0 | Node node = getDocumentFactory().createText(text); | 
| 629 | 0 | newContent.add(node); | 
| 630 | 0 | childAdded(node); | 
| 631 |  | } | 
| 632 |  | } | 
| 633 |  |  | 
| 634 | 2 | this.content = newContent; | 
| 635 |  | } | 
| 636 |  | } | 
| 637 |  |  | 
| 638 | 0 | public void clearContent() { | 
| 639 | 0 | if (content != null) { | 
| 640 | 0 | contentRemoved(); | 
| 641 |  |  | 
| 642 | 0 | content = null; | 
| 643 |  | } | 
| 644 |  | } | 
| 645 |  |  | 
| 646 | 355275 | public Node node(int index) { | 
| 647 | 355275 | if (index >= 0) { | 
| 648 | 355275 | final Object contentShadow = content; | 
| 649 | 355275 | Object node; | 
| 650 |  |  | 
| 651 | 355275 | if (contentShadow instanceof List) { | 
| 652 | 333677 | List list = (List) contentShadow; | 
| 653 |  |  | 
| 654 | 333677 | if (index >= list.size()) { | 
| 655 | 0 | return null; | 
| 656 |  | } | 
| 657 |  |  | 
| 658 | 333677 | node = list.get(index); | 
| 659 |  | } else { | 
| 660 | 21598 | node = (index == 0) ? contentShadow : null; | 
| 661 |  | } | 
| 662 |  |  | 
| 663 | 355275 | if (node != null) { | 
| 664 | 355275 | if (node instanceof Node) { | 
| 665 | 355275 | return (Node) node; | 
| 666 |  | } else { | 
| 667 | 0 | return new DefaultText(node.toString()); | 
| 668 |  | } | 
| 669 |  | } | 
| 670 |  | } | 
| 671 |  |  | 
| 672 | 0 | return null; | 
| 673 |  | } | 
| 674 |  |  | 
| 675 | 0 | public int indexOf(Node node) { | 
| 676 | 0 | final Object contentShadow = content; | 
| 677 |  |  | 
| 678 | 0 | if (contentShadow instanceof List) { | 
| 679 | 0 | List list = (List) contentShadow; | 
| 680 |  |  | 
| 681 | 0 | return list.indexOf(node); | 
| 682 |  | } else { | 
| 683 | 0 | if ((contentShadow != null) && contentShadow.equals(node)) { | 
| 684 | 0 | return 0; | 
| 685 |  | } else { | 
| 686 | 0 | return -1; | 
| 687 |  | } | 
| 688 |  | } | 
| 689 |  | } | 
| 690 |  |  | 
| 691 | 125606 | public int nodeCount() { | 
| 692 | 125606 | final Object contentShadow = content; | 
| 693 |  |  | 
| 694 | 125606 | if (contentShadow instanceof List) { | 
| 695 | 103856 | List list = (List) contentShadow; | 
| 696 |  |  | 
| 697 | 103856 | return list.size(); | 
| 698 |  | } else { | 
| 699 | 21750 | return (contentShadow != null) ? 1 : 0; | 
| 700 |  | } | 
| 701 |  | } | 
| 702 |  |  | 
| 703 | 94704 | public Iterator nodeIterator() { | 
| 704 | 94704 | final Object contentShadow = content; | 
| 705 |  |  | 
| 706 | 94704 | if (contentShadow instanceof List) { | 
| 707 | 33208 | List list = (List) contentShadow; | 
| 708 |  |  | 
| 709 | 33208 | return list.iterator(); | 
| 710 |  | } else { | 
| 711 | 61496 | if (contentShadow != null) { | 
| 712 | 61120 | return createSingleIterator(contentShadow); | 
| 713 |  | } else { | 
| 714 | 376 | return EMPTY_ITERATOR; | 
| 715 |  | } | 
| 716 |  | } | 
| 717 |  | } | 
| 718 |  |  | 
| 719 | 109 | public List attributes() { | 
| 720 | 109 | return new ContentListFacade(this, attributeList()); | 
| 721 |  | } | 
| 722 |  |  | 
| 723 | 0 | public void setAttributes(List attributes) { | 
| 724 | 0 | if (attributes instanceof ContentListFacade) { | 
| 725 | 0 | attributes = ((ContentListFacade) attributes).getBackingList(); | 
| 726 |  | } | 
| 727 |  |  | 
| 728 | 0 | this.attributes = attributes; | 
| 729 |  | } | 
| 730 |  |  | 
| 731 | 5028 | public Iterator attributeIterator() { | 
| 732 | 5028 | final Object attributesShadow = this.attributes; | 
| 733 |  |  | 
| 734 | 5028 | if (attributesShadow instanceof List) { | 
| 735 | 2596 | List list = (List) attributesShadow; | 
| 736 |  |  | 
| 737 | 2596 | return list.iterator(); | 
| 738 | 2432 | } else if (attributesShadow != null) { | 
| 739 | 998 | return createSingleIterator(attributesShadow); | 
| 740 |  | } else { | 
| 741 | 1434 | return EMPTY_ITERATOR; | 
| 742 |  | } | 
| 743 |  | } | 
| 744 |  |  | 
| 745 | 24324 | public Attribute attribute(int index) { | 
| 746 | 24324 | final Object attributesShadow = this.attributes; | 
| 747 |  |  | 
| 748 | 24324 | if (attributesShadow instanceof List) { | 
| 749 | 22129 | List list = (List) attributesShadow; | 
| 750 |  |  | 
| 751 | 22129 | return (Attribute) list.get(index); | 
| 752 | 2195 | } else if ((attributesShadow != null) && (index == 0)) { | 
| 753 | 2195 | return (Attribute) attributesShadow; | 
| 754 |  | } else { | 
| 755 | 0 | return null; | 
| 756 |  | } | 
| 757 |  | } | 
| 758 |  |  | 
| 759 | 110652 | public int attributeCount() { | 
| 760 | 110652 | final Object attributesShadow = this.attributes; | 
| 761 |  |  | 
| 762 | 110652 | if (attributesShadow instanceof List) { | 
| 763 | 65626 | List list = (List) attributesShadow; | 
| 764 |  |  | 
| 765 | 65626 | return list.size(); | 
| 766 |  | } else { | 
| 767 | 45026 | return (attributesShadow != null) ? 1 : 0; | 
| 768 |  | } | 
| 769 |  | } | 
| 770 |  |  | 
| 771 | 3958 | public Attribute attribute(String name) { | 
| 772 | 3958 | final Object attributesShadow = this.attributes; | 
| 773 |  |  | 
| 774 | 3958 | if (attributesShadow instanceof List) { | 
| 775 | 1292 | List list = (List) attributesShadow; | 
| 776 |  |  | 
| 777 | 1292 | int size = list.size(); | 
| 778 |  |  | 
| 779 | 1292 | for (int i = 0; i < size; i++) { | 
| 780 | 2294 | Attribute attribute = (Attribute) list.get(i); | 
| 781 |  |  | 
| 782 | 2294 | if (name.equals(attribute.getName())) { | 
| 783 | 974 | return attribute; | 
| 784 |  | } | 
| 785 |  | } | 
| 786 | 2666 | } else if (attributesShadow != null) { | 
| 787 | 1729 | Attribute attribute = (Attribute) attributesShadow; | 
| 788 |  |  | 
| 789 | 1729 | if (name.equals(attribute.getName())) { | 
| 790 | 575 | return attribute; | 
| 791 |  | } | 
| 792 |  | } | 
| 793 |  |  | 
| 794 | 2409 | return null; | 
| 795 |  | } | 
| 796 |  |  | 
| 797 | 20997 | public Attribute attribute(QName qName) { | 
| 798 | 20997 | final Object attributesShadow = this.attributes; | 
| 799 |  |  | 
| 800 | 20997 | if (attributesShadow instanceof List) { | 
| 801 | 17846 | List list = (List) attributesShadow; | 
| 802 |  |  | 
| 803 | 17846 | int size = list.size(); | 
| 804 |  |  | 
| 805 | 17846 | for (int i = 0; i < size; i++) { | 
| 806 | 20862 | Attribute attribute = (Attribute) list.get(i); | 
| 807 |  |  | 
| 808 | 20862 | if (qName.equals(attribute.getQName())) { | 
| 809 | 17696 | return attribute; | 
| 810 |  | } | 
| 811 |  | } | 
| 812 | 3151 | } else if (attributesShadow != null) { | 
| 813 | 618 | Attribute attribute = (Attribute) attributesShadow; | 
| 814 |  |  | 
| 815 | 618 | if (qName.equals(attribute.getQName())) { | 
| 816 | 231 | return attribute; | 
| 817 |  | } | 
| 818 |  | } | 
| 819 |  |  | 
| 820 | 3070 | return null; | 
| 821 |  | } | 
| 822 |  |  | 
| 823 | 0 | public Attribute attribute(String name, Namespace namespace) { | 
| 824 | 0 | return attribute(getDocumentFactory().createQName(name, namespace)); | 
| 825 |  | } | 
| 826 |  |  | 
| 827 | 10743 | public void add(Attribute attribute) { | 
| 828 | 10743 | if (attribute.getParent() != null) { | 
| 829 | 0 | String message = "The Attribute already has an existing parent \"" | 
| 830 |  | + attribute.getParent().getQualifiedName() + "\""; | 
| 831 |  |  | 
| 832 | 0 | throw new IllegalAddException(this, attribute, message); | 
| 833 |  | } | 
| 834 |  |  | 
| 835 | 10743 | if (attribute.getValue() == null) { | 
| 836 |  |  | 
| 837 |  |  | 
| 838 |  |  | 
| 839 | 2 | Attribute oldAttribute = attribute(attribute.getQName()); | 
| 840 |  |  | 
| 841 | 2 | if (oldAttribute != null) { | 
| 842 | 1 | remove(oldAttribute); | 
| 843 |  | } | 
| 844 |  | } else { | 
| 845 | 10741 | if (attributes == null) { | 
| 846 | 9433 | attributes = attribute; | 
| 847 |  | } else { | 
| 848 | 1308 | attributeList().add(attribute); | 
| 849 |  | } | 
| 850 |  |  | 
| 851 | 10741 | childAdded(attribute); | 
| 852 |  | } | 
| 853 |  | } | 
| 854 |  |  | 
| 855 | 6 | public boolean remove(Attribute attribute) { | 
| 856 | 6 | boolean answer = false; | 
| 857 | 6 | final Object attributesShadow = this.attributes; | 
| 858 |  |  | 
| 859 | 6 | if (attributesShadow instanceof List) { | 
| 860 | 3 | List list = (List) attributesShadow; | 
| 861 |  |  | 
| 862 | 3 | answer = list.remove(attribute); | 
| 863 |  |  | 
| 864 | 3 | if (!answer) { | 
| 865 |  |  | 
| 866 | 0 | Attribute copy = attribute(attribute.getQName()); | 
| 867 |  |  | 
| 868 | 0 | if (copy != null) { | 
| 869 | 0 | list.remove(copy); | 
| 870 |  |  | 
| 871 | 0 | answer = true; | 
| 872 |  | } | 
| 873 |  | } | 
| 874 | 3 | } else if (attributesShadow != null) { | 
| 875 | 3 | if (attribute.equals(attributesShadow)) { | 
| 876 | 3 | this.attributes = null; | 
| 877 |  |  | 
| 878 | 3 | answer = true; | 
| 879 |  | } else { | 
| 880 |  |  | 
| 881 | 0 | Attribute other = (Attribute) attributesShadow; | 
| 882 |  |  | 
| 883 | 0 | if (attribute.getQName().equals(other.getQName())) { | 
| 884 | 0 | attributes = null; | 
| 885 |  |  | 
| 886 | 0 | answer = true; | 
| 887 |  | } | 
| 888 |  | } | 
| 889 |  | } | 
| 890 |  |  | 
| 891 | 6 | if (answer) { | 
| 892 | 6 | childRemoved(attribute); | 
| 893 |  | } | 
| 894 |  |  | 
| 895 | 6 | return answer; | 
| 896 |  | } | 
| 897 |  |  | 
| 898 |  |  | 
| 899 |  |  | 
| 900 | 219990 | protected void addNewNode(Node node) { | 
| 901 | 219990 | final Object contentShadow = content; | 
| 902 |  |  | 
| 903 | 219990 | if (contentShadow == null) { | 
| 904 | 92043 | this.content = node; | 
| 905 |  | } else { | 
| 906 | 127947 | if (contentShadow instanceof List) { | 
| 907 | 103858 | List list = (List) contentShadow; | 
| 908 |  |  | 
| 909 | 103858 | list.add(node); | 
| 910 |  | } else { | 
| 911 | 24089 | List list = createContentList(); | 
| 912 |  |  | 
| 913 | 24089 | list.add(contentShadow); | 
| 914 |  |  | 
| 915 | 24089 | list.add(node); | 
| 916 |  |  | 
| 917 | 24089 | this.content = list; | 
| 918 |  | } | 
| 919 |  | } | 
| 920 |  |  | 
| 921 | 219990 | childAdded(node); | 
| 922 |  | } | 
| 923 |  |  | 
| 924 | 13545 | protected boolean removeNode(Node node) { | 
| 925 | 13545 | boolean answer = false; | 
| 926 | 13545 | final Object contentShadow = content; | 
| 927 |  |  | 
| 928 | 13545 | if (contentShadow != null) { | 
| 929 | 13545 | if (contentShadow == node) { | 
| 930 | 1 | this.content = null; | 
| 931 |  |  | 
| 932 | 1 | answer = true; | 
| 933 | 13544 | } else if (contentShadow instanceof List) { | 
| 934 | 13544 | List list = (List) contentShadow; | 
| 935 |  |  | 
| 936 | 13544 | answer = list.remove(node); | 
| 937 |  | } | 
| 938 |  | } | 
| 939 |  |  | 
| 940 | 13545 | if (answer) { | 
| 941 | 13545 | childRemoved(node); | 
| 942 |  | } | 
| 943 |  |  | 
| 944 | 13545 | return answer; | 
| 945 |  | } | 
| 946 |  |  | 
| 947 | 88171 | protected List contentList() { | 
| 948 | 88171 | final Object contentShadow = content; | 
| 949 |  |  | 
| 950 | 88171 | if (contentShadow instanceof List) { | 
| 951 | 61297 | return (List) contentShadow; | 
| 952 |  | } else { | 
| 953 | 26874 | List list = createContentList(); | 
| 954 |  |  | 
| 955 | 26874 | if (contentShadow != null) { | 
| 956 | 23679 | list.add(contentShadow); | 
| 957 |  | } | 
| 958 |  |  | 
| 959 | 26874 | this.content = list; | 
| 960 |  |  | 
| 961 | 26874 | return list; | 
| 962 |  | } | 
| 963 |  | } | 
| 964 |  |  | 
| 965 | 87124 | protected List attributeList() { | 
| 966 | 87124 | final Object attributesShadow = this.attributes; | 
| 967 |  |  | 
| 968 | 87124 | if (attributesShadow instanceof List) { | 
| 969 | 58366 | return (List) attributesShadow; | 
| 970 | 28758 | } else if (attributesShadow != null) { | 
| 971 | 9093 | List list = createAttributeList(); | 
| 972 |  |  | 
| 973 | 9093 | list.add(attributesShadow); | 
| 974 |  |  | 
| 975 | 9093 | this.attributes = list; | 
| 976 |  |  | 
| 977 | 9093 | return list; | 
| 978 |  | } else { | 
| 979 | 19665 | List list = createAttributeList(); | 
| 980 |  |  | 
| 981 | 19665 | this.attributes = list; | 
| 982 |  |  | 
| 983 | 19665 | return list; | 
| 984 |  | } | 
| 985 |  | } | 
| 986 |  |  | 
| 987 | 1618 | protected List attributeList(int size) { | 
| 988 | 1618 | final Object attributesShadow = this.attributes; | 
| 989 |  |  | 
| 990 | 1618 | if (attributesShadow instanceof List) { | 
| 991 | 0 | return (List) attributesShadow; | 
| 992 | 1618 | } else if (attributesShadow != null) { | 
| 993 | 0 | List list = createAttributeList(size); | 
| 994 |  |  | 
| 995 | 0 | list.add(attributesShadow); | 
| 996 |  |  | 
| 997 | 0 | this.attributes = list; | 
| 998 |  |  | 
| 999 | 0 | return list; | 
| 1000 |  | } else { | 
| 1001 | 1618 | List list = createAttributeList(size); | 
| 1002 |  |  | 
| 1003 | 1618 | this.attributes = list; | 
| 1004 |  |  | 
| 1005 | 1618 | return list; | 
| 1006 |  | } | 
| 1007 |  | } | 
| 1008 |  |  | 
| 1009 | 2 | protected void setAttributeList(List attributeList) { | 
| 1010 | 2 | this.attributes = attributeList; | 
| 1011 |  | } | 
| 1012 |  |  | 
| 1013 | 228999 | protected DocumentFactory getDocumentFactory() { | 
| 1014 | 228999 | DocumentFactory factory = qname.getDocumentFactory(); | 
| 1015 |  |  | 
| 1016 | 228999 | return (factory != null) ? factory : DOCUMENT_FACTORY; | 
| 1017 |  | } | 
| 1018 |  | } | 
| 1019 |  |  | 
| 1020 |  |  | 
| 1021 |  |  | 
| 1022 |  |  | 
| 1023 |  |  | 
| 1024 |  |  | 
| 1025 |  |  | 
| 1026 |  |  | 
| 1027 |  |  | 
| 1028 |  |  | 
| 1029 |  |  | 
| 1030 |  |  | 
| 1031 |  |  | 
| 1032 |  |  | 
| 1033 |  |  | 
| 1034 |  |  | 
| 1035 |  |  | 
| 1036 |  |  | 
| 1037 |  |  | 
| 1038 |  |  | 
| 1039 |  |  | 
| 1040 |  |  | 
| 1041 |  |  | 
| 1042 |  |  | 
| 1043 |  |  | 
| 1044 |  |  | 
| 1045 |  |  | 
| 1046 |  |  | 
| 1047 |  |  | 
| 1048 |  |  | 
| 1049 |  |  | 
| 1050 |  |  | 
| 1051 |  |  | 
| 1052 |  |  | 
| 1053 |  |  | 
| 1054 |  |  | 
| 1055 |  |  |