001 /* 002 * Common usable utilities 003 * 004 * Copyright (c) 2006 Petr Hadraba <hadrabap@gmail.com> 005 * 006 * Author: Petr Hadraba 007 * 008 * -- 009 * 010 * XML Utilities 011 */ 012 013 package global.sandbox.xmlutilities; 014 015 import java.io.File; 016 import java.io.InputStream; 017 import java.io.OutputStream; 018 import java.io.StringReader; 019 import java.util.Map; 020 import java.util.Properties; 021 import java.util.logging.Level; 022 import java.util.logging.Logger; 023 import javax.xml.namespace.NamespaceContext; 024 import javax.xml.parsers.DocumentBuilder; 025 import javax.xml.parsers.DocumentBuilderFactory; 026 import javax.xml.transform.Source; 027 import javax.xml.transform.Templates; 028 import javax.xml.transform.Transformer; 029 import javax.xml.transform.TransformerFactory; 030 import javax.xml.transform.dom.DOMSource; 031 import javax.xml.transform.stream.StreamSource; 032 import javax.xml.validation.SchemaFactory; 033 import javax.xml.xpath.XPath; 034 import javax.xml.xpath.XPathFactory; 035 import org.w3c.dom.Document; 036 import org.w3c.dom.Node; 037 import org.w3c.dom.NodeList; 038 039 /** 040 * Static version of the XML utilities class. 041 * 042 * @author Petr Hadraba 043 * 044 * @version 1.2 045 */ 046 public final class XmlTools { 047 048 /** 049 * Internal logger. 050 */ 051 private static final Logger LOGGER = Logger.getLogger(XmlUtilities.XMLUTILITIES_LOGGER_NAME); 052 053 /** 054 * Use this constant, if you want to use internal XMLUtilities for the static methods. 055 */ 056 private static final XmlUtilities INTERNAL_XMLUTILITIES = null; 057 058 /** 059 * Stores XMLUtilities object for the static usage. 060 */ 061 private static XmlUtilities xmlUtilities = null; 062 063 /** 064 * Converts Document to DOMSource object. 065 * 066 * @param source Document XML representation 067 * 068 * @return converted XML source 069 */ 070 public static Source documentToDomSource(final Document source) { 071 return new DOMSource(source); 072 } 073 074 /** 075 * Converts Document to DOMSource object. 076 * 077 * @param source Document XML representation 078 * @param systemId system ID 079 * 080 * @return converted XML source 081 */ 082 public static Source documentToDomSource(final Document source, String systemId) { 083 return new DOMSource(source, systemId); 084 } 085 086 /** 087 * Converts XML Document into String. 088 * 089 * @param source Document to convert 090 * @param xmlUtilities custom XMLUtilities; can be null 091 * 092 * @return XML in the String 093 * 094 * @throws XmlUtilitiesException on error 095 */ 096 public static String documentToString(final Document source, final XmlUtilities xmlUtilities) throws XmlUtilitiesException { 097 if (xmlUtilities != null) { 098 return xmlUtilities.documentToString(source); 099 } 100 101 if (XmlTools.xmlUtilities == null) { 102 XmlTools.initializeXmlUtilities(); 103 } 104 105 return XmlTools.xmlUtilities.documentToString(source); 106 } 107 108 /** 109 * Converts XML Document into String. 110 * 111 * @param source Document to convert 112 * @param outputFormat output format configuration 113 * 114 * @return XML in the String 115 * 116 * @throws XmlUtilitiesException on error 117 */ 118 public static String documentToString(final Document source, final OutputFormat outputFormat) throws XmlUtilitiesException { 119 return documentToString(source, outputFormat, INTERNAL_XMLUTILITIES); 120 } 121 122 /** 123 * Converts XML Document into String. 124 * 125 * @param source Document to convert 126 * @param outputProperties output properties (see {@link OutputFormat OutputFormat}) 127 * 128 * @return XML in the String 129 * 130 * @throws XmlUtilitiesException on error 131 */ 132 public static String documentToString(final Document source, final Properties outputProperties) throws XmlUtilitiesException { 133 return documentToString(source, outputProperties, INTERNAL_XMLUTILITIES); 134 } 135 136 /** 137 * Converts XML Document into String. 138 * 139 * @param source Document to convert 140 * @param outputFormat output format configuration 141 * @param xmlUtilities custom XMLUtilities; can be null 142 * 143 * @return XML in the String 144 * 145 * @throws XmlUtilitiesException on error 146 */ 147 public static String documentToString(final Document source, final OutputFormat outputFormat, final XmlUtilities xmlUtilities) throws XmlUtilitiesException { 148 if (xmlUtilities != null) { 149 return xmlUtilities.documentToString(source, outputFormat); 150 } 151 152 if (XmlTools.xmlUtilities == null) { 153 XmlTools.initializeXmlUtilities(); 154 } 155 156 return XmlTools.xmlUtilities.documentToString(source, outputFormat); 157 } 158 159 /** 160 * Converts XML Document into String. 161 * 162 * @param source Document to convert 163 * @param outputProperties output properties (see {@link OutputFormat OutputFormat}) 164 * @param xmlUtilities custom XMLUtilities; can be null 165 * 166 * @return XML in the String 167 * 168 * @throws XmlUtilitiesException on error 169 */ 170 public static String documentToString(final Document source, final Properties outputProperties, final XmlUtilities xmlUtilities) throws XmlUtilitiesException { 171 if (xmlUtilities != null) { 172 return xmlUtilities.documentToString(source, outputProperties); 173 } 174 175 if (XmlTools.xmlUtilities == null) { 176 XmlTools.initializeXmlUtilities(); 177 } 178 179 return XmlTools.xmlUtilities.documentToString(source, outputProperties); 180 } 181 182 /** 183 * Converts XML Document into String. 184 * 185 * @param source Document to convert 186 * 187 * @return XML in the String 188 * 189 * @throws XmlUtilitiesException on error 190 */ 191 public static String documentToString(final Document source) throws XmlUtilitiesException { 192 return documentToString(source, INTERNAL_XMLUTILITIES); 193 } 194 195 /** 196 * Evaluates specified XPath expression on specified context node. 197 * 198 * @param query XPath expression 199 * @param context context node 200 * @param namespaces name space context 201 * @param xmlUtilities custom XMLUtilities; can be null 202 * 203 * @return {@link NodeList NodeList} or {@code null} if no matches 204 * 205 * @throws XmlUtilitiesException on error 206 */ 207 public static NodeList evaluateXPath(final String query, final Node context, final NamespaceContext namespaces, final XmlUtilities xmlUtilities) 208 throws XmlUtilitiesException { 209 if (xmlUtilities != null) { 210 return xmlUtilities.evaluateXPath(query, context, namespaces); 211 } 212 213 if (XmlTools.xmlUtilities == null) { 214 XmlTools.initializeXmlUtilities(); 215 } 216 217 return XmlTools.xmlUtilities.evaluateXPath(query, context, namespaces); 218 } 219 220 /** 221 * Evaluates specified XPath expression on specified context node. 222 * 223 * @param query XPath expression 224 * @param context context node 225 * @param namespaces name space context 226 * 227 * @return {@link NodeList NodeList} or {@code null} if no matches 228 * 229 * @throws XmlUtilitiesException on error 230 */ 231 public static NodeList evaluateXPath(final String query, final Node context, final NamespaceContext namespaces) throws XmlUtilitiesException { 232 return evaluateXPath(query, context, namespaces, INTERNAL_XMLUTILITIES); 233 } 234 235 /** 236 * Evaluates specified XPath expression on specified context node. 237 * 238 * @param query XPath expression 239 * @param context context node 240 * @param xmlUtilities custom XMLUtilities; can be null 241 * 242 * @return {@link NodeList NodeList} or {@code null} if no matches 243 * 244 * @throws XmlUtilitiesException on error 245 */ 246 public static NodeList evaluateXPath(final String query, final Node context, final XmlUtilities xmlUtilities) throws XmlUtilitiesException { 247 if (xmlUtilities != null) { 248 return xmlUtilities.evaluateXPath(query, context); 249 } 250 251 if (XmlTools.xmlUtilities == null) { 252 XmlTools.initializeXmlUtilities(); 253 } 254 255 return XmlTools.xmlUtilities.evaluateXPath(query, context); 256 } 257 258 /** 259 * Evaluates specified XPath expression on specified context node. 260 * 261 * @param query XPath expression 262 * @param context context node 263 * 264 * @return {@link NodeList NodeList} or {@code null} if no matches 265 * 266 * @throws XmlUtilitiesException on error 267 */ 268 public static NodeList evaluateXPath(final String query, final Node context) throws XmlUtilitiesException { 269 return evaluateXPath(query, context, INTERNAL_XMLUTILITIES); 270 } 271 272 /** 273 * Evaluates specified XPath expression on specified context node and returns results as 274 * {@link NodeListCollection NodeListCollection} of specified element types. This method never returns {@code null}. 275 * 276 * @param <E> type of element 277 * @param query XPath expression 278 * @param context context node 279 * @param elementType class type of element 280 * 281 * @return {@link NodeListCollection NodeListCollection} of element type or empty list if no matches. 282 * 283 * @throws XmlUtilitiesException on error 284 */ 285 @SuppressWarnings("unchecked") 286 public static <E extends Node> NodeListCollection<E> evaluateXPath(final String query, final Node context, final Class<E> elementType) throws XmlUtilitiesException { 287 return evaluateXPath(query, context, elementType, INTERNAL_XMLUTILITIES); 288 } 289 290 /** 291 * Evaluates specified XPath expression on specified context node and returns results as 292 * {@link NodeListCollection NodeListCollection} of specified element types. This method never returns {@code null}. 293 * 294 * @param <E> type of element 295 * @param query XPath expression 296 * @param context context node 297 * @param namespaces name space context 298 * @param elementType class type of element 299 * 300 * @return {@link NodeListCollection NodeListCollection} of element type or empty list if no matches. 301 * 302 * @throws XmlUtilitiesException on error 303 */ 304 @SuppressWarnings("unchecked") 305 public static <E extends Node> NodeListCollection<E> evaluateXPath(final String query, final Node context, final NamespaceContext namespaces, final Class<E> elementType) 306 throws XmlUtilitiesException { 307 return evaluateXPath(query, context, namespaces, elementType, INTERNAL_XMLUTILITIES); 308 } 309 310 /** 311 * Evaluates specified XPath expression on specified context node and returns results as 312 * {@link NodeListCollection NodeListCollection} of specified element types. This method never returns {@code null}. 313 * 314 * @param <E> type of element 315 * @param query XPath expression 316 * @param context context node 317 * @param elementType class type of element 318 * @param xmlUtilities custom XMLUtilities; can be {@code null} 319 * 320 * @return {@link NodeListCollection NodeListCollection} of element type or empty list if no matches. 321 * 322 * @throws XmlUtilitiesException on error 323 */ 324 @SuppressWarnings("unchecked") 325 public static <E extends Node> NodeListCollection<E> evaluateXPath(final String query, final Node context, final Class<E> elementType, final XmlUtilities xmlUtilities) 326 throws XmlUtilitiesException { 327 if (xmlUtilities != null) { 328 return xmlUtilities.evaluateXPath(query, context, elementType); 329 } 330 331 if (XmlTools.xmlUtilities == null) { 332 XmlTools.initializeXmlUtilities(); 333 } 334 335 return XmlTools.xmlUtilities.evaluateXPath(query, context, elementType); 336 } 337 338 /** 339 * Evaluates specified XPath expression on specified context node and returns results as 340 * {@link NodeListCollection NodeListCollection} of specified element types. This method never returns {@code null}. 341 * 342 * @param <E> type of element 343 * @param query XPath expression 344 * @param context context node 345 * @param namespaces name space context 346 * @param elementType class type of element 347 * @param xmlUtilities custom XMLUtilities; can be {@code null} 348 * 349 * @return {@link NodeListCollection NodeListCollection} of element type or empty list if no matches. 350 * 351 * @throws XmlUtilitiesException on error 352 */ 353 @SuppressWarnings("unchecked") 354 public static <E extends Node> NodeListCollection<E> evaluateXPath( 355 final String query, 356 final Node context, 357 final NamespaceContext namespaces, 358 final Class<E> elementType, 359 final XmlUtilities xmlUtilities) 360 throws XmlUtilitiesException { 361 if (xmlUtilities != null) { 362 return xmlUtilities.evaluateXPath(query, context, namespaces, elementType); 363 } 364 365 if (XmlTools.xmlUtilities == null) { 366 XmlTools.initializeXmlUtilities(); 367 } 368 369 return XmlTools.xmlUtilities.evaluateXPath(query, context, namespaces, elementType); 370 } 371 372 /** 373 * Evaluates specified XPath expression and returns first Node if XPath has matches. 374 * 375 * @param query XPath expression 376 * @param context context node 377 * @param xmlUtilities custom XMLUtilities; can be {@code null} 378 * 379 * @return first node or {@code null} 380 * 381 * @throws XmlUtilitiesException on error 382 */ 383 public static Node getFirstNodeForXPath(final String query, final Node context, final XmlUtilities xmlUtilities) throws XmlUtilitiesException { 384 if (xmlUtilities != null) { 385 return xmlUtilities.getFirstNodeForXPath(query, context); 386 } 387 388 if (XmlTools.xmlUtilities == null) { 389 XmlTools.initializeXmlUtilities(); 390 } 391 392 return XmlTools.xmlUtilities.getFirstNodeForXPath(query, context); 393 } 394 395 /** 396 * Evaluates specified XPath expression and returns first Node if XPath has matches. 397 * 398 * @param query XPath expression 399 * @param context context node 400 * 401 * @return first node or {@code null} 402 * 403 * @throws XmlUtilitiesException on error 404 */ 405 public static Node getFirstNodeForXPath(final String query, final Node context) throws XmlUtilitiesException { 406 return getFirstNodeForXPath(query, context, INTERNAL_XMLUTILITIES); 407 } 408 409 /** 410 * Evaluates specified XPath expression and returns first Node if XPath has matches. 411 * 412 * @param query XPath expression 413 * @param context context node 414 * @param namespaces name space context 415 * @param xmlUtilities custom XMLUtilities; can be null 416 * 417 * @return first node or {@code null} 418 * 419 * @throws XmlUtilitiesException on error 420 */ 421 public static Node getFirstNodeForXPath(final String query, final Node context, final NamespaceContext namespaces, final XmlUtilities xmlUtilities) 422 throws XmlUtilitiesException { 423 if (xmlUtilities != null) { 424 return xmlUtilities.getFirstNodeForXPath( 425 query, context, namespaces); 426 } 427 428 if (XmlTools.xmlUtilities == null) { 429 XmlTools.initializeXmlUtilities(); 430 } 431 432 return XmlTools.xmlUtilities.getFirstNodeForXPath( 433 query, context, namespaces); 434 } 435 436 /** 437 * Evaluates specified XPath expression and returns first Node if XPath has matches. 438 * 439 * @param query XPath expression 440 * @param context context node 441 * @param namespaces name space context 442 * 443 * @return first node or null 444 * 445 * @throws XmlUtilitiesException on error 446 */ 447 public static Node getFirstNodeForXPath(final String query, final Node context, final NamespaceContext namespaces) throws XmlUtilitiesException { 448 return getFirstNodeForXPath(query, context, namespaces, INTERNAL_XMLUTILITIES); 449 } 450 451 /** 452 * Evaluates specified XPath expression and returns first Node as specified element type if XPath has matches. 453 * 454 * @param <E> type of element 455 * @param query XPath expression 456 * @param context context node 457 * @param elementType class type of element 458 * 459 * @return first node as specified type or {@code null} 460 * 461 * @throws XmlUtilitiesException on error 462 */ 463 public static <E extends Node> E getFirstNodeForXPath(final String query, final Node context, final Class<E> elementType) throws XmlUtilitiesException { 464 return getFirstNodeForXPath(query, context, elementType, INTERNAL_XMLUTILITIES); 465 } 466 467 /** 468 * Evaluates specified XPath expression and returns first Node as specified element type if XPath has matches. 469 * 470 * @param <E> type of element 471 * @param query XPath expression 472 * @param context context node 473 * @param namespaces name space context 474 * @param elementType class type of element 475 * 476 * @return first node as specified type or {@code null} 477 * 478 * @throws XmlUtilitiesException on error 479 */ 480 public static <E extends Node> E getFirstNodeForXPath(final String query, final Node context, final NamespaceContext namespaces, final Class<E> elementType) 481 throws XmlUtilitiesException { 482 return getFirstNodeForXPath(query, context, namespaces, elementType, INTERNAL_XMLUTILITIES); 483 } 484 485 /** 486 * Evaluates specified XPath expression and returns first Node as specified element type if XPath has matches. 487 * 488 * @param <E> type of element 489 * @param query XPath expression 490 * @param context context node 491 * @param elementType class type of element 492 * @param xmlUtilities custom XMLUtilities; can be null 493 * 494 * @return first node as specified type or {@code null} 495 * 496 * @throws XmlUtilitiesException on error 497 */ 498 public static <E extends Node> E getFirstNodeForXPath(final String query, final Node context, final Class<E> elementType, final XmlUtilities xmlUtilities) 499 throws XmlUtilitiesException { 500 if (xmlUtilities != null) { 501 return xmlUtilities.getFirstNodeForXPath(query, context, elementType); 502 } 503 504 if (XmlTools.xmlUtilities == null) { 505 initializeXmlUtilities(); 506 } 507 508 return XmlTools.xmlUtilities.getFirstNodeForXPath(query, context, elementType); 509 } 510 511 /** 512 * Evaluates specified XPath expression and returns first Node as specified element type if XPath has matches. 513 * 514 * @param <E> type of element 515 * @param query XPath expression 516 * @param context context node 517 * @param namespaces name space context 518 * @param elementType class type of element 519 * @param xmlUtilities custom XMLUtilities; can be null 520 * 521 * @return first node as specified type or {@code null} 522 * 523 * @throws XmlUtilitiesException on error 524 */ 525 public static <E extends Node> E getFirstNodeForXPath( 526 final String query, 527 final Node context, 528 final NamespaceContext namespaces, 529 final Class<E> elementType, 530 final XmlUtilities xmlUtilities) 531 throws XmlUtilitiesException { 532 if (xmlUtilities != null) { 533 return xmlUtilities.getFirstNodeForXPath(query, context, namespaces, elementType); 534 } 535 536 if (XmlTools.xmlUtilities == null) { 537 initializeXmlUtilities(); 538 } 539 540 return XmlTools.xmlUtilities.getFirstNodeForXPath(query, context, namespaces, elementType); 541 } 542 543 /** 544 * Initializes XMLUtilities static member for the static usage. 545 * 546 * @throws XmlUtilitiesException on error 547 */ 548 private static void initializeXmlUtilities() throws XmlUtilitiesException { 549 XmlTools.xmlUtilities = new XmlUtilities(); 550 } 551 552 /** 553 * Initializes XMLUtilities static member for the static usage using specified XMLUtilities. 554 * 555 * @param xmlUtilities XMLUtilities to use 556 */ 557 public static void initializeXmlUtilities(final XmlUtilities xmlUtilities) { 558 if (xmlUtilities == null) { 559 throw new NullPointerException(); 560 } 561 562 XmlTools.xmlUtilities = xmlUtilities; 563 } 564 565 /** 566 * Rests internal XML Utilities so new instance will be created while next relevant call is invoked. 567 */ 568 public static void resetXmlUtilities() { 569 XmlTools.xmlUtilities = null; 570 } 571 572 /** 573 * Returns SchemaFactory object internally used by the XMLUtilities static methods. 574 * 575 * @return SchemaFactory object 576 */ 577 public static SchemaFactory getInternalSchemaFactory() { 578 if (xmlUtilities == null) { 579 return null; 580 } 581 582 return xmlUtilities.getSchemaFactory(); 583 } 584 585 /** 586 * Returns DocumentBuilder object internally used by the XMLUtilities static methods. 587 * 588 * @return DocumentBuilder object 589 */ 590 public static DocumentBuilder getInternalDocumentBuilder() { 591 if (xmlUtilities == null) { 592 return null; 593 } 594 595 return xmlUtilities.getDocumentBuilder(); 596 } 597 598 /** 599 * Returns TransformerFactory object internally used by the XMLUtilities static methods. 600 * 601 * @return TransformerFactory object 602 */ 603 public static TransformerFactory getInternalTransformerFactory() { 604 if (xmlUtilities == null) { 605 return null; 606 } 607 608 return xmlUtilities.getTransformerFactory(); 609 } 610 611 /** 612 * Returns Transformer object internally used by the XMLUtilities static methods. 613 * 614 * @return Transformer object 615 */ 616 public static Transformer getInternalTransformer() { 617 if (xmlUtilities == null) { 618 return null; 619 } 620 621 return xmlUtilities.getTransformer(); 622 } 623 624 /** 625 * Returns XPathFactory object internally used by the XMLUtilities static methods. 626 * 627 * @return XPathFactory object 628 */ 629 public static XPathFactory getInternalXPathFactory() { 630 if (xmlUtilities == null) { 631 return null; 632 } 633 634 return xmlUtilities.getXPathFactory(); 635 } 636 637 /** 638 * Returns NamespaceContext object internally used by the XMLUtilities static methods. 639 * 640 * @return NamespaceContext object 641 */ 642 public static NamespaceContext getInternalNamespaceContext() { 643 if (xmlUtilities == null) { 644 return null; 645 } 646 647 return xmlUtilities.getDefaultNamespaceContext(); 648 } 649 650 /** 651 * Validates specified XML with the specified XMLScheme. 652 * 653 * @param xmlDocument XML document to validate 654 * @param xmlSchema XMLSchema 655 * @param xmlUtilities specified XMLUtilities. if null, internal will be used 656 * 657 * @return {@code null} if successful, string with error message otherwise 658 * 659 * @throws XmlUtilitiesException on technical error 660 */ 661 public static String validateXmlUsingSchema(final Source xmlDocument, final Source xmlSchema, final XmlUtilities xmlUtilities) throws XmlUtilitiesException { 662 if (xmlUtilities != null) { 663 return xmlUtilities.validateXmlUsingSchema(xmlDocument, xmlSchema); 664 } 665 666 if (XmlTools.xmlUtilities == null) { 667 XmlTools.initializeXmlUtilities(); 668 } 669 670 return XmlTools.xmlUtilities.validateXmlUsingSchema(xmlDocument, xmlSchema); 671 } 672 673 /** 674 * Validates specified XML with the specified XMLScheme. 675 * 676 * @param xmlDocument XML document to validate 677 * @param xmlSchema XMLSchema 678 * 679 * @return {@code null} if successful, string with error otherwise 680 * 681 * @throws XmlUtilitiesException on technical error 682 */ 683 public static String validateXmlUsingSchema(final Source xmlDocument, final Source xmlSchema) throws XmlUtilitiesException { 684 return validateXmlUsingSchema(xmlDocument, xmlSchema, INTERNAL_XMLUTILITIES); 685 } 686 687 /** 688 * Loads XML from file specified with file name. 689 * 690 * @param fileName file to load 691 * @param xmlUtilities custom XMLUtilities object; can be null 692 * 693 * @return Document object 694 * 695 * @throws XmlUtilitiesException on error 696 */ 697 public static Document loadDocumentFromFile(final String fileName, final XmlUtilities xmlUtilities) throws XmlUtilitiesException { 698 if (xmlUtilities != null) { 699 return xmlUtilities.loadDocumentFromFile(fileName); 700 } 701 702 if (XmlTools.xmlUtilities == null) { 703 XmlTools.initializeXmlUtilities(); 704 } 705 706 return XmlTools.xmlUtilities.loadDocumentFromFile(fileName); 707 } 708 709 /** 710 * Loads XML from file specified with file name. 711 * 712 * @param fileName file to load 713 * 714 * @return Document object 715 * 716 * @throws XmlUtilitiesException on error 717 */ 718 public static Document loadDocumentFromFile(final String fileName) throws XmlUtilitiesException { 719 return loadDocumentFromFile(fileName, INTERNAL_XMLUTILITIES); 720 } 721 722 /** 723 * Loads XML from file specified with file name. 724 * 725 * @param fileName file to load 726 * @param documentBuilder custom DocumentBuilder 727 * @param xmlUtilities custom XMLUtilities; can be null 728 * 729 * @return Document object 730 * 731 * @throws XmlUtilitiesException on error 732 */ 733 public static Document loadDocumentFromFile(final String fileName, final DocumentBuilder documentBuilder, final XmlUtilities xmlUtilities) throws XmlUtilitiesException { 734 if (xmlUtilities != null) { 735 return xmlUtilities.loadDocumentFromFile(fileName, documentBuilder); 736 } 737 738 if (XmlTools.xmlUtilities == null) { 739 XmlTools.initializeXmlUtilities(); 740 } 741 742 return XmlTools.xmlUtilities.loadDocumentFromFile(fileName, documentBuilder); 743 } 744 745 /** 746 * Loads XML from file specified with file name. 747 * 748 * @param fileName file to load 749 * @param documentBuilder custom DocumentBuilder 750 * 751 * @return Document object 752 * 753 * @throws XmlUtilitiesException on error 754 */ 755 public static Document loadDocumentFromFile(final String fileName, final DocumentBuilder documentBuilder) throws XmlUtilitiesException { 756 return loadDocumentFromFile(fileName, documentBuilder, INTERNAL_XMLUTILITIES); 757 } 758 759 /** 760 * Loads XML from file specified with the File object. 761 * 762 * @param file file to load 763 * @param xmlUtilities custom XMLUtilities; can be null 764 * 765 * @return Document object 766 * 767 * @throws XmlUtilitiesException on error 768 */ 769 public static Document loadDocumentFromFile(final File file, final XmlUtilities xmlUtilities) throws XmlUtilitiesException { 770 if (xmlUtilities != null) { 771 return xmlUtilities.loadDocumentFromFile(file); 772 } 773 774 if (XmlTools.xmlUtilities == null) { 775 XmlTools.initializeXmlUtilities(); 776 } 777 778 return XmlTools.xmlUtilities.loadDocumentFromFile(file); 779 } 780 781 /** 782 * Loads XML from file specified with the File object. 783 * 784 * @param file file to load 785 * 786 * @return Document object 787 * 788 * @throws XmlUtilitiesException on error 789 */ 790 public static Document loadDocumentFromFile(final File file) throws XmlUtilitiesException { 791 return loadDocumentFromFile(file, INTERNAL_XMLUTILITIES); 792 } 793 794 /** 795 * Loads XML from file specified with the file object. 796 * 797 * @param file file to load 798 * @param documentBuilder custom document builder 799 * @param xmlUtilities custom XMLUtilities; can be null 800 * 801 * @return Document object 802 * 803 * @throws XmlUtilitiesException on error 804 */ 805 public static Document loadDocumentFromFile(final File file, final DocumentBuilder documentBuilder, final XmlUtilities xmlUtilities) throws XmlUtilitiesException { 806 if (xmlUtilities != null) { 807 return xmlUtilities.loadDocumentFromFile(file, documentBuilder); 808 } 809 810 if (XmlTools.xmlUtilities == null) { 811 XmlTools.initializeXmlUtilities(); 812 } 813 814 return XmlTools.xmlUtilities.loadDocumentFromFile(file, documentBuilder); 815 } 816 817 /** 818 * Loads XML from file specified with the file object. 819 * 820 * @param file file to load 821 * @param documentBuilder custom document builder 822 * 823 * @return Document object 824 * 825 * @throws XmlUtilitiesException on error 826 */ 827 public static Document loadDocumentFromFile(final File file, final DocumentBuilder documentBuilder) throws XmlUtilitiesException { 828 return loadDocumentFromFile(file, documentBuilder, INTERNAL_XMLUTILITIES); 829 } 830 831 /** 832 * Loads XML from specified stream. 833 * 834 * @param is input stream 835 * @param xmlUtilities custom XMLUtilities (can be null) 836 * 837 * @return Document object 838 * 839 * @throws XmlUtilitiesException on error 840 */ 841 public static Document loadDocumentFromStream(final InputStream is, final XmlUtilities xmlUtilities) throws XmlUtilitiesException { 842 if (xmlUtilities != null) { 843 return xmlUtilities.loadDocumentFromStream(is); 844 } 845 846 if (XmlTools.xmlUtilities == null) { 847 XmlTools.initializeXmlUtilities(); 848 } 849 850 return XmlTools.xmlUtilities.loadDocumentFromStream(is); 851 } 852 853 /** 854 * Loads XML from specified stream. 855 * 856 * @param is input stream 857 * 858 * @return Document object 859 * 860 * @throws XmlUtilitiesException on error 861 */ 862 public static Document loadDocumentFromStream(final InputStream is) throws XmlUtilitiesException { 863 return loadDocumentFromStream(is, INTERNAL_XMLUTILITIES); 864 } 865 866 /** 867 * Loads XML from specified input stream. 868 * 869 * @param is input stream 870 * @param documentBuilder custom Document Builder 871 * @param xmlUtilities custom XMLUtilities (can be null) 872 * 873 * @return Document object 874 * 875 * @throws XmlUtilitiesException on error 876 */ 877 public static Document loadDocumentFromStream(final InputStream is, final DocumentBuilder documentBuilder, final XmlUtilities xmlUtilities) throws XmlUtilitiesException { 878 if (xmlUtilities != null) { 879 return xmlUtilities.loadDocumentFromStream(is, documentBuilder); 880 } 881 882 if (XmlTools.xmlUtilities == null) { 883 XmlTools.initializeXmlUtilities(); 884 } 885 886 return XmlTools.xmlUtilities.loadDocumentFromStream(is, documentBuilder); 887 } 888 889 /** 890 * Loads XML from specified input stream. 891 * 892 * @param is input stream 893 * @param documentBuilder custom Document Builder 894 * 895 * @return Document object 896 * 897 * @throws XmlUtilitiesException on error 898 */ 899 public static Document loadDocumentFromStream(final InputStream is, final DocumentBuilder documentBuilder) throws XmlUtilitiesException { 900 return loadDocumentFromStream(is, documentBuilder, INTERNAL_XMLUTILITIES); 901 } 902 903 /** 904 * Loads document from ClassLoaders. The first of {@code ContextClassLoader}, {@code fallBackClazz#getClassLoader()} 905 * or {@code SystemClassLoader} is used whichever is find first. 906 * 907 * @param resource resource name to load from 908 * @param fallbackClazz ClassLoader to use if {@code ContextClassLoader} does not exist 909 * 910 * @return Document object 911 * 912 * @throws XmlUtilitiesException on error 913 */ 914 public static Document loadDocumentFromClassLoader(final String resource, final Class<?> fallbackClazz) throws XmlUtilitiesException { 915 return loadDocumentFromClassLoader(resource, fallbackClazz, INTERNAL_XMLUTILITIES); 916 } 917 918 /** 919 * Loads document from ClassLoaders. The first of {@code ContextClassLoader}, {@code fallBackClazz#getClassLoader()} 920 * or {@code SystemClassLoader} is used whichever is find first. 921 * 922 * @param resource resource name to load from 923 * @param documentBuilder custom DocumentBuilder 924 * @param fallbackClazz ClassLoader to use if {@code ContextClassLoader} does not exist 925 * 926 * @return Document object 927 * 928 * @throws XmlUtilitiesException on error 929 */ 930 public static Document loadDocumentFromClassLoader(final String resource, final DocumentBuilder documentBuilder, final Class<?> fallbackClazz) throws XmlUtilitiesException { 931 return loadDocumentFromClassLoader(resource, documentBuilder, fallbackClazz, INTERNAL_XMLUTILITIES); 932 } 933 934 /** 935 * Loads document from ClassLoaders. The first of {@code ContextClassLoader}, {@code fallBackClazz#getClassLoader()} 936 * or {@code SystemClassLoader} is used whichever is find first. 937 * 938 * @param resource resource name to load from 939 * @param fallbackClazz ClassLoader to use if {@code ContextClassLoader} does not exist 940 * @param xmlUtilities custom XMLUtilities (can be null) 941 * 942 * @return Document object 943 * 944 * @throws XmlUtilitiesException on error 945 */ 946 public static Document loadDocumentFromClassLoader(final String resource, final Class<?> fallbackClazz, final XmlUtilities xmlUtilities) throws XmlUtilitiesException { 947 if (xmlUtilities != null) { 948 return xmlUtilities.loadDocumentFromClassLoader(resource, fallbackClazz); 949 } 950 951 if (XmlTools.xmlUtilities == null) { 952 XmlTools.initializeXmlUtilities(); 953 } 954 955 return XmlTools.xmlUtilities.loadDocumentFromClassLoader(resource, fallbackClazz); 956 } 957 958 /** 959 * Loads document from ClassLoaders. The first of {@code ContextClassLoader}, {@code fallBackClazz#getClassLoader()} 960 * or {@code SystemClassLoader} is used whichever is find first. 961 * 962 * @param resource resource name to load from 963 * @param documentBuilder custom DocumentBuilder 964 * @param fallbackClazz ClassLoader to use if {@code ContextClassLoader} does not exist 965 * @param xmlUtilities custom XMLUtilities (can be null) 966 * 967 * @return Document object 968 * 969 * @throws XmlUtilitiesException on error 970 */ 971 public static Document loadDocumentFromClassLoader( 972 final String resource, 973 final DocumentBuilder documentBuilder, 974 final Class<?> fallbackClazz, 975 final XmlUtilities xmlUtilities) 976 throws XmlUtilitiesException { 977 if (xmlUtilities != null) { 978 return xmlUtilities.loadDocumentFromClassLoader(resource, documentBuilder, fallbackClazz); 979 } 980 981 if (XmlTools.xmlUtilities == null) { 982 XmlTools.initializeXmlUtilities(); 983 } 984 985 return XmlTools.xmlUtilities.loadDocumentFromClassLoader(resource, documentBuilder, fallbackClazz); 986 } 987 988 /** 989 * Loads Document from resource from given class. 990 * 991 * @param resource resource to load 992 * @param clazz class to use 993 * @param xmlUtilities custom XMLUtilities (can be null) 994 * 995 * @return Document object 996 * 997 * @throws XmlUtilitiesException on error 998 */ 999 public static Document loadDocumentFromResource(final String resource, final Class<?> clazz, final XmlUtilities xmlUtilities) throws XmlUtilitiesException { 1000 if (xmlUtilities != null) { 1001 return xmlUtilities.loadDocumentFromResource(resource, clazz); 1002 } 1003 1004 if (XmlTools.xmlUtilities == null) { 1005 XmlTools.initializeXmlUtilities(); 1006 } 1007 1008 return XmlTools.xmlUtilities.loadDocumentFromResource(resource, clazz); 1009 } 1010 1011 /** 1012 * Loads Document from resource from given class. 1013 * 1014 * @param resource resource to load 1015 * @param documentBuilder custom DocumentBuilder 1016 * @param clazz class to use 1017 * @param xmlUtilities custom XMLUtilities (can be null) 1018 * 1019 * @return Document object 1020 * 1021 * @throws XmlUtilitiesException on error 1022 */ 1023 public static Document loadDocumentFromResource(final String resource, final DocumentBuilder documentBuilder, final Class<?> clazz, final XmlUtilities xmlUtilities) 1024 throws XmlUtilitiesException { 1025 if (xmlUtilities != null) { 1026 return xmlUtilities.loadDocumentFromResource(resource, documentBuilder, clazz); 1027 } 1028 1029 if (XmlTools.xmlUtilities == null) { 1030 XmlTools.initializeXmlUtilities(); 1031 } 1032 1033 return XmlTools.xmlUtilities.loadDocumentFromResource(resource, documentBuilder, clazz); 1034 } 1035 1036 /** 1037 * Loads Document from resource from given class. 1038 * 1039 * @param resource resource to load 1040 * @param clazz class to use 1041 * 1042 * @return Document object 1043 * 1044 * @throws XmlUtilitiesException on error 1045 */ 1046 public static Document loadDocumentFromResource(final String resource, final Class<?> clazz) throws XmlUtilitiesException { 1047 return loadDocumentFromClassLoader(resource, clazz, INTERNAL_XMLUTILITIES); 1048 } 1049 1050 /** 1051 * Loads Document from resource from given class. 1052 * 1053 * @param resource resource to load 1054 * @param documentBuilder custom DocumentBuilder 1055 * @param clazz class to use 1056 * 1057 * @return Document object 1058 * 1059 * @throws XmlUtilitiesException on error 1060 */ 1061 public static Document loadDocumentFromResource(final String resource, final DocumentBuilder documentBuilder, final Class<?> clazz) throws XmlUtilitiesException { 1062 return loadDocumentFromResource(resource, documentBuilder, clazz, INTERNAL_XMLUTILITIES); 1063 } 1064 1065 /** 1066 * Loads document from resource using specified ClassLoader. 1067 * 1068 * @param resource resource to load 1069 * @param classLoader ClassLoader to use 1070 * 1071 * @return Document object 1072 * 1073 * @throws XmlUtilitiesException on error 1074 */ 1075 public static Document loadDocumentFromResource(final String resource, final ClassLoader classLoader) throws XmlUtilitiesException { 1076 return loadDocumentFromResource(resource, classLoader, INTERNAL_XMLUTILITIES); 1077 } 1078 1079 /** 1080 * Loads document from resource using specified ClassLoader. 1081 * 1082 * @param resource resource to load 1083 * @param documentBuilder custom DocumentBuilder 1084 * @param classLoader ClassLoader to use 1085 * 1086 * @return Document object 1087 * 1088 * @throws XmlUtilitiesException on error 1089 */ 1090 public static Document loadDocumentFromResource(final String resource, final DocumentBuilder documentBuilder, final ClassLoader classLoader) throws XmlUtilitiesException { 1091 return loadDocumentFromResource(resource, documentBuilder, classLoader, INTERNAL_XMLUTILITIES); 1092 } 1093 1094 /** 1095 * Loads document from resource using specified ClassLoader. 1096 * 1097 * @param resource resource to load 1098 * @param classLoader ClassLoader to use 1099 * @param xmlUtilities custom XMLUtilities (can be null) 1100 * 1101 * @return Document object 1102 * 1103 * @throws XmlUtilitiesException on error 1104 */ 1105 public static Document loadDocumentFromResource(final String resource, final ClassLoader classLoader, final XmlUtilities xmlUtilities) throws XmlUtilitiesException { 1106 if (xmlUtilities != null) { 1107 return xmlUtilities.loadDocumentFromResource(resource, classLoader); 1108 } 1109 1110 if (XmlTools.xmlUtilities == null) { 1111 XmlTools.initializeXmlUtilities(); 1112 } 1113 1114 return XmlTools.xmlUtilities.loadDocumentFromResource(resource, classLoader); 1115 } 1116 1117 /** 1118 * Loads document from resource using specified ClassLoader. 1119 * 1120 * @param resource resource to load 1121 * @param documentBuilder custom DocumentBuilder 1122 * @param classLoader ClassLoader to use 1123 * @param xmlUtilities custom XMLUtilities (can be null) 1124 * 1125 * @return Document object 1126 * 1127 * @throws XmlUtilitiesException on error 1128 */ 1129 public static Document loadDocumentFromResource(final String resource, final DocumentBuilder documentBuilder, final ClassLoader classLoader, final XmlUtilities xmlUtilities) 1130 throws XmlUtilitiesException { 1131 if (xmlUtilities != null) { 1132 return xmlUtilities.loadDocumentFromResource(resource, documentBuilder, classLoader); 1133 } 1134 1135 if (XmlTools.xmlUtilities == null) { 1136 XmlTools.initializeXmlUtilities(); 1137 } 1138 1139 return XmlTools.xmlUtilities.loadDocumentFromResource(resource, documentBuilder, classLoader); 1140 } 1141 1142 /** 1143 * Returns DocumentBuilderFactory object internally used by the XMLUtilities static methods. 1144 * 1145 * @return DocumentBuilderFactory object 1146 */ 1147 public static DocumentBuilderFactory getInternalDocumentBuilderFactory() { 1148 if (xmlUtilities == null) { 1149 return null; 1150 } 1151 1152 return xmlUtilities.getDocumentBuilderFactory(); 1153 } 1154 1155 /** 1156 * Returns XPath object internally used by the XMLUtilities static methods. 1157 * 1158 * @return XPath object 1159 */ 1160 public static XPath getInternalXPath() { 1161 if (xmlUtilities == null) { 1162 return null; 1163 } 1164 1165 return xmlUtilities.getXPath(); 1166 } 1167 1168 /** 1169 * Transforms specified XML document using specified XSLT template. 1170 * 1171 * @param xsltTemplate template to use 1172 * @param document source XML document 1173 * 1174 * @return resulting document in the String 1175 * 1176 * @throws XmlUtilitiesException on error 1177 */ 1178 public static String transformToString(final Source xsltTemplate, final Source document) throws XmlUtilitiesException { 1179 return transformToString(xsltTemplate, document, XmlTools.INTERNAL_XMLUTILITIES); 1180 } 1181 1182 /** 1183 * Transforms specified XML document using specified XSLT template. 1184 * 1185 * @param xsltTemplate XSLT template 1186 * @param document source XML document 1187 * @param xmlUtilities custom {@code XMLUtilities} 1188 * 1189 * @return resulting XML document in the String 1190 * 1191 * @throws XmlUtilitiesException on error 1192 */ 1193 public static String transformToString(final Source xsltTemplate, final Source document, final XmlUtilities xmlUtilities) throws XmlUtilitiesException { 1194 return transformToString(xsltTemplate, document, null, xmlUtilities); 1195 } 1196 1197 /** 1198 * Transforms specified XML document using specified XSLT template. 1199 * 1200 * @param xsltTemplate XSLT template to use 1201 * @param document source XML document 1202 * @param parameters parameters for the XSLT processor 1203 * 1204 * @return resulting XML file in the String 1205 * 1206 * @throws XmlUtilitiesException on error 1207 */ 1208 public static String transformToString(final Source xsltTemplate, final Source document, final Map<String, Object> parameters) throws XmlUtilitiesException { 1209 return transformToString(xsltTemplate, document, parameters, XmlTools.INTERNAL_XMLUTILITIES); 1210 } 1211 1212 /** 1213 * Transforms specified XML document using specified XSLT template. 1214 * 1215 * @param xsltTemplate XSLT template to use 1216 * @param document source XML document 1217 * @param parameters parameters for the XSLT processor 1218 * @param xmlUtilities custom {@code XMLUtilities} to use 1219 * 1220 * @return resulting XML document in the String 1221 * 1222 * @throws XmlUtilitiesException on error 1223 */ 1224 public static String transformToString(final Source xsltTemplate, final Source document, final Map<String, Object> parameters, final XmlUtilities xmlUtilities) 1225 throws XmlUtilitiesException { 1226 if (xmlUtilities != null) { 1227 return xmlUtilities.transformToString(xsltTemplate, document, parameters); 1228 } 1229 1230 if (XmlTools.xmlUtilities == null) { 1231 XmlTools.initializeXmlUtilities(); 1232 } 1233 1234 return XmlTools.xmlUtilities.transformToString(xsltTemplate, document, parameters); 1235 } 1236 1237 /** 1238 * Transforms specified XML document using XSLT (compiled) template. 1239 * 1240 * @param xsltTemplate template to use 1241 * @param document XML document to transform 1242 * @param parameters parameters for the transformation 1243 * @param xmlUtilities custom {@code XMLUtilities} to use 1244 * 1245 * @return resulting XML document in the String 1246 * 1247 * @throws XmlUtilitiesException on error 1248 */ 1249 public static String transformToString(final Templates xsltTemplate, final Source document, final Map<String, Object> parameters, final XmlUtilities xmlUtilities) 1250 throws XmlUtilitiesException { 1251 if (xmlUtilities != null) { 1252 return xmlUtilities.transformToString(xsltTemplate, document, parameters); 1253 } 1254 1255 if (XmlTools.xmlUtilities == null) { 1256 XmlTools.initializeXmlUtilities(); 1257 } 1258 1259 return XmlTools.xmlUtilities.transformToString(xsltTemplate, document, parameters); 1260 } 1261 1262 /** 1263 * Transforms specified XML document using XSLT (compiled) template. 1264 * 1265 * @param xsltTemplate template to use 1266 * @param document XML document to transform 1267 * @param parameters parameters for the transformation 1268 * 1269 * @return resulting XML document in the String 1270 * 1271 * @throws XmlUtilitiesException on error 1272 */ 1273 public static String transformToString(final Templates xsltTemplate, final Source document, final Map<String, Object> parameters) throws XmlUtilitiesException { 1274 return transformToString(xsltTemplate, document, parameters, XmlTools.INTERNAL_XMLUTILITIES); 1275 } 1276 1277 /** 1278 * Transforms specified XML document using XSLT (compiled) template. 1279 * 1280 * @param xsltTemplate template to use 1281 * @param document XML document to transform 1282 * @param xmlUtilities custom {@code XMLUtilities} to use 1283 * 1284 * @return resulting XML in the String 1285 * 1286 * @throws XmlUtilitiesException on error 1287 */ 1288 public static String transformToString(final Templates xsltTemplate, final Source document, final XmlUtilities xmlUtilities) throws XmlUtilitiesException { 1289 return transformToString(xsltTemplate, document, null, xmlUtilities); 1290 } 1291 1292 /** 1293 * Transforms specified XML document using XSLT (compiled) template. 1294 * 1295 * @param xsltTemplate template to use 1296 * @param document XML document to transform 1297 * 1298 * @return resulting XML in the String 1299 * 1300 * @throws XmlUtilitiesException on error 1301 */ 1302 public static String transformToString(final Templates xsltTemplate, final Source document) throws XmlUtilitiesException { 1303 return transformToString(xsltTemplate, document, null, XmlTools.INTERNAL_XMLUTILITIES); 1304 } 1305 1306 /** 1307 * Transforms specified XML document using XSLT (compiled) template. 1308 * 1309 * @param xsltTemplate template to use 1310 * @param document XML document to transform 1311 * @param parameters parameters for the transformation 1312 * @param xmlUtilities custom {@code XMLUtilities} to use 1313 * 1314 * @return resulting XML in the {@code Document} 1315 * 1316 * @throws XmlUtilitiesException on error 1317 */ 1318 public static Document transformToDocument(final Templates xsltTemplate, final Source document, final Map<String, Object> parameters, final XmlUtilities xmlUtilities) 1319 throws XmlUtilitiesException { 1320 if (xmlUtilities != null) { 1321 return xmlUtilities.transformToDocument(xsltTemplate, document, parameters); 1322 } 1323 1324 if (XmlTools.xmlUtilities == null) { 1325 XmlTools.initializeXmlUtilities(); 1326 } 1327 1328 return XmlTools.xmlUtilities.transformToDocument(xsltTemplate, document, parameters); 1329 } 1330 1331 /** 1332 * Transforms specified XML document using XSLT (compiled) template. 1333 * 1334 * @param xsltTemplate template to use 1335 * @param document XML document to transform 1336 * @param parameters parameters for the transformation 1337 * 1338 * @return resulting XML in the {@code Document} 1339 * 1340 * @throws XmlUtilitiesException on error 1341 */ 1342 public static Document transformToDocument(final Templates xsltTemplate, final Source document, final Map<String, Object> parameters) throws XmlUtilitiesException { 1343 return transformToDocument(xsltTemplate, document, parameters, XmlTools.INTERNAL_XMLUTILITIES); 1344 } 1345 1346 /** 1347 * Transforms specified XML document using XSLT (compiled) template. 1348 * 1349 * @param xsltTemplate template to use 1350 * @param document XML document to transform 1351 * @param xmlUtilities custom {@code XMLUtilities} to use 1352 * 1353 * @return resulting XML in the {@code Document} 1354 * 1355 * @throws XmlUtilitiesException on error 1356 */ 1357 public static Document transformToDocument(final Templates xsltTemplate, final Source document, final XmlUtilities xmlUtilities) throws XmlUtilitiesException { 1358 return transformToDocument(xsltTemplate, document, null, xmlUtilities); 1359 } 1360 1361 /** 1362 * Transforms specified XML document using XSLT (compiled) template. 1363 * 1364 * @param xsltTemplate template to use 1365 * @param document XML document to transform 1366 * 1367 * @return resulting XML in the {@code Document} 1368 * 1369 * @throws XmlUtilitiesException on error 1370 */ 1371 public static Document transformToDocument(final Templates xsltTemplate, final Source document) throws XmlUtilitiesException { 1372 return transformToDocument(xsltTemplate, document, null, XmlTools.INTERNAL_XMLUTILITIES); 1373 } 1374 1375 /** 1376 * Loads document from String into the {@code Document}. 1377 * 1378 * @param source source XML 1379 * 1380 * @return resulting XML 1381 * 1382 * @throws XmlUtilitiesException on error 1383 */ 1384 public static Document loadDocumentFromString(final String source) throws XmlUtilitiesException { 1385 return loadDocumentFromString(source, INTERNAL_XMLUTILITIES); 1386 } 1387 1388 /** 1389 * Loads document from String into the {@code Document}. 1390 * 1391 * @param source source XML 1392 * @param xmlUtilities custom {@code XMLUtilities} to use 1393 * 1394 * @return resulting XML 1395 * 1396 * @throws XmlUtilitiesException on error 1397 */ 1398 public static Document loadDocumentFromString(final String source, final XmlUtilities xmlUtilities) throws XmlUtilitiesException { 1399 if (xmlUtilities != null) { 1400 return xmlUtilities.loadDocumentFromString(source); 1401 } 1402 1403 if (XmlTools.xmlUtilities == null) { 1404 initializeXmlUtilities(); 1405 } 1406 1407 return XmlTools.xmlUtilities.loadDocumentFromString(source); 1408 } 1409 1410 /** 1411 * Loads document from String into the {@code Document}. 1412 * 1413 * @param source source XML 1414 * @param documentBuilder custom document builder 1415 * 1416 * @return resulting XML 1417 * 1418 * @throws XmlUtilitiesException on error 1419 */ 1420 public static Document loadDocumentFromString(final String source, final DocumentBuilder documentBuilder) throws XmlUtilitiesException { 1421 return loadDocumentFromString(source, documentBuilder, INTERNAL_XMLUTILITIES); 1422 } 1423 1424 /** 1425 * Loads document from String into the {@code Document}. 1426 * 1427 * @param source source XML 1428 * @param documentBuilder custom DocumentBuilder to use 1429 * @param xmlUtilities custom {@code XMLUtilities} to use 1430 * 1431 * @return resulting XML 1432 * 1433 * @throws XmlUtilitiesException on error 1434 */ 1435 public static Document loadDocumentFromString(final String source, final DocumentBuilder documentBuilder, final XmlUtilities xmlUtilities) throws XmlUtilitiesException { 1436 if (xmlUtilities != null) { 1437 return xmlUtilities.loadDocumentFromString(source, documentBuilder); 1438 } 1439 1440 if (XmlTools.xmlUtilities == null) { 1441 initializeXmlUtilities(); 1442 } 1443 1444 return XmlTools.xmlUtilities.loadDocumentFromString(source, documentBuilder); 1445 } 1446 1447 /** 1448 * Converts XML Source into String. 1449 * 1450 * @param source source Document 1451 * 1452 * @return XML in the String 1453 * 1454 * @throws XmlUtilitiesException on error 1455 */ 1456 public static String sourceToString(final Source source) throws XmlUtilitiesException { 1457 return sourceToString(source, XmlTools.INTERNAL_XMLUTILITIES); 1458 } 1459 1460 /** 1461 * Converts XML Source into String. 1462 * 1463 * @param source source Document 1464 * @param xmlUtilities {@code XMLUtilities} to use 1465 * 1466 * @return XML in the String 1467 * 1468 * @throws XmlUtilitiesException on error 1469 */ 1470 public static String sourceToString(final Source source, final XmlUtilities xmlUtilities) throws XmlUtilitiesException { 1471 if (xmlUtilities != null) { 1472 return xmlUtilities.sourceToString(source); 1473 } 1474 1475 if (XmlTools.xmlUtilities == null) { 1476 XmlTools.initializeXmlUtilities(); 1477 } 1478 1479 return XmlTools.xmlUtilities.sourceToString(source); 1480 } 1481 1482 /** 1483 * Converts XML Source into String. 1484 * 1485 * @param source source Document 1486 * @param outputFormat output format configuration 1487 * 1488 * @return XML in the String 1489 * 1490 * @throws XmlUtilitiesException on error 1491 */ 1492 public static String sourceToString(final Source source, final OutputFormat outputFormat) throws XmlUtilitiesException { 1493 return sourceToString(source, outputFormat, INTERNAL_XMLUTILITIES); 1494 } 1495 1496 /** 1497 * Converts XML Source into String. 1498 * 1499 * @param source source Document 1500 * @param outputProperties output properties (see {@link OutputFormat OutputFormat}) 1501 * 1502 * @return XML in the String 1503 * 1504 * @throws XmlUtilitiesException on error 1505 */ 1506 public static String sourceToString(final Source source, final Properties outputProperties) throws XmlUtilitiesException { 1507 return sourceToString(source, outputProperties, INTERNAL_XMLUTILITIES); 1508 } 1509 1510 /** 1511 * Converts XML Source into String. 1512 * 1513 * @param source source Document 1514 * @param outputFormat output format configuration 1515 * @param xmlUtilities {@code XMLUtilities} to use 1516 * 1517 * @return XML in the String 1518 * 1519 * @throws XmlUtilitiesException on error 1520 */ 1521 public static String sourceToString(final Source source, final OutputFormat outputFormat, final XmlUtilities xmlUtilities) throws XmlUtilitiesException { 1522 if (xmlUtilities != null) { 1523 return xmlUtilities.sourceToString(source, outputFormat); 1524 } 1525 1526 if (XmlTools.xmlUtilities == null) { 1527 XmlTools.initializeXmlUtilities(); 1528 } 1529 1530 return XmlTools.xmlUtilities.sourceToString(source, outputFormat); 1531 } 1532 1533 /** 1534 * Converts XML Source into String. 1535 * 1536 * @param source source Document 1537 * @param outputProperties output properties (see {@link OutputFormat OutputFormat}) 1538 * @param xmlUtilities {@code XMLUtilities} to use 1539 * 1540 * @return XML in the String 1541 * 1542 * @throws XmlUtilitiesException on error 1543 */ 1544 public static String sourceToString(final Source source, final Properties outputProperties, final XmlUtilities xmlUtilities) throws XmlUtilitiesException { 1545 if (xmlUtilities != null) { 1546 return xmlUtilities.sourceToString(source, outputProperties); 1547 } 1548 1549 if (XmlTools.xmlUtilities == null) { 1550 XmlTools.initializeXmlUtilities(); 1551 } 1552 1553 return XmlTools.xmlUtilities.sourceToString(source, outputProperties); 1554 } 1555 1556 /** 1557 * Transforms specified XML using specified XSLT template. 1558 * 1559 * @param xsltTemplate XSLT template 1560 * @param document source XML document 1561 * @param parameters parameters for the template 1562 * @param xmlUtilities {@code XMLUtilities} to use 1563 * 1564 * @return resulting XML in the {@code Document} 1565 * 1566 * @throws XmlUtilitiesException on error 1567 */ 1568 public static Document transformToDocument(final Source xsltTemplate, final Source document, final Map<String, Object> parameters, final XmlUtilities xmlUtilities) 1569 throws XmlUtilitiesException { 1570 if (xmlUtilities != null) { 1571 return xmlUtilities.transformToDocument(xsltTemplate, document, parameters); 1572 } 1573 1574 if (XmlTools.xmlUtilities == null) { 1575 XmlTools.initializeXmlUtilities(); 1576 } 1577 1578 return XmlTools.xmlUtilities.transformToDocument(xsltTemplate, document, parameters); 1579 } 1580 1581 /** 1582 * Transforms specified XML using specified XSLT template. 1583 * 1584 * @param xsltTemplate XSLT template 1585 * @param document source XML document 1586 * @param parameters parameters for the template 1587 * 1588 * @return resulting XML in the {@code Document} 1589 * 1590 * @throws XmlUtilitiesException on error 1591 */ 1592 public static Document transformToDocument(final Source xsltTemplate, final Source document, final Map<String, Object> parameters) 1593 throws XmlUtilitiesException { 1594 return transformToDocument(xsltTemplate, document, parameters, INTERNAL_XMLUTILITIES); 1595 } 1596 1597 /** 1598 * Transforms specified XML using specified XSLT template. 1599 * 1600 * @param xsltTemplate XSLT template 1601 * @param document source XML document 1602 * @param xmlUtilities {@code XMLUtilities} to use 1603 * 1604 * @return resulting XML in the {@code Document} 1605 * 1606 * @throws XmlUtilitiesException on error 1607 */ 1608 public static Document transformToDocument(final Source xsltTemplate, final Source document, final XmlUtilities xmlUtilities) throws XmlUtilitiesException { 1609 if (xmlUtilities != null) { 1610 return xmlUtilities.transformToDocument(xsltTemplate, document); 1611 } 1612 1613 if (XmlTools.xmlUtilities == null) { 1614 XmlTools.initializeXmlUtilities(); 1615 } 1616 1617 return XmlTools.xmlUtilities.transformToDocument(xsltTemplate, document); 1618 } 1619 1620 /** 1621 * Transforms specified XML using specified XSLT template. 1622 * 1623 * @param xsltTemplate XSLT template 1624 * @param document source XML document 1625 * 1626 * @return resulting XML in the {@code Document} 1627 * 1628 * @throws XmlUtilitiesException on error 1629 */ 1630 public static Document transformToDocument(final Source xsltTemplate, final Source document) throws XmlUtilitiesException { 1631 return transformToDocument(xsltTemplate, document, INTERNAL_XMLUTILITIES); 1632 } 1633 1634 /** 1635 * Writes specified document into specified output stream. 1636 * 1637 * @param doc document 1638 * @param os output stream 1639 * 1640 * @throws XmlUtilitiesException on error 1641 */ 1642 public static void writeDocumentToStream(final Document doc, final OutputStream os) throws XmlUtilitiesException { 1643 writeDocumentToStream(doc, os, INTERNAL_XMLUTILITIES); 1644 } 1645 1646 /** 1647 * Writes specified document into specified output stream. 1648 * 1649 * @param doc document 1650 * @param os output stream 1651 * @param xmlUtilities XMLUtilities to use 1652 * 1653 * @throws XmlUtilitiesException on error 1654 */ 1655 public static void writeDocumentToStream(final Document doc, final OutputStream os, final XmlUtilities xmlUtilities) throws XmlUtilitiesException { 1656 if (xmlUtilities != null) { 1657 xmlUtilities.writeDocumentToStream(doc, os); 1658 } 1659 1660 if (XmlTools.xmlUtilities == null) { 1661 XmlTools.initializeXmlUtilities(); 1662 } 1663 1664 XmlTools.xmlUtilities.writeDocumentToStream(doc, os); 1665 } 1666 1667 /** 1668 * Writes specified document into specified stream and specified output format. 1669 * 1670 * @param doc document 1671 * @param os output stream 1672 * @param outputFormat output format 1673 * 1674 * @throws XmlUtilitiesException on error 1675 */ 1676 public static void writeDocumentToStream(final Document doc, final OutputStream os, final OutputFormat outputFormat) throws XmlUtilitiesException { 1677 writeDocumentToStream(doc, os, outputFormat, INTERNAL_XMLUTILITIES); 1678 } 1679 1680 /** 1681 * Writes specified document into specified stream and specified output format. 1682 * 1683 * @param doc document 1684 * @param os output stream 1685 * @param outputFormat output format 1686 * @param xmlUtilities XMLUtilities to use 1687 * 1688 * @throws XmlUtilitiesException on error 1689 */ 1690 public static void writeDocumentToStream(final Document doc, final OutputStream os, final OutputFormat outputFormat, final XmlUtilities xmlUtilities) 1691 throws XmlUtilitiesException { 1692 if (xmlUtilities != null) { 1693 xmlUtilities.writeDocumentToStream(doc, os, outputFormat); 1694 } 1695 1696 if (XmlTools.xmlUtilities == null) { 1697 XmlTools.initializeXmlUtilities(); 1698 } 1699 1700 XmlTools.xmlUtilities.writeDocumentToStream(doc, os, outputFormat); 1701 } 1702 1703 /** 1704 * Writes specified document into specified stream and specified output format properties. 1705 * 1706 * @param doc document 1707 * @param os output stream 1708 * @param outputProperties output format properties 1709 * 1710 * @throws XmlUtilitiesException on error 1711 */ 1712 public static void writeDocumentToStream(final Document doc, final OutputStream os, final Properties outputProperties) throws XmlUtilitiesException { 1713 writeDocumentToStream(doc, os, outputProperties, INTERNAL_XMLUTILITIES); 1714 } 1715 1716 /** 1717 * Writes specified document into specified stream and specified output format properties. 1718 * 1719 * @param doc document 1720 * @param os output stream 1721 * @param outputProperties output format properties 1722 * @param xmlUtilities XMLUtilities to use 1723 * 1724 * @throws XmlUtilitiesException on error 1725 */ 1726 public static void writeDocumentToStream(final Document doc, final OutputStream os, final Properties outputProperties, final XmlUtilities xmlUtilities) 1727 throws XmlUtilitiesException { 1728 if (xmlUtilities != null) { 1729 xmlUtilities.writeDocumentToStream(doc, os, outputProperties); 1730 } 1731 1732 if (XmlTools.xmlUtilities == null) { 1733 XmlTools.initializeXmlUtilities(); 1734 } 1735 1736 XmlTools.xmlUtilities.writeDocumentToStream(doc, os, outputProperties); 1737 } 1738 1739 /** 1740 * Writes specified document into specified stream and specified {@link Transformer Transformer}. 1741 * 1742 * @param doc document 1743 * @param os output stream 1744 * @param transformer Transformer to use 1745 * 1746 * @throws XmlUtilitiesException on error 1747 */ 1748 public static void writeDocumentToStream(final Document doc, final OutputStream os, final Transformer transformer) throws XmlUtilitiesException { 1749 writeDocumentToStream(doc, os, transformer, INTERNAL_XMLUTILITIES); 1750 } 1751 1752 /** 1753 * Writes specified document into specified stream and specified {@link Transformer Transformer}. 1754 * 1755 * @param doc document 1756 * @param os output stream 1757 * @param transformer Transformer to use 1758 * @param xmlUtilities XMLUtilities to use 1759 * 1760 * @throws XmlUtilitiesException on error 1761 */ 1762 public static void writeDocumentToStream(final Document doc, final OutputStream os, final Transformer transformer, final XmlUtilities xmlUtilities) 1763 throws XmlUtilitiesException { 1764 if (xmlUtilities != null) { 1765 xmlUtilities.writeDocumentToStream(doc, os, transformer); 1766 } 1767 1768 if (XmlTools.xmlUtilities == null) { 1769 XmlTools.initializeXmlUtilities(); 1770 } 1771 1772 XmlTools.xmlUtilities.writeDocumentToStream(doc, os, transformer); 1773 } 1774 1775 /** 1776 * Writes Document to specified file. 1777 * 1778 * @param doc document 1779 * @param file target file 1780 * 1781 * @throws XmlUtilitiesException on error 1782 */ 1783 public static void writeDocumentToFile(final Document doc, final String file) throws XmlUtilitiesException { 1784 writeDocumentToFile(doc, file, INTERNAL_XMLUTILITIES); 1785 } 1786 1787 /** 1788 * Writes Document to specified file. 1789 * 1790 * @param doc document 1791 * @param file target file 1792 * @param outputFormat output format 1793 * 1794 * @throws XmlUtilitiesException on error 1795 */ 1796 public static void writeDocumentToFile(final Document doc, final String file, final OutputFormat outputFormat) throws XmlUtilitiesException { 1797 writeDocumentToFile(doc, file, outputFormat, INTERNAL_XMLUTILITIES); 1798 } 1799 1800 /** 1801 * Writes Document to specified file. 1802 * 1803 * @param doc document 1804 * @param file target file 1805 * @param outputProperties output format properties 1806 * 1807 * @throws XmlUtilitiesException on error 1808 */ 1809 public static void writeDocumentToFile(final Document doc, final String file, final Properties outputProperties) throws XmlUtilitiesException { 1810 writeDocumentToFile(doc, file, outputProperties, INTERNAL_XMLUTILITIES); 1811 } 1812 1813 /** 1814 * Writes Document to specified file. 1815 * 1816 * @param doc document 1817 * @param file target file 1818 * @param transformer transformer 1819 * 1820 * @throws XmlUtilitiesException on error 1821 */ 1822 public static void writeDocumentToFile(final Document doc, final String file, final Transformer transformer) throws XmlUtilitiesException { 1823 writeDocumentToFile(doc, file, transformer, INTERNAL_XMLUTILITIES); 1824 } 1825 1826 /** 1827 * Writes Document to specified file using internal buffer. 1828 * 1829 * @param doc document 1830 * @param file target file 1831 * @param bufferSize buffer size or {@code null} for default 1832 * 1833 * @throws XmlUtilitiesException on error 1834 */ 1835 public static void writeDocumentToFile(final Document doc, final String file, final Integer bufferSize) throws XmlUtilitiesException { 1836 writeDocumentToFile(doc, file, bufferSize, INTERNAL_XMLUTILITIES); 1837 } 1838 1839 /** 1840 * Writes Document to specified file using internal buffer. 1841 * 1842 * @param doc document 1843 * @param file target file 1844 * @param bufferSize buffer size or {@code null} for default 1845 * @param outputFormat output format 1846 * 1847 * @throws XmlUtilitiesException on error 1848 */ 1849 public static void writeDocumentToFile(final Document doc, final String file, final Integer bufferSize, final OutputFormat outputFormat) throws XmlUtilitiesException { 1850 writeDocumentToFile(doc, file, bufferSize, outputFormat, INTERNAL_XMLUTILITIES); 1851 } 1852 1853 /** 1854 * Writes Document to specified file using internal buffer. 1855 * 1856 * @param doc document 1857 * @param file target file 1858 * @param bufferSize buffer size or {@code null} for default 1859 * @param outputProperties output format properties 1860 * 1861 * @throws XmlUtilitiesException on error 1862 */ 1863 public static void writeDocumentToFile(final Document doc, final String file, final Integer bufferSize, final Properties outputProperties) throws XmlUtilitiesException { 1864 writeDocumentToFile(doc, file, bufferSize, outputProperties, INTERNAL_XMLUTILITIES); 1865 } 1866 1867 /** 1868 * Writes Document to specified file using internal buffer. 1869 * 1870 * @param doc document 1871 * @param file target file 1872 * @param bufferSize buffer size or {@code null} for default 1873 * @param transformer transformer 1874 * 1875 * @throws XmlUtilitiesException on error 1876 */ 1877 public static void writeDocumentToFile(final Document doc, final String file, final Integer bufferSize, final Transformer transformer) throws XmlUtilitiesException { 1878 writeDocumentToFile(doc, file, bufferSize, transformer, INTERNAL_XMLUTILITIES); 1879 } 1880 1881 /** 1882 * Writes Document to specified file. 1883 * 1884 * @param doc document 1885 * @param file target file 1886 * @param xmlUtilities XML Utilities to use 1887 * 1888 * @throws XmlUtilitiesException on error 1889 */ 1890 public static void writeDocumentToFile(final Document doc, final String file, final XmlUtilities xmlUtilities) throws XmlUtilitiesException { 1891 if (xmlUtilities != null) { 1892 xmlUtilities.writeDocumentToFile(doc, file); 1893 } 1894 1895 if (XmlTools.xmlUtilities == null) { 1896 XmlTools.initializeXmlUtilities(); 1897 } 1898 1899 XmlTools.xmlUtilities.writeDocumentToFile(doc, file); 1900 } 1901 1902 /** 1903 * Writes Document to specified file. 1904 * 1905 * @param doc document 1906 * @param file target file 1907 * @param outputFormat output format 1908 * @param xmlUtilities XML Utilities to use 1909 * 1910 * @throws XmlUtilitiesException on error 1911 */ 1912 public static void writeDocumentToFile(final Document doc, final String file, final OutputFormat outputFormat, final XmlUtilities xmlUtilities) 1913 throws XmlUtilitiesException { 1914 if (xmlUtilities != null) { 1915 xmlUtilities.writeDocumentToFile(doc, file, outputFormat); 1916 } 1917 1918 if (XmlTools.xmlUtilities == null) { 1919 XmlTools.initializeXmlUtilities(); 1920 } 1921 1922 XmlTools.xmlUtilities.writeDocumentToFile(doc, file, outputFormat); 1923 } 1924 1925 /** 1926 * Writes Document to specified file. 1927 * 1928 * @param doc document 1929 * @param file target file 1930 * @param outputProperties output format properties 1931 * @param xmlUtilities XML Utilities to use 1932 * 1933 * @throws XmlUtilitiesException on error 1934 */ 1935 public static void writeDocumentToFile(final Document doc, final String file, final Properties outputProperties, final XmlUtilities xmlUtilities) 1936 throws XmlUtilitiesException { 1937 if (xmlUtilities != null) { 1938 xmlUtilities.writeDocumentToFile(doc, file, outputProperties); 1939 } 1940 1941 if (XmlTools.xmlUtilities == null) { 1942 XmlTools.initializeXmlUtilities(); 1943 } 1944 1945 XmlTools.xmlUtilities.writeDocumentToFile(doc, file, outputProperties); 1946 } 1947 1948 /** 1949 * Writes Document to specified file. 1950 * 1951 * @param doc document 1952 * @param file target file 1953 * @param transformer transformer 1954 * @param xmlUtilities XML Utilities to use 1955 * 1956 * @throws XmlUtilitiesException on error 1957 */ 1958 public static void writeDocumentToFile(final Document doc, final String file, final Transformer transformer, final XmlUtilities xmlUtilities) throws XmlUtilitiesException { 1959 if (xmlUtilities != null) { 1960 xmlUtilities.writeDocumentToFile(doc, file, transformer); 1961 } 1962 1963 if (XmlTools.xmlUtilities == null) { 1964 XmlTools.initializeXmlUtilities(); 1965 } 1966 1967 XmlTools.xmlUtilities.writeDocumentToFile(doc, file, transformer); 1968 } 1969 1970 /** 1971 * Writes Document to specified file using internal buffer. 1972 * 1973 * @param doc document 1974 * @param file target file 1975 * @param bufferSize buffer size or {@code null} for default 1976 * @param xmlUtilities XML Utilities to use 1977 * 1978 * @throws XmlUtilitiesException on error 1979 */ 1980 public static void writeDocumentToFile(final Document doc, final String file, final Integer bufferSize, final XmlUtilities xmlUtilities) throws XmlUtilitiesException { 1981 if (xmlUtilities != null) { 1982 xmlUtilities.writeDocumentToFile(doc, file, bufferSize); 1983 } 1984 1985 if (XmlTools.xmlUtilities == null) { 1986 XmlTools.initializeXmlUtilities(); 1987 } 1988 1989 XmlTools.xmlUtilities.writeDocumentToFile(doc, file, bufferSize); 1990 } 1991 1992 /** 1993 * Writes Document to specified file using internal buffer. 1994 * 1995 * @param doc document 1996 * @param file target file 1997 * @param bufferSize buffer size or {@code null} for default 1998 * @param outputFormat output format 1999 * @param xmlUtilities XML Utilities to use 2000 * 2001 * @throws XmlUtilitiesException on error 2002 */ 2003 public static void writeDocumentToFile(final Document doc, final String file, final Integer bufferSize, final OutputFormat outputFormat, final XmlUtilities xmlUtilities) 2004 throws XmlUtilitiesException { 2005 if (xmlUtilities != null) { 2006 xmlUtilities.writeDocumentToFile(doc, file, bufferSize, outputFormat); 2007 } 2008 2009 if (XmlTools.xmlUtilities == null) { 2010 XmlTools.initializeXmlUtilities(); 2011 } 2012 2013 XmlTools.xmlUtilities.writeDocumentToFile(doc, file, bufferSize, outputFormat); 2014 } 2015 2016 /** 2017 * Writes Document to specified file using internal buffer. 2018 * 2019 * @param doc document 2020 * @param file target file 2021 * @param bufferSize buffer size or {@code null} for default 2022 * @param outputProperties output format properties 2023 * @param xmlUtilities XML Utilities to use 2024 * 2025 * @throws XmlUtilitiesException on error 2026 */ 2027 public static void writeDocumentToFile(final Document doc, final String file, final Integer bufferSize, final Properties outputProperties, final XmlUtilities xmlUtilities) 2028 throws XmlUtilitiesException { 2029 if (xmlUtilities != null) { 2030 xmlUtilities.writeDocumentToFile(doc, file, bufferSize, outputProperties); 2031 } 2032 2033 if (XmlTools.xmlUtilities == null) { 2034 XmlTools.initializeXmlUtilities(); 2035 } 2036 2037 XmlTools.xmlUtilities.writeDocumentToFile(doc, file, bufferSize, outputProperties); 2038 } 2039 2040 /** 2041 * Writes Document to specified file using internal buffer. 2042 * 2043 * @param doc document 2044 * @param file target file 2045 * @param bufferSize buffer size or {@code null} for default 2046 * @param transformer transformer 2047 * @param xmlUtilities XML Utilities to use 2048 * 2049 * @throws XmlUtilitiesException on error 2050 */ 2051 public static void writeDocumentToFile(final Document doc, final String file, final Integer bufferSize, final Transformer transformer, final XmlUtilities xmlUtilities) 2052 throws XmlUtilitiesException { 2053 if (xmlUtilities != null) { 2054 xmlUtilities.writeDocumentToFile(doc, file, bufferSize, transformer); 2055 } 2056 2057 if (XmlTools.xmlUtilities == null) { 2058 XmlTools.initializeXmlUtilities(); 2059 } 2060 2061 XmlTools.xmlUtilities.writeDocumentToFile(doc, file, bufferSize, transformer); 2062 } 2063 2064 /** 2065 * Writes Document to specified file. 2066 * 2067 * @param doc document 2068 * @param file target file 2069 * 2070 * @throws XmlUtilitiesException on error 2071 */ 2072 public static void writeDocumentToFile(final Document doc, final File file) throws XmlUtilitiesException { 2073 writeDocumentToFile(doc, file, INTERNAL_XMLUTILITIES); 2074 } 2075 2076 /** 2077 * Writes Document to specified file. 2078 * 2079 * @param doc document 2080 * @param file target file 2081 * @param outputFormat output format 2082 * 2083 * @throws XmlUtilitiesException on error 2084 */ 2085 public static void writeDocumentToFile(final Document doc, final File file, final OutputFormat outputFormat) throws XmlUtilitiesException { 2086 writeDocumentToFile(doc, file, outputFormat, INTERNAL_XMLUTILITIES); 2087 } 2088 2089 /** 2090 * Writes Document to specified file. 2091 * 2092 * @param doc document 2093 * @param file target file 2094 * @param outputProperties output format properties 2095 * 2096 * @throws XmlUtilitiesException on error 2097 */ 2098 public static void writeDocumentToFile(final Document doc, final File file, final Properties outputProperties) throws XmlUtilitiesException { 2099 writeDocumentToFile(doc, file, outputProperties, INTERNAL_XMLUTILITIES); 2100 } 2101 2102 /** 2103 * Writes Document to specified file. 2104 * 2105 * @param doc document 2106 * @param file target file 2107 * @param transformer transformer 2108 * 2109 * @throws XmlUtilitiesException on error 2110 */ 2111 public static void writeDocumentToFile(final Document doc, final File file, final Transformer transformer) throws XmlUtilitiesException { 2112 writeDocumentToFile(doc, file, transformer, INTERNAL_XMLUTILITIES); 2113 } 2114 2115 /** 2116 * Writes Document to specified file using internal buffer. 2117 * 2118 * @param doc document 2119 * @param file target file 2120 * @param bufferSize buffer size or {@code null} for default 2121 * 2122 * @throws XmlUtilitiesException on error 2123 */ 2124 public static void writeDocumentToFile(final Document doc, final File file, final Integer bufferSize) throws XmlUtilitiesException { 2125 writeDocumentToFile(doc, file, bufferSize, INTERNAL_XMLUTILITIES); 2126 } 2127 2128 /** 2129 * Writes Document to specified file using internal buffer. 2130 * 2131 * @param doc document 2132 * @param file target file 2133 * @param bufferSize buffer size or {@code null} for default 2134 * @param outputFormat output format 2135 * 2136 * @throws XmlUtilitiesException on error 2137 */ 2138 public static void writeDocumentToFile(final Document doc, final File file, final Integer bufferSize, final OutputFormat outputFormat) throws XmlUtilitiesException { 2139 writeDocumentToFile(doc, file, bufferSize, outputFormat, INTERNAL_XMLUTILITIES); 2140 } 2141 2142 /** 2143 * Writes Document to specified file using internal buffer. 2144 * 2145 * @param doc document 2146 * @param file target file 2147 * @param bufferSize buffer size or {@code null} for default 2148 * @param outputProperties output format properties 2149 * 2150 * @throws XmlUtilitiesException on error 2151 */ 2152 public static void writeDocumentToFile(final Document doc, final File file, final Integer bufferSize, final Properties outputProperties) throws XmlUtilitiesException { 2153 writeDocumentToFile(doc, file, bufferSize, outputProperties, INTERNAL_XMLUTILITIES); 2154 } 2155 2156 /** 2157 * Writes Document to specified file using internal buffer. 2158 * 2159 * @param doc document 2160 * @param file target file 2161 * @param bufferSize buffer size or {@code null} for default 2162 * @param transformer transformer 2163 * 2164 * @throws XmlUtilitiesException on error 2165 */ 2166 public static void writeDocumentToFile(final Document doc, final File file, final Integer bufferSize, final Transformer transformer) throws XmlUtilitiesException { 2167 writeDocumentToFile(doc, file, bufferSize, transformer, INTERNAL_XMLUTILITIES); 2168 } 2169 2170 /** 2171 * Writes Document to specified file. 2172 * 2173 * @param doc document 2174 * @param file target file 2175 * @param xmlUtilities XML Utilities to use 2176 * 2177 * @throws XmlUtilitiesException on error 2178 */ 2179 public static void writeDocumentToFile(final Document doc, final File file, final XmlUtilities xmlUtilities) throws XmlUtilitiesException { 2180 if (xmlUtilities != null) { 2181 xmlUtilities.writeDocumentToFile(doc, file); 2182 } 2183 2184 if (XmlTools.xmlUtilities == null) { 2185 XmlTools.initializeXmlUtilities(); 2186 } 2187 2188 XmlTools.xmlUtilities.writeDocumentToFile(doc, file); 2189 } 2190 2191 /** 2192 * Writes Document to specified file. 2193 * 2194 * @param doc document 2195 * @param file target file 2196 * @param outputFormat output format 2197 * @param xmlUtilities XML Utilities to use 2198 * 2199 * @throws XmlUtilitiesException on error 2200 */ 2201 public static void writeDocumentToFile(final Document doc, final File file, final OutputFormat outputFormat, final XmlUtilities xmlUtilities) 2202 throws XmlUtilitiesException { 2203 if (xmlUtilities != null) { 2204 xmlUtilities.writeDocumentToFile(doc, file, outputFormat); 2205 } 2206 2207 if (XmlTools.xmlUtilities == null) { 2208 XmlTools.initializeXmlUtilities(); 2209 } 2210 2211 XmlTools.xmlUtilities.writeDocumentToFile(doc, file, outputFormat); 2212 } 2213 2214 /** 2215 * Writes Document to specified file. 2216 * 2217 * @param doc document 2218 * @param file target file 2219 * @param outputProperties output format properties 2220 * @param xmlUtilities XML Utilities to use 2221 * 2222 * @throws XmlUtilitiesException on error 2223 */ 2224 public static void writeDocumentToFile(final Document doc, final File file, final Properties outputProperties, final XmlUtilities xmlUtilities) 2225 throws XmlUtilitiesException { 2226 if (xmlUtilities != null) { 2227 xmlUtilities.writeDocumentToFile(doc, file, outputProperties); 2228 } 2229 2230 if (XmlTools.xmlUtilities == null) { 2231 XmlTools.initializeXmlUtilities(); 2232 } 2233 2234 XmlTools.xmlUtilities.writeDocumentToFile(doc, file, outputProperties); 2235 } 2236 2237 /** 2238 * Writes Document to specified file. 2239 * 2240 * @param doc document 2241 * @param file target file 2242 * @param transformer transformer 2243 * @param xmlUtilities XML Utilities to use 2244 * 2245 * @throws XmlUtilitiesException on error 2246 */ 2247 public static void writeDocumentToFile(final Document doc, final File file, final Transformer transformer, final XmlUtilities xmlUtilities) throws XmlUtilitiesException { 2248 if (xmlUtilities != null) { 2249 xmlUtilities.writeDocumentToFile(doc, file, transformer); 2250 } 2251 2252 if (XmlTools.xmlUtilities == null) { 2253 XmlTools.initializeXmlUtilities(); 2254 } 2255 2256 XmlTools.xmlUtilities.writeDocumentToFile(doc, file, transformer); 2257 } 2258 2259 /** 2260 * Writes Document to specified file using internal buffer. 2261 * 2262 * @param doc document 2263 * @param file target file 2264 * @param bufferSize buffer size or {@code null} for default 2265 * @param xmlUtilities XML Utilities to use 2266 * 2267 * @throws XmlUtilitiesException on error 2268 */ 2269 public static void writeDocumentToFile(final Document doc, final File file, final Integer bufferSize, final XmlUtilities xmlUtilities) throws XmlUtilitiesException { 2270 if (xmlUtilities != null) { 2271 xmlUtilities.writeDocumentToFile(doc, file, bufferSize); 2272 } 2273 2274 if (XmlTools.xmlUtilities == null) { 2275 XmlTools.initializeXmlUtilities(); 2276 } 2277 2278 XmlTools.xmlUtilities.writeDocumentToFile(doc, file, bufferSize); 2279 } 2280 2281 /** 2282 * Writes Document to specified file using internal buffer. 2283 * 2284 * @param doc document 2285 * @param file target file 2286 * @param bufferSize buffer size or {@code null} for default 2287 * @param outputFormat output format 2288 * @param xmlUtilities XML Utilities to use 2289 * 2290 * @throws XmlUtilitiesException on error 2291 */ 2292 public static void writeDocumentToFile(final Document doc, final File file, final Integer bufferSize, final OutputFormat outputFormat, final XmlUtilities xmlUtilities) 2293 throws XmlUtilitiesException { 2294 if (xmlUtilities != null) { 2295 xmlUtilities.writeDocumentToFile(doc, file, bufferSize, outputFormat); 2296 } 2297 2298 if (XmlTools.xmlUtilities == null) { 2299 XmlTools.initializeXmlUtilities(); 2300 } 2301 2302 XmlTools.xmlUtilities.writeDocumentToFile(doc, file, bufferSize, outputFormat); 2303 } 2304 2305 /** 2306 * Writes Document to specified file using internal buffer. 2307 * 2308 * @param doc document 2309 * @param file target file 2310 * @param bufferSize buffer size or {@code null} for default 2311 * @param outputProperties output format properties 2312 * @param xmlUtilities XML Utilities to use 2313 * 2314 * @throws XmlUtilitiesException on error 2315 */ 2316 public static void writeDocumentToFile(final Document doc, final File file, final Integer bufferSize, final Properties outputProperties, final XmlUtilities xmlUtilities) 2317 throws XmlUtilitiesException { 2318 if (xmlUtilities != null) { 2319 xmlUtilities.writeDocumentToFile(doc, file, bufferSize, outputProperties); 2320 } 2321 2322 if (XmlTools.xmlUtilities == null) { 2323 XmlTools.initializeXmlUtilities(); 2324 } 2325 2326 XmlTools.xmlUtilities.writeDocumentToFile(doc, file, bufferSize, outputProperties); 2327 } 2328 2329 /** 2330 * Writes Document to specified file using internal buffer. 2331 * 2332 * @param doc document 2333 * @param file target file 2334 * @param bufferSize buffer size or {@code null} for default 2335 * @param transformer transformer 2336 * @param xmlUtilities XML Utilities to use 2337 * 2338 * @throws XmlUtilitiesException on error 2339 */ 2340 public static void writeDocumentToFile(final Document doc, final File file, final Integer bufferSize, final Transformer transformer, final XmlUtilities xmlUtilities) 2341 throws XmlUtilitiesException { 2342 if (xmlUtilities != null) { 2343 xmlUtilities.writeDocumentToFile(doc, file, bufferSize, transformer); 2344 } 2345 2346 if (XmlTools.xmlUtilities == null) { 2347 XmlTools.initializeXmlUtilities(); 2348 } 2349 2350 XmlTools.xmlUtilities.writeDocumentToFile(doc, file, bufferSize, transformer); 2351 } 2352 2353 /** 2354 * Loads XML from String. 2355 * 2356 * @param source source string 2357 * 2358 * @return XML in the {@link Source Source} 2359 */ 2360 public static Source loadSourceFromString(final String source) { 2361 return new StreamSource(new StringReader(source)); 2362 } 2363 2364 /** 2365 * Loads XML from String. 2366 * 2367 * @param source source string 2368 * @param systemId system ID 2369 * 2370 * @return XML in the {@link Source Source} 2371 */ 2372 public static Source loadSourceFromString(final String source, final String systemId) { 2373 return new StreamSource(new StringReader(source), systemId); 2374 } 2375 2376 /** 2377 * Disables logging of {@code XmlTools} and {@code XmlUtilities}. 2378 */ 2379 public static void disableLogging() { 2380 disableLogging0(); 2381 XmlUtilities.disableLogging0(); 2382 } 2383 2384 /** 2385 * Disables logging. 2386 */ 2387 static void disableLogging0() { 2388 setLoggingLevel0(Level.OFF); 2389 } 2390 2391 /** 2392 * Sets new logging level of {@code XmlTools} and {@code XmlUtilities}. 2393 * 2394 * @param newLevel level to set 2395 */ 2396 public static void setLoggingLevel(final Level newLevel) { 2397 setLoggingLevel0(newLevel); 2398 XmlUtilities.setLoggingLevel0(newLevel); 2399 } 2400 2401 /** 2402 * Sets new logging level. 2403 * 2404 * @param newLevel level to set 2405 */ 2406 static void setLoggingLevel0(final Level newLevel) { 2407 LOGGER.setLevel(newLevel); 2408 } 2409 2410 /** 2411 * Utility class. 2412 */ 2413 private XmlTools() { 2414 throw new AssertionError(String.format("No instance of %s for you!", XmlTools.class.getName())); 2415 } 2416 2417 }