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    }