| 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 |  | import java.util.StringTokenizer; | 
| 14 |  |  | 
| 15 |  | import org.dom4j.Branch; | 
| 16 |  | import org.dom4j.Comment; | 
| 17 |  | import org.dom4j.Element; | 
| 18 |  | import org.dom4j.IllegalAddException; | 
| 19 |  | import org.dom4j.Namespace; | 
| 20 |  | import org.dom4j.Node; | 
| 21 |  | import org.dom4j.ProcessingInstruction; | 
| 22 |  | import org.dom4j.QName; | 
| 23 |  |  | 
| 24 |  |  | 
| 25 |  |  | 
| 26 |  |  | 
| 27 |  |  | 
| 28 |  |  | 
| 29 |  |  | 
| 30 |  |  | 
| 31 |  |  | 
| 32 |  |  | 
| 33 |  | public abstract class AbstractBranch extends AbstractNode implements Branch { | 
| 34 |  | protected static final int DEFAULT_CONTENT_LIST_SIZE = 5; | 
| 35 |  |  | 
| 36 | 102292 | public AbstractBranch() { | 
| 37 |  | } | 
| 38 |  |  | 
| 39 | 138 | public boolean isReadOnly() { | 
| 40 | 138 | return false; | 
| 41 |  | } | 
| 42 |  |  | 
| 43 | 0 | public boolean hasContent() { | 
| 44 | 0 | return nodeCount() > 0; | 
| 45 |  | } | 
| 46 |  |  | 
| 47 | 4891 | public List content() { | 
| 48 | 4891 | List backingList = contentList(); | 
| 49 |  |  | 
| 50 | 4891 | return new ContentListFacade(this, backingList); | 
| 51 |  | } | 
| 52 |  |  | 
| 53 | 80 | public String getText() { | 
| 54 | 80 | List content = contentList(); | 
| 55 |  |  | 
| 56 | 80 | if (content != null) { | 
| 57 | 80 | int size = content.size(); | 
| 58 |  |  | 
| 59 | 80 | if (size >= 1) { | 
| 60 | 80 | Object first = content.get(0); | 
| 61 | 80 | String firstText = getContentAsText(first); | 
| 62 |  |  | 
| 63 | 80 | if (size == 1) { | 
| 64 |  |  | 
| 65 | 68 | return firstText; | 
| 66 |  | } else { | 
| 67 | 12 | StringBuffer buffer = new StringBuffer(firstText); | 
| 68 |  |  | 
| 69 | 12 | for (int i = 1; i < size; i++) { | 
| 70 | 29 | Object node = content.get(i); | 
| 71 | 29 | buffer.append(getContentAsText(node)); | 
| 72 |  | } | 
| 73 |  |  | 
| 74 | 12 | return buffer.toString(); | 
| 75 |  | } | 
| 76 |  | } | 
| 77 |  | } | 
| 78 |  |  | 
| 79 | 0 | return ""; | 
| 80 |  | } | 
| 81 |  |  | 
| 82 |  |  | 
| 83 |  |  | 
| 84 |  |  | 
| 85 |  |  | 
| 86 |  |  | 
| 87 |  |  | 
| 88 |  |  | 
| 89 |  |  | 
| 90 |  |  | 
| 91 | 202 | protected String getContentAsText(Object content) { | 
| 92 | 202 | if (content instanceof Node) { | 
| 93 | 202 | Node node = (Node) content; | 
| 94 |  |  | 
| 95 | 202 | switch (node.getNodeType()) { | 
| 96 | 2 | case CDATA_SECTION_NODE: | 
| 97 |  |  | 
| 98 |  |  | 
| 99 | 0 | case ENTITY_REFERENCE_NODE: | 
| 100 | 195 | case TEXT_NODE: | 
| 101 | 197 | return node.getText(); | 
| 102 |  |  | 
| 103 | 5 | default: | 
| 104 | 5 | break; | 
| 105 |  | } | 
| 106 | 0 | } else if (content instanceof String) { | 
| 107 | 0 | return (String) content; | 
| 108 |  | } | 
| 109 |  |  | 
| 110 | 5 | return ""; | 
| 111 |  | } | 
| 112 |  |  | 
| 113 |  |  | 
| 114 |  |  | 
| 115 |  |  | 
| 116 |  |  | 
| 117 |  |  | 
| 118 |  |  | 
| 119 |  |  | 
| 120 |  |  | 
| 121 | 13 | protected String getContentAsStringValue(Object content) { | 
| 122 | 13 | if (content instanceof Node) { | 
| 123 | 13 | Node node = (Node) content; | 
| 124 |  |  | 
| 125 | 13 | switch (node.getNodeType()) { | 
| 126 | 0 | case CDATA_SECTION_NODE: | 
| 127 |  |  | 
| 128 |  |  | 
| 129 | 0 | case ENTITY_REFERENCE_NODE: | 
| 130 | 11 | case TEXT_NODE: | 
| 131 | 2 | case ELEMENT_NODE: | 
| 132 | 13 | return node.getStringValue(); | 
| 133 |  |  | 
| 134 | 0 | default: | 
| 135 | 0 | break; | 
| 136 |  | } | 
| 137 | 0 | } else if (content instanceof String) { | 
| 138 | 0 | return (String) content; | 
| 139 |  | } | 
| 140 |  |  | 
| 141 | 0 | return ""; | 
| 142 |  | } | 
| 143 |  |  | 
| 144 | 77 | public String getTextTrim() { | 
| 145 | 77 | String text = getText(); | 
| 146 |  |  | 
| 147 | 77 | StringBuffer textContent = new StringBuffer(); | 
| 148 | 77 | StringTokenizer tokenizer = new StringTokenizer(text); | 
| 149 |  |  | 
| 150 | 77 | while (tokenizer.hasMoreTokens()) { | 
| 151 | 99 | String str = tokenizer.nextToken(); | 
| 152 | 99 | textContent.append(str); | 
| 153 |  |  | 
| 154 | 99 | if (tokenizer.hasMoreTokens()) { | 
| 155 | 23 | textContent.append(" "); | 
| 156 |  | } | 
| 157 |  | } | 
| 158 |  |  | 
| 159 | 77 | return textContent.toString(); | 
| 160 |  | } | 
| 161 |  |  | 
| 162 | 0 | public void setProcessingInstructions(List listOfPIs) { | 
| 163 | 0 | for (Iterator iter = listOfPIs.iterator(); iter.hasNext();) { | 
| 164 | 0 | ProcessingInstruction pi = (ProcessingInstruction) iter.next(); | 
| 165 | 0 | addNode(pi); | 
| 166 |  | } | 
| 167 |  | } | 
| 168 |  |  | 
| 169 | 0 | public Element addElement(String name) { | 
| 170 | 0 | Element node = getDocumentFactory().createElement(name); | 
| 171 | 0 | add(node); | 
| 172 |  |  | 
| 173 | 0 | return node; | 
| 174 |  | } | 
| 175 |  |  | 
| 176 | 2 | public Element addElement(String qualifiedName, String namespaceURI) { | 
| 177 | 2 | Element node = getDocumentFactory().createElement(qualifiedName, | 
| 178 |  | namespaceURI); | 
| 179 | 2 | add(node); | 
| 180 |  |  | 
| 181 | 2 | return node; | 
| 182 |  | } | 
| 183 |  |  | 
| 184 | 86007 | public Element addElement(QName qname) { | 
| 185 | 86007 | Element node = getDocumentFactory().createElement(qname); | 
| 186 | 86007 | add(node); | 
| 187 |  |  | 
| 188 | 86007 | return node; | 
| 189 |  | } | 
| 190 |  |  | 
| 191 | 0 | public Element addElement(String name, String prefix, String uri) { | 
| 192 | 0 | Namespace namespace = Namespace.get(prefix, uri); | 
| 193 | 0 | QName qName = getDocumentFactory().createQName(name, namespace); | 
| 194 |  |  | 
| 195 | 0 | return addElement(qName); | 
| 196 |  | } | 
| 197 |  |  | 
| 198 |  |  | 
| 199 | 14 | public void add(Node node) { | 
| 200 | 14 | switch (node.getNodeType()) { | 
| 201 | 14 | case ELEMENT_NODE: | 
| 202 | 14 | add((Element) node); | 
| 203 |  |  | 
| 204 | 14 | break; | 
| 205 |  |  | 
| 206 | 0 | case COMMENT_NODE: | 
| 207 | 0 | add((Comment) node); | 
| 208 |  |  | 
| 209 | 0 | break; | 
| 210 |  |  | 
| 211 | 0 | case PROCESSING_INSTRUCTION_NODE: | 
| 212 | 0 | add((ProcessingInstruction) node); | 
| 213 |  |  | 
| 214 | 0 | break; | 
| 215 |  |  | 
| 216 | 0 | default: | 
| 217 | 0 | invalidNodeTypeAddException(node); | 
| 218 |  | } | 
| 219 |  | } | 
| 220 |  |  | 
| 221 | 2 | public boolean remove(Node node) { | 
| 222 | 2 | switch (node.getNodeType()) { | 
| 223 | 2 | case ELEMENT_NODE: | 
| 224 | 2 | return remove((Element) node); | 
| 225 |  |  | 
| 226 | 0 | case COMMENT_NODE: | 
| 227 | 0 | return remove((Comment) node); | 
| 228 |  |  | 
| 229 | 0 | case PROCESSING_INSTRUCTION_NODE: | 
| 230 | 0 | return remove((ProcessingInstruction) node); | 
| 231 |  |  | 
| 232 | 0 | default: | 
| 233 | 0 | invalidNodeTypeAddException(node); | 
| 234 |  |  | 
| 235 | 0 | return false; | 
| 236 |  | } | 
| 237 |  | } | 
| 238 |  |  | 
| 239 |  |  | 
| 240 | 24 | public void add(Comment comment) { | 
| 241 | 24 | addNode(comment); | 
| 242 |  | } | 
| 243 |  |  | 
| 244 | 6291 | public void add(Element element) { | 
| 245 | 6291 | addNode(element); | 
| 246 |  | } | 
| 247 |  |  | 
| 248 | 25 | public void add(ProcessingInstruction pi) { | 
| 249 | 25 | addNode(pi); | 
| 250 |  | } | 
| 251 |  |  | 
| 252 | 0 | public boolean remove(Comment comment) { | 
| 253 | 0 | return removeNode(comment); | 
| 254 |  | } | 
| 255 |  |  | 
| 256 | 2 | public boolean remove(Element element) { | 
| 257 | 2 | return removeNode(element); | 
| 258 |  | } | 
| 259 |  |  | 
| 260 | 0 | public boolean remove(ProcessingInstruction pi) { | 
| 261 | 0 | return removeNode(pi); | 
| 262 |  | } | 
| 263 |  |  | 
| 264 | 13 | public Element elementByID(String elementID) { | 
| 265 | 13 | for (int i = 0, size = nodeCount(); i < size; i++) { | 
| 266 | 31 | Node node = node(i); | 
| 267 |  |  | 
| 268 | 31 | if (node instanceof Element) { | 
| 269 | 12 | Element element = (Element) node; | 
| 270 | 12 | String id = elementID(element); | 
| 271 |  |  | 
| 272 | 12 | if ((id != null) && id.equals(elementID)) { | 
| 273 | 1 | return element; | 
| 274 |  | } else { | 
| 275 | 11 | element = element.elementByID(elementID); | 
| 276 |  |  | 
| 277 | 11 | if (element != null) { | 
| 278 | 2 | return element; | 
| 279 |  | } | 
| 280 |  | } | 
| 281 |  | } | 
| 282 |  | } | 
| 283 |  |  | 
| 284 | 10 | return null; | 
| 285 |  | } | 
| 286 |  |  | 
| 287 | 143 | public void appendContent(Branch branch) { | 
| 288 | 143 | for (int i = 0, size = branch.nodeCount(); i < size; i++) { | 
| 289 | 330 | Node node = branch.node(i); | 
| 290 | 330 | add((Node) node.clone()); | 
| 291 |  | } | 
| 292 |  | } | 
| 293 |  |  | 
| 294 | 435 | public Node node(int index) { | 
| 295 | 435 | Object object = contentList().get(index); | 
| 296 |  |  | 
| 297 | 435 | if (object instanceof Node) { | 
| 298 | 435 | return (Node) object; | 
| 299 |  | } | 
| 300 |  |  | 
| 301 | 0 | if (object instanceof String) { | 
| 302 | 0 | return getDocumentFactory().createText(object.toString()); | 
| 303 |  | } | 
| 304 |  |  | 
| 305 | 0 | return null; | 
| 306 |  | } | 
| 307 |  |  | 
| 308 | 360 | public int nodeCount() { | 
| 309 | 360 | return contentList().size(); | 
| 310 |  | } | 
| 311 |  |  | 
| 312 | 0 | public int indexOf(Node node) { | 
| 313 | 0 | return contentList().indexOf(node); | 
| 314 |  | } | 
| 315 |  |  | 
| 316 | 313 | public Iterator nodeIterator() { | 
| 317 | 313 | return contentList().iterator(); | 
| 318 |  | } | 
| 319 |  |  | 
| 320 |  |  | 
| 321 |  |  | 
| 322 |  |  | 
| 323 |  |  | 
| 324 |  |  | 
| 325 |  |  | 
| 326 |  |  | 
| 327 |  |  | 
| 328 |  |  | 
| 329 |  |  | 
| 330 | 12 | protected String elementID(Element element) { | 
| 331 |  |  | 
| 332 |  |  | 
| 333 | 12 | return element.attributeValue("ID"); | 
| 334 |  | } | 
| 335 |  |  | 
| 336 |  |  | 
| 337 |  |  | 
| 338 |  |  | 
| 339 |  |  | 
| 340 |  |  | 
| 341 |  | protected abstract List contentList(); | 
| 342 |  |  | 
| 343 |  |  | 
| 344 |  |  | 
| 345 |  |  | 
| 346 |  |  | 
| 347 |  |  | 
| 348 |  |  | 
| 349 | 57260 | protected List createContentList() { | 
| 350 | 57260 | return new ArrayList(DEFAULT_CONTENT_LIST_SIZE); | 
| 351 |  | } | 
| 352 |  |  | 
| 353 |  |  | 
| 354 |  |  | 
| 355 |  |  | 
| 356 |  |  | 
| 357 |  |  | 
| 358 |  |  | 
| 359 |  |  | 
| 360 |  |  | 
| 361 |  |  | 
| 362 | 3 | protected List createContentList(int size) { | 
| 363 | 3 | return new ArrayList(size); | 
| 364 |  | } | 
| 365 |  |  | 
| 366 |  |  | 
| 367 |  |  | 
| 368 |  |  | 
| 369 |  |  | 
| 370 |  |  | 
| 371 |  |  | 
| 372 | 24169 | protected BackedList createResultList() { | 
| 373 | 24169 | return new BackedList(this, contentList()); | 
| 374 |  | } | 
| 375 |  |  | 
| 376 |  |  | 
| 377 |  |  | 
| 378 |  |  | 
| 379 |  |  | 
| 380 |  |  | 
| 381 |  |  | 
| 382 |  |  | 
| 383 |  |  | 
| 384 |  |  | 
| 385 | 0 | protected List createSingleResultList(Object result) { | 
| 386 | 0 | BackedList list = new BackedList(this, contentList(), 1); | 
| 387 | 0 | list.addLocal(result); | 
| 388 |  |  | 
| 389 | 0 | return list; | 
| 390 |  | } | 
| 391 |  |  | 
| 392 |  |  | 
| 393 |  |  | 
| 394 |  |  | 
| 395 |  |  | 
| 396 |  |  | 
| 397 |  |  | 
| 398 | 2 | protected List createEmptyList() { | 
| 399 | 2 | return new BackedList(this, contentList(), 0); | 
| 400 |  | } | 
| 401 |  |  | 
| 402 |  | protected abstract void addNode(Node node); | 
| 403 |  |  | 
| 404 |  | protected abstract void addNode(int index, Node node); | 
| 405 |  |  | 
| 406 |  | protected abstract boolean removeNode(Node node); | 
| 407 |  |  | 
| 408 |  |  | 
| 409 |  |  | 
| 410 |  |  | 
| 411 |  |  | 
| 412 |  |  | 
| 413 |  |  | 
| 414 |  |  | 
| 415 |  | protected abstract void childAdded(Node node); | 
| 416 |  |  | 
| 417 |  |  | 
| 418 |  |  | 
| 419 |  |  | 
| 420 |  |  | 
| 421 |  |  | 
| 422 |  |  | 
| 423 |  |  | 
| 424 |  | protected abstract void childRemoved(Node node); | 
| 425 |  |  | 
| 426 |  |  | 
| 427 |  |  | 
| 428 |  |  | 
| 429 |  |  | 
| 430 | 8 | protected void contentRemoved() { | 
| 431 | 8 | List content = contentList(); | 
| 432 |  |  | 
| 433 | 8 | for (int i = 0, size = content.size(); i < size; i++) { | 
| 434 | 8 | Object object = content.get(i); | 
| 435 |  |  | 
| 436 | 8 | if (object instanceof Node) { | 
| 437 | 8 | childRemoved((Node) object); | 
| 438 |  | } | 
| 439 |  | } | 
| 440 |  | } | 
| 441 |  |  | 
| 442 |  |  | 
| 443 |  |  | 
| 444 |  |  | 
| 445 |  |  | 
| 446 |  |  | 
| 447 |  |  | 
| 448 |  |  | 
| 449 |  |  | 
| 450 |  |  | 
| 451 |  |  | 
| 452 | 0 | protected void invalidNodeTypeAddException(Node node) { | 
| 453 | 0 | throw new IllegalAddException("Invalid node type. Cannot add node: " | 
| 454 |  | + node + " to this branch: " + this); | 
| 455 |  | } | 
| 456 |  | } | 
| 457 |  |  | 
| 458 |  |  | 
| 459 |  |  | 
| 460 |  |  | 
| 461 |  |  | 
| 462 |  |  | 
| 463 |  |  | 
| 464 |  |  | 
| 465 |  |  | 
| 466 |  |  | 
| 467 |  |  | 
| 468 |  |  | 
| 469 |  |  | 
| 470 |  |  | 
| 471 |  |  | 
| 472 |  |  | 
| 473 |  |  | 
| 474 |  |  | 
| 475 |  |  | 
| 476 |  |  | 
| 477 |  |  | 
| 478 |  |  | 
| 479 |  |  | 
| 480 |  |  | 
| 481 |  |  | 
| 482 |  |  | 
| 483 |  |  | 
| 484 |  |  | 
| 485 |  |  | 
| 486 |  |  | 
| 487 |  |  | 
| 488 |  |  | 
| 489 |  |  | 
| 490 |  |  | 
| 491 |  |  | 
| 492 |  |  | 
| 493 |  |  |