001package org.hl7.fhir.utilities.xml;
002
003/*
004  Copyright (c) 2011+, HL7, Inc.
005  All rights reserved.
006  
007  Redistribution and use in source and binary forms, with or without modification, 
008  are permitted provided that the following conditions are met:
009    
010   * Redistributions of source code must retain the above copyright notice, this 
011     list of conditions and the following disclaimer.
012   * Redistributions in binary form must reproduce the above copyright notice, 
013     this list of conditions and the following disclaimer in the documentation 
014     and/or other materials provided with the distribution.
015   * Neither the name of HL7 nor the names of its contributors may be used to 
016     endorse or promote products derived from this software without specific 
017     prior written permission.
018  
019  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 
020  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
021  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
022  IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 
023  INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 
024  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 
025  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
026  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
027  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
028  POSSIBILITY OF SUCH DAMAGE.
029  
030 */
031
032
033
034import java.io.ByteArrayInputStream;
035import java.io.FileInputStream;
036import java.io.IOException;
037import java.io.InputStream;
038import java.io.InputStreamReader;
039import java.io.OutputStream;
040import java.util.ArrayList;
041import java.util.List;
042import java.util.Set;
043
044import javax.xml.XMLConstants;
045import javax.xml.parsers.*;
046import javax.xml.transform.Result;
047import javax.xml.transform.Source;
048import javax.xml.transform.Transformer;
049import javax.xml.transform.TransformerException;
050import javax.xml.transform.TransformerFactory;
051import javax.xml.transform.dom.DOMSource;
052import javax.xml.transform.stream.StreamResult;
053
054import org.hl7.fhir.exceptions.FHIRException;
055import org.hl7.fhir.utilities.Utilities;
056import org.hl7.fhir.utilities.filesystem.ManagedFileAccess;
057import org.w3c.dom.Attr;
058import org.w3c.dom.Document;
059import org.w3c.dom.Element;
060import org.w3c.dom.Node;
061import org.w3c.dom.NodeList;
062import org.w3c.dom.ls.DOMImplementationLS;
063import org.w3c.dom.ls.LSSerializer;
064import org.xml.sax.SAXException;
065import org.xml.sax.SAXNotRecognizedException;
066import org.xml.sax.SAXNotSupportedException;
067import org.xml.sax.XMLReader;
068
069public class XMLUtil {
070
071        public static final String SPACE_CHAR = "\u00A0";
072  public static final String SAX_FEATURES_EXTERNAL_GENERAL_ENTITIES = "http://xml.org/sax/features/external-general-entities";
073  public static final String APACHE_XML_FEATURES_DISALLOW_DOCTYPE_DECL = "http://apache.org/xml/features/disallow-doctype-decl";
074
075  public static boolean isNMToken(String name) {
076                if (name == null)
077                        return false;
078                for (int i = 0; i < name.length(); i++) 
079                        if (!isNMTokenChar(name.charAt(i)))
080                                return false;   
081                return name.length() > 0;
082        }
083
084        public static boolean isNMTokenChar(char c) {
085                return isLetter(c) || isDigit(c) || c == '.' || c == '-' || c == '_' || c == ':' || isCombiningChar(c) || isExtender(c);
086        }
087
088        private static boolean isDigit(char c) {
089                return (c >= '\u0030' && c <= '\u0039') || (c >= '\u0660' && c <= '\u0669') || (c >= '\u06F0' && c <= '\u06F9') || 
090                        (c >= '\u0966' && c <= '\u096F') || (c >= '\u09E6' && c <= '\u09EF') || (c >= '\u0A66' && c <= '\u0A6F') || 
091                        (c >= '\u0AE6' && c <= '\u0AEF') || (c >= '\u0B66' && c <= '\u0B6F') || (c >= '\u0BE7' && c <= '\u0BEF') || 
092                        (c >= '\u0C66' && c <= '\u0C6F') || (c >= '\u0CE6' && c <= '\u0CEF') || (c >= '\u0D66' && c <= '\u0D6F') || 
093                        (c >= '\u0E50' && c <= '\u0E59') || (c >= '\u0ED0' && c <= '\u0ED9') || (c >= '\u0F20' && c <= '\u0F29');
094        }
095
096        private static boolean isCombiningChar(char c) {
097                return (c >= '\u0300' && c <= '\u0345') || (c >= '\u0360' && c <= '\u0361') || (c >= '\u0483' && c <= '\u0486') || 
098                        (c >= '\u0591' && c <= '\u05A1') || (c >= '\u05A3' && c <= '\u05B9') || (c >= '\u05BB' && c <= '\u05BD') || 
099                        c == '\u05BF' || (c >= '\u05C1' && c <= '\u05C2') || c == '\u05C4' || (c >= '\u064B' && c <= '\u0652') || 
100                        c == '\u0670' || (c >= '\u06D6' && c <= '\u06DC') || (c >= '\u06DD' && c <= '\u06DF') || (c >= '\u06E0' && c <= '\u06E4') || 
101                        (c >= '\u06E7' && c <= '\u06E8') || (c >= '\u06EA' && c <= '\u06ED') || (c >= '\u0901' && c <= '\u0903') || c == '\u093C' || 
102                        (c >= '\u093E' && c <= '\u094C') || c == '\u094D' || (c >= '\u0951' && c <= '\u0954') || (c >= '\u0962' && c <= '\u0963') || 
103                        (c >= '\u0981' && c <= '\u0983') || c == '\u09BC' || c == '\u09BE' || c == '\u09BF' || (c >= '\u09C0' && c <= '\u09C4') || 
104                        (c >= '\u09C7' && c <= '\u09C8') || (c >= '\u09CB' && c <= '\u09CD') || c == '\u09D7' || (c >= '\u09E2' && c <= '\u09E3') || 
105                        c == '\u0A02' || c == '\u0A3C' || c == '\u0A3E' || c == '\u0A3F' || (c >= '\u0A40' && c <= '\u0A42') || 
106                        (c >= '\u0A47' && c <= '\u0A48') || (c >= '\u0A4B' && c <= '\u0A4D') || (c >= '\u0A70' && c <= '\u0A71') || 
107                        (c >= '\u0A81' && c <= '\u0A83') || c == '\u0ABC' || (c >= '\u0ABE' && c <= '\u0AC5') || (c >= '\u0AC7' && c <= '\u0AC9') || 
108                        (c >= '\u0ACB' && c <= '\u0ACD') || (c >= '\u0B01' && c <= '\u0B03') || c == '\u0B3C' || (c >= '\u0B3E' && c <= '\u0B43') || 
109                        (c >= '\u0B47' && c <= '\u0B48') || (c >= '\u0B4B' && c <= '\u0B4D') || (c >= '\u0B56' && c <= '\u0B57') || 
110                        (c >= '\u0B82' && c <= '\u0B83') || (c >= '\u0BBE' && c <= '\u0BC2') || (c >= '\u0BC6' && c <= '\u0BC8') || 
111                        (c >= '\u0BCA' && c <= '\u0BCD') || c == '\u0BD7' || (c >= '\u0C01' && c <= '\u0C03') || (c >= '\u0C3E' && c <= '\u0C44') || 
112                        (c >= '\u0C46' && c <= '\u0C48') || (c >= '\u0C4A' && c <= '\u0C4D') || (c >= '\u0C55' && c <= '\u0C56') || 
113                        (c >= '\u0C82' && c <= '\u0C83') || (c >= '\u0CBE' && c <= '\u0CC4') || (c >= '\u0CC6' && c <= '\u0CC8') || 
114                        (c >= '\u0CCA' && c <= '\u0CCD') || (c >= '\u0CD5' && c <= '\u0CD6') || (c >= '\u0D02' && c <= '\u0D03') || 
115                        (c >= '\u0D3E' && c <= '\u0D43') || (c >= '\u0D46' && c <= '\u0D48') || (c >= '\u0D4A' && c <= '\u0D4D') || c == '\u0D57' || 
116                        c == '\u0E31' || (c >= '\u0E34' && c <= '\u0E3A') || (c >= '\u0E47' && c <= '\u0E4E') || c == '\u0EB1' || 
117                        (c >= '\u0EB4' && c <= '\u0EB9') || (c >= '\u0EBB' && c <= '\u0EBC') || (c >= '\u0EC8' && c <= '\u0ECD') || 
118                        (c >= '\u0F18' && c <= '\u0F19') || c == '\u0F35' || c == '\u0F37' || c == '\u0F39' || c == '\u0F3E' || c == '\u0F3F' || 
119                        (c >= '\u0F71' && c <= '\u0F84') || (c >= '\u0F86' && c <= '\u0F8B') || (c >= '\u0F90' && c <= '\u0F95') || c == '\u0F97' || 
120                        (c >= '\u0F99' && c <= '\u0FAD') || (c >= '\u0FB1' && c <= '\u0FB7') || c == '\u0FB9' || (c >= '\u20D0' && c <= '\u20DC') ||
121                        c == '\u20E1' || (c >= '\u302A' && c <= '\u302F') || c == '\u3099' || c == '\u309A';
122        }
123
124        private static boolean isExtender(char c) {
125                return c == '\u00B7' || c == '\u02D0' || c == '\u02D1' || c == '\u0387' || c == '\u0640' || c == '\u0E46' || 
126                        c == '\u0EC6' || c == '\u3005' || (c >= '\u3031' && c <= '\u3035') || (c >= '\u309D' && c <= '\u309E') || 
127                        (c >= '\u30FC' && c <= '\u30FE');
128        }
129
130        private static boolean isLetter(char c) {
131                return isBaseChar(c) || isIdeographic(c);
132        }
133
134        private static boolean isBaseChar(char c) {
135                return (c >= '\u0041' && c <= '\u005A') || (c >= '\u0061' && c <= '\u007A') || (c >= '\u00C0' && c <= '\u00D6') || 
136                        (c >= '\u00D8' && c <= '\u00F6') || (c >= '\u00F8' && c <= '\u00FF') || (c >= '\u0100' && c <= '\u0131') || 
137                        (c >= '\u0134' && c <= '\u013E') || (c >= '\u0141' && c <= '\u0148') || (c >= '\u014A' && c <= '\u017E') || 
138                        (c >= '\u0180' && c <= '\u01C3') || (c >= '\u01CD' && c <= '\u01F0') || (c >= '\u01F4' && c <= '\u01F5') || 
139                        (c >= '\u01FA' && c <= '\u0217') || (c >= '\u0250' && c <= '\u02A8') || (c >= '\u02BB' && c <= '\u02C1') || 
140                        c == '\u0386' || (c >= '\u0388' && c <= '\u038A') || c == '\u038C' || (c >= '\u038E' && c <= '\u03A1') || 
141                        (c >= '\u03A3' && c <= '\u03CE') || (c >= '\u03D0' && c <= '\u03D6') || c == '\u03DA' || c == '\u03DC' || c == '\u03DE' || 
142                        c == '\u03E0' || (c >= '\u03E2' && c <= '\u03F3') || (c >= '\u0401' && c <= '\u040C') || (c >= '\u040E' && c <= '\u044F') || 
143                        (c >= '\u0451' && c <= '\u045C') || (c >= '\u045E' && c <= '\u0481') || (c >= '\u0490' && c <= '\u04C4') || 
144                        (c >= '\u04C7' && c <= '\u04C8') || (c >= '\u04CB' && c <= '\u04CC') || (c >= '\u04D0' && c <= '\u04EB') || 
145                        (c >= '\u04EE' && c <= '\u04F5') || (c >= '\u04F8' && c <= '\u04F9') || (c >= '\u0531' && c <= '\u0556') || 
146                        c == '\u0559' || (c >= '\u0561' && c <= '\u0586') || (c >= '\u05D0' && c <= '\u05EA') || (c >= '\u05F0' && c <= '\u05F2') || 
147                        (c >= '\u0621' && c <= '\u063A') || (c >= '\u0641' && c <= '\u064A') || (c >= '\u0671' && c <= '\u06B7') || 
148                        (c >= '\u06BA' && c <= '\u06BE') || (c >= '\u06C0' && c <= '\u06CE') || (c >= '\u06D0' && c <= '\u06D3') || 
149                        c == '\u06D5' || (c >= '\u06E5' && c <= '\u06E6') || (c >= '\u0905' && c <= '\u0939') || c == '\u093D' || 
150                        (c >= '\u0958' && c <= '\u0961') || (c >= '\u0985' && c <= '\u098C') || (c >= '\u098F' && c <= '\u0990') || 
151                        (c >= '\u0993' && c <= '\u09A8') || (c >= '\u09AA' && c <= '\u09B0') || c == '\u09B2' || 
152                        (c >= '\u09B6' && c <= '\u09B9') || (c >= '\u09DC' && c <= '\u09DD') || (c >= '\u09DF' && c <= '\u09E1') || 
153                        (c >= '\u09F0' && c <= '\u09F1') || (c >= '\u0A05' && c <= '\u0A0A') || (c >= '\u0A0F' && c <= '\u0A10') || 
154                        (c >= '\u0A13' && c <= '\u0A28') || (c >= '\u0A2A' && c <= '\u0A30') || (c >= '\u0A32' && c <= '\u0A33') || 
155                        (c >= '\u0A35' && c <= '\u0A36') || (c >= '\u0A38' && c <= '\u0A39') || (c >= '\u0A59' && c <= '\u0A5C') || 
156                        c == '\u0A5E' || (c >= '\u0A72' && c <= '\u0A74') || (c >= '\u0A85' && c <= '\u0A8B') || c == '\u0A8D' || 
157                        (c >= '\u0A8F' && c <= '\u0A91') || (c >= '\u0A93' && c <= '\u0AA8') || (c >= '\u0AAA' && c <= '\u0AB0') || 
158                        (c >= '\u0AB2' && c <= '\u0AB3') || (c >= '\u0AB5' && c <= '\u0AB9') || c == '\u0ABD' || c == '\u0AE0' || 
159                        (c >= '\u0B05' && c <= '\u0B0C') || (c >= '\u0B0F' && c <= '\u0B10') || (c >= '\u0B13' && c <= '\u0B28') || 
160                        (c >= '\u0B2A' && c <= '\u0B30') || (c >= '\u0B32' && c <= '\u0B33') || (c >= '\u0B36' && c <= '\u0B39') || 
161                        c == '\u0B3D' || (c >= '\u0B5C' && c <= '\u0B5D') || (c >= '\u0B5F' && c <= '\u0B61') || 
162                        (c >= '\u0B85' && c <= '\u0B8A') || (c >= '\u0B8E' && c <= '\u0B90') || (c >= '\u0B92' && c <= '\u0B95') || 
163                        (c >= '\u0B99' && c <= '\u0B9A') || c == '\u0B9C' || (c >= '\u0B9E' && c <= '\u0B9F') || 
164                        (c >= '\u0BA3' && c <= '\u0BA4') || (c >= '\u0BA8' && c <= '\u0BAA') || (c >= '\u0BAE' && c <= '\u0BB5') || 
165                        (c >= '\u0BB7' && c <= '\u0BB9') || (c >= '\u0C05' && c <= '\u0C0C') || (c >= '\u0C0E' && c <= '\u0C10') || 
166                        (c >= '\u0C12' && c <= '\u0C28') || (c >= '\u0C2A' && c <= '\u0C33') || (c >= '\u0C35' && c <= '\u0C39') || 
167                        (c >= '\u0C60' && c <= '\u0C61') || (c >= '\u0C85' && c <= '\u0C8C') || (c >= '\u0C8E' && c <= '\u0C90') || 
168                        (c >= '\u0C92' && c <= '\u0CA8') || (c >= '\u0CAA' && c <= '\u0CB3') || (c >= '\u0CB5' && c <= '\u0CB9') || 
169                        c == '\u0CDE' || (c >= '\u0CE0' && c <= '\u0CE1') || (c >= '\u0D05' && c <= '\u0D0C') || 
170                        (c >= '\u0D0E' && c <= '\u0D10') || (c >= '\u0D12' && c <= '\u0D28') || (c >= '\u0D2A' && c <= '\u0D39') || 
171                        (c >= '\u0D60' && c <= '\u0D61') || (c >= '\u0E01' && c <= '\u0E2E') || c == '\u0E30' || 
172                        (c >= '\u0E32' && c <= '\u0E33') || (c >= '\u0E40' && c <= '\u0E45') || (c >= '\u0E81' && c <= '\u0E82') || 
173                        c == '\u0E84' || (c >= '\u0E87' && c <= '\u0E88') || c == '\u0E8A' || c == '\u0E8D' || (c >= '\u0E94' && c <= '\u0E97') || 
174                        (c >= '\u0E99' && c <= '\u0E9F') || (c >= '\u0EA1' && c <= '\u0EA3') || c == '\u0EA5' || c == '\u0EA7' || 
175                        (c >= '\u0EAA' && c <= '\u0EAB') || (c >= '\u0EAD' && c <= '\u0EAE') || c == '\u0EB0' || 
176                        (c >= '\u0EB2' && c <= '\u0EB3') || c == '\u0EBD' || (c >= '\u0EC0' && c <= '\u0EC4') || 
177                        (c >= '\u0F40' && c <= '\u0F47') || (c >= '\u0F49' && c <= '\u0F69') || (c >= '\u10A0' && c <= '\u10C5') || 
178                        (c >= '\u10D0' && c <= '\u10F6') || c == '\u1100' || (c >= '\u1102' && c <= '\u1103') || 
179                        (c >= '\u1105' && c <= '\u1107') || c == '\u1109' || (c >= '\u110B' && c <= '\u110C') || 
180                        (c >= '\u110E' && c <= '\u1112') || c == '\u113C' || c == '\u113E' || c == '\u1140' || c == '\u114C' || 
181                        c == '\u114E' || c == '\u1150' || (c >= '\u1154' && c <= '\u1155') || c == '\u1159' || 
182                        (c >= '\u115F' && c <= '\u1161') || c == '\u1163' || c == '\u1165' || c == '\u1167' || c == '\u1169' || 
183                        (c >= '\u116D' && c <= '\u116E') || (c >= '\u1172' && c <= '\u1173') || c == '\u1175' || 
184                        c == '\u119E' || c == '\u11A8' || c == '\u11AB' || (c >= '\u11AE' && c <= '\u11AF') || 
185                        (c >= '\u11B7' && c <= '\u11B8') || c == '\u11BA' || (c >= '\u11BC' && c <= '\u11C2') || 
186                        c == '\u11EB' || c == '\u11F0' || c == '\u11F9' || (c >= '\u1E00' && c <= '\u1E9B') || (c >= '\u1EA0' && c <= '\u1EF9') || 
187                        (c >= '\u1F00' && c <= '\u1F15') || (c >= '\u1F18' && c <= '\u1F1D') || (c >= '\u1F20' && c <= '\u1F45') || 
188                        (c >= '\u1F48' && c <= '\u1F4D') || (c >= '\u1F50' && c <= '\u1F57') || c == '\u1F59' || c == '\u1F5B' || c == '\u1F5D' || 
189                        (c >= '\u1F5F' && c <= '\u1F7D') || (c >= '\u1F80' && c <= '\u1FB4') || (c >= '\u1FB6' && c <= '\u1FBC') || 
190                        c == '\u1FBE' || (c >= '\u1FC2' && c <= '\u1FC4') || (c >= '\u1FC6' && c <= '\u1FCC') || 
191                        (c >= '\u1FD0' && c <= '\u1FD3') || (c >= '\u1FD6' && c <= '\u1FDB') || (c >= '\u1FE0' && c <= '\u1FEC') || 
192                        (c >= '\u1FF2' && c <= '\u1FF4') || (c >= '\u1FF6' && c <= '\u1FFC') || c == '\u2126' || 
193                        (c >= '\u212A' && c <= '\u212B') || c == '\u212E' || (c >= '\u2180' && c <= '\u2182') || 
194                        (c >= '\u3041' && c <= '\u3094') || (c >= '\u30A1' && c <= '\u30FA') || (c >= '\u3105' && c <= '\u312C') || 
195                        (c >= '\uAC00' && c <= '\uD7A3');
196        }
197
198        private static boolean isIdeographic(char c) {
199                return (c >= '\u4E00' && c <= '\u9FA5') || c == '\u3007' || (c >= '\u3021' && c <= '\u3029');
200        }
201
202        public static String determineEncoding(InputStream stream) throws IOException {
203                stream.mark(20000);
204                try {
205                        int b0 = stream.read();
206                        int b1 = stream.read();
207                        int b2 = stream.read();
208                        int b3 = stream.read();
209
210                        if (b0 == 0xFE && b1 == 0xFF)
211                                return "UTF-16BE";
212                        else if (b0 == 0xFF && b1 == 0xFE)
213                                return "UTF-16LE";
214                        else if (b0 == 0xEF && b1 == 0xBB && b2 == 0xBF )
215                                return "UTF-8";
216                        else if (b0 == 0x00 && b1 == 0x3C && b2 == 0x00 && b3 == 0x3F)
217                                return "UTF-16BE";
218                        else if (b0 == 0x3C && b1 == 0x00 && b2 == 0x3F && b3 == 0x00)
219                                return "UTF-16LE";
220                        else if (b0 == 0x3C && b1 == 0x3F && b2 == 0x78 && b3 == 0x6D) {
221//                              UTF-8, ISO 646, ASCII, some part of ISO 8859, Shift-JIS, EUC, or any other 7-bit, 8-bit, or mixed-width encoding 
222//                              which ensures that the characters of ASCII have their normal positions, width, and values; the actual encoding 
223//                              declaration must be read to detect which of these applies, but since all of these encodings use the same bit patterns 
224//                              for the relevant ASCII characters, the encoding declaration itself may be read reliably
225                                InputStreamReader rdr = new InputStreamReader(stream, "US-ASCII");
226                                String hdr = readFirstLine(rdr);
227                                return extractEncoding(hdr); 
228                        } else
229                                return null;
230                } finally {
231                        stream.reset();
232                }
233        }
234
235        private static String extractEncoding(String hdr) {
236                int i = hdr.indexOf("encoding=");
237                if (i == -1)
238                        return null;
239                hdr = hdr.substring(i+9);
240                char sep = hdr.charAt(0);
241                hdr = hdr.substring(1);
242                i = hdr.indexOf(sep);
243                if (i == -1)
244                        return null;
245                return hdr.substring(0, i);
246        }
247
248        private static String readFirstLine(InputStreamReader rdr) throws IOException {
249                char[] buf = new char[1];
250                StringBuffer bldr = new StringBuffer();
251                rdr.read(buf);
252                while (buf[0] != '>') {
253                        bldr.append(buf[0]);
254                        rdr.read(buf);
255                }
256                return bldr.toString();
257        }
258
259        
260    public static boolean charSetImpliesAscii(String charset) {
261                return charset.equals("ISO-8859-1") || charset.equals("US-ASCII");
262        }
263
264        
265        /**
266         * Converts the raw characters to XML escape characters.
267         * 
268         * @param rawContent
269         * @param charset Null when charset is not known, so we assume it's unicode
270         * @param isNoLines
271         * @return escape string
272         */
273        public static String escapeXML(String rawContent, String charset, boolean isNoLines) {
274                if (rawContent == null)
275                        return "";
276                else {
277                        StringBuffer sb = new StringBuffer();
278
279                        for (int i = 0; i < rawContent.length(); i++) {
280                                char ch = rawContent.charAt(i);
281                                // We don't escape ' because our code always spits out attributes surrounded by "", which means
282                                // it's not necessary to escape ' - and it's *much* less ugly and more bandwidth-efficient when we don't.
283                                if (ch == '&')
284                                        sb.append("&amp;");
285                                else if (ch == '"')
286                                        sb.append("&quot;");
287                                else if (ch == '<')
288                                        sb.append("&lt;");
289                                else if (ch == '>')
290                                        sb.append("&gt;");
291                                else if (ch > '~' && charset != null && charSetImpliesAscii(charset)) 
292                                        // TODO - why is hashcode the only way to get the unicode number for the character
293                                        // in jre 5.0?
294                                        sb.append("&#x"+Integer.toHexString(ch).toUpperCase()+";");
295                                else if (isNoLines) {
296                                        if (ch == '\r')
297                                                sb.append("&#xA;");
298                                        else if (ch != '\n')
299                                                sb.append(ch);
300                                }
301                                else
302                                        sb.append(ch);
303                        }
304                        return sb.toString();
305                }
306        }
307
308  public static Element getFirstChild(Element e) {
309    if (e == null)
310      return null;
311    Node n = e.getFirstChild();
312    while (n != null && n.getNodeType() != Node.ELEMENT_NODE)
313      n = n.getNextSibling();
314    return (Element) n;
315  }
316
317  public static Element getNamedChild(Element e, String name) {
318    Element c = getFirstChild(e);
319    while (c != null && !name.equals(c.getLocalName()) && !name.equals(c.getNodeName()))
320      c = getNextSibling(c);
321    return c;
322  }
323
324  public static Element getNamedChildByAttribute(Element e, String name, String nname, String nvalue) {
325    Element c = getFirstChild(e);
326    while (c != null && !((name.equals(c.getLocalName()) || name.equals(c.getNodeName())) && nvalue.equals(c.getAttribute(nname))))
327      c = getNextSibling(c);
328    return c;
329  }
330
331  public static Element getNextSibling(Element e) {
332    Node n = e.getNextSibling();
333    while (n != null && n.getNodeType() != Node.ELEMENT_NODE)
334      n = n.getNextSibling();
335    return (Element) n;
336  }
337
338  public static void getNamedChildren(Element e, String name, List<Element> set) {
339    Element c = getFirstChild(e);
340    while (c != null) {
341      if (name.equals(c.getLocalName()) || name.equals(c.getNodeName()) )
342        set.add(c);
343      c = getNextSibling(c);
344    }
345  }
346
347  public static List<Element> getNamedChildren(Element e, String name) {
348    List<Element> res = new ArrayList<Element>();
349    Element c = getFirstChild(e);
350    while (c != null) {
351      if (name.equals(c.getLocalName()) || name.equals(c.getNodeName()) )
352        res.add(c);
353      c = getNextSibling(c);
354    }
355    return res;
356  }
357
358  public static String htmlToXmlEscapedPlainText(Element r) {
359    StringBuilder s = new StringBuilder();
360    Node n = r.getFirstChild();
361    boolean ws = false;
362    while (n != null) {
363      if (n.getNodeType() == Node.TEXT_NODE) {
364        String t = n.getTextContent().trim();
365        if (Utilities.noString(t))
366          ws = true;
367        else {
368          if (ws)
369            s.append(" ");
370          ws = false;
371          s.append(t);
372        }
373      }
374      if (n.getNodeType() == Node.ELEMENT_NODE) {
375        if (ws)
376          s.append(" ");
377        ws = false;
378        s.append(htmlToXmlEscapedPlainText((Element) n));
379        if (r.getNodeName().equals("br") || r.getNodeName().equals("p"))
380          s.append("\r\n");
381      }
382      n = n.getNextSibling();      
383    }
384    return s.toString();
385  }
386
387  public static String htmlToXmlEscapedPlainText(String definition) throws ParserConfigurationException, SAXException, IOException  {
388    return htmlToXmlEscapedPlainText(parseToDom("<div>"+definition+"</div>").getDocumentElement());
389  }
390
391  public static String elementToString(Element el) {
392    if (el == null)
393      return "";
394    Document document = el.getOwnerDocument();
395    DOMImplementationLS domImplLS = (DOMImplementationLS) document
396        .getImplementation();
397    LSSerializer serializer = domImplLS.createLSSerializer();
398    return serializer.writeToString(el);
399  }
400
401  public static String getNamedChildValue(Element element, String name) {
402    Element e = getNamedChild(element, name);
403    return e == null ? null : e.getAttribute("value");
404  }
405
406  public static void setNamedChildValue(Element element, String name, String value) throws FHIRException  {
407    Element e = getNamedChild(element, name);
408    if (e == null)
409      throw new FHIRException("unable to find element "+name);
410    e.setAttribute("value", value);
411  }
412
413
414        public static void getNamedChildrenWithWildcard(Element focus, String name, List<Element> children) {
415    Element c = getFirstChild(focus);
416    while (c != null) {
417        String n = c.getLocalName() != null ? c.getLocalName() : c.getNodeName(); 
418      if (name.equals(n) || (name.endsWith("[x]") && n.startsWith(name.substring(0, name.length()-3))))
419        children.add(c);
420      c = getNextSibling(c);
421    }
422  }
423
424        public static void getNamedChildrenWithTails(Element focus, String name, List<Element> children, Set<String> typeTails) {
425    Element c = getFirstChild(focus);
426    while (c != null) {
427      String n = c.getLocalName() != null ? c.getLocalName() : c.getNodeName(); 
428      if (n.equals(name) || (!n.equals("responseCode") && (n.startsWith(name) && typeTails.contains(n.substring(name.length())))))
429        children.add(c);
430      c = getNextSibling(c);
431    }
432  }
433        
434  public static boolean hasNamedChild(Element e, String name) {
435    Element c = getFirstChild(e);
436    while (c != null && !name.equals(c.getLocalName()) && !name.equals(c.getNodeName()))
437      c = getNextSibling(c);
438    return c != null;
439  }
440
441  public static Document parseToDom(String content) throws ParserConfigurationException, SAXException, IOException  {
442    DocumentBuilderFactory factory = XMLUtil.newXXEProtectedDocumentBuilderFactory();
443    factory.setNamespaceAware(false);
444    DocumentBuilder builder = factory.newDocumentBuilder();
445    return builder.parse(new ByteArrayInputStream(content.getBytes()));
446  }
447
448  public static Document parseToDom(byte[] content) throws ParserConfigurationException, SAXException, IOException  {
449    DocumentBuilderFactory factory = XMLUtil.newXXEProtectedDocumentBuilderFactory();
450    factory.setNamespaceAware(false);
451    DocumentBuilder builder = factory.newDocumentBuilder();
452    return builder.parse(new ByteArrayInputStream(content));
453  }
454
455  public static Document parseToDom(byte[] content, boolean ns) throws ParserConfigurationException, SAXException, IOException  {
456    DocumentBuilderFactory factory = XMLUtil.newXXEProtectedDocumentBuilderFactory();
457    factory.setNamespaceAware(ns);
458    DocumentBuilder builder = factory.newDocumentBuilder();
459    return builder.parse(new ByteArrayInputStream(content));
460  }
461
462  public static Document parseFileToDom(String filename) throws ParserConfigurationException, SAXException, IOException  {
463    DocumentBuilderFactory factory = XMLUtil.newXXEProtectedDocumentBuilderFactory();
464    factory.setNamespaceAware(false);
465    DocumentBuilder builder = factory.newDocumentBuilder();
466    FileInputStream fs = ManagedFileAccess.inStream(filename);
467    try {
468      return builder.parse(fs);
469    } finally {
470      fs.close();
471    }  
472  }
473
474  public static Document parseFileToDom(String filename, boolean ns) throws ParserConfigurationException, SAXException, IOException  {
475    DocumentBuilderFactory factory = XMLUtil.newXXEProtectedDocumentBuilderFactory();
476    factory.setNamespaceAware(ns);
477    DocumentBuilder builder = factory.newDocumentBuilder();
478    FileInputStream fs = ManagedFileAccess.inStream(filename);
479    try {
480      return builder.parse(fs);
481    } finally {
482      fs.close();
483    }
484  }
485
486  public static Element getLastChild(Element e) {
487    if (e == null)
488      return null;
489    Node n = e.getLastChild();
490    while (n != null && n.getNodeType() != Node.ELEMENT_NODE)
491      n = n.getPreviousSibling();
492    return (Element) n;
493  }
494
495  public static Element getPrevSibling(Element e) {
496    Node n = e.getPreviousSibling();
497    while (n != null && n.getNodeType() != Node.ELEMENT_NODE)
498      n = n.getPreviousSibling();
499    return (Element) n;
500  }
501
502  public static String getNamedChildAttribute(Element element, String name, String aname) {
503    Element e = getNamedChild(element, name);
504    return e == null ? null : e.getAttribute(aname);
505  }
506
507  public static TransformerFactory newXXEProtectedTransformerFactory() {
508    final TransformerFactory transformerFactory = TransformerFactory.newInstance();
509    transformerFactory.setAttribute(XMLConstants.ACCESS_EXTERNAL_DTD, "");
510    transformerFactory.setAttribute(XMLConstants.ACCESS_EXTERNAL_STYLESHEET, "");
511    return transformerFactory;
512  }
513
514  public static DocumentBuilderFactory newXXEProtectedDocumentBuilderFactory() throws ParserConfigurationException {
515    final DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();
516    documentBuilderFactory.setFeature(APACHE_XML_FEATURES_DISALLOW_DOCTYPE_DECL, true);
517    documentBuilderFactory.setXIncludeAware(false);
518    return documentBuilderFactory;
519  }
520
521  public static SAXParserFactory newXXEProtectedSaxParserFactory() throws SAXNotSupportedException, SAXNotRecognizedException, ParserConfigurationException {
522    final SAXParserFactory spf = SAXParserFactory.newInstance();
523    spf.setFeature(SAX_FEATURES_EXTERNAL_GENERAL_ENTITIES, false);
524    spf.setFeature(APACHE_XML_FEATURES_DISALLOW_DOCTYPE_DECL, true);
525    return spf;
526  }
527
528  public static XMLReader getXXEProtectedXMLReader(SAXParserFactory spf) throws ParserConfigurationException, SAXException {
529    final SAXParser saxParser = spf.newSAXParser();
530    final XMLReader xmlReader = saxParser.getXMLReader();
531
532    final boolean externalGeneralEntitiesFeatureValue = spf.getFeature(SAX_FEATURES_EXTERNAL_GENERAL_ENTITIES);
533    if (externalGeneralEntitiesFeatureValue) {
534      throw new IllegalArgumentException("SAXParserFactory has insecure feature setting:" + SAX_FEATURES_EXTERNAL_GENERAL_ENTITIES+ "=" + externalGeneralEntitiesFeatureValue);
535    }
536    final boolean disallowDocTypeDeclFeatureValue = spf.getFeature(APACHE_XML_FEATURES_DISALLOW_DOCTYPE_DECL);
537    if (!disallowDocTypeDeclFeatureValue) {
538      throw new IllegalArgumentException("SAXParserFactory has insecure feature setting:" + APACHE_XML_FEATURES_DISALLOW_DOCTYPE_DECL + "=" + disallowDocTypeDeclFeatureValue);
539    }
540    xmlReader.setFeature(SAX_FEATURES_EXTERNAL_GENERAL_ENTITIES, false);
541    xmlReader.setFeature(APACHE_XML_FEATURES_DISALLOW_DOCTYPE_DECL, true);
542    return xmlReader;
543  }
544  public static void writeDomToFile(Document doc, String filename) throws TransformerException, IOException {
545    TransformerFactory transformerFactory = XMLUtil.newXXEProtectedTransformerFactory();
546    Transformer transformer = transformerFactory.newTransformer();
547    DOMSource source = new DOMSource(doc);
548    StreamResult streamResult =  new StreamResult(ManagedFileAccess.file(filename));
549    transformer.transform(source, streamResult);    
550  }
551
552  public static String getXsiType(org.w3c.dom.Element element) {
553    Attr a = element.getAttributeNodeNS("http://www.w3.org/2001/XMLSchema-instance", "type");
554    return (a == null ? null : a.getTextContent());
555    
556  }
557
558        public static String getDirectText(org.w3c.dom.Element node) {
559    Node n = node.getFirstChild();
560    StringBuilder b = new StringBuilder();
561    while (n != null) {
562        if (n.getNodeType() == Node.TEXT_NODE) 
563                b.append(n.getTextContent());
564        n = n.getNextSibling();
565    }
566          return b.toString().trim();
567        }
568
569  public static void deleteByName(Element e, String name) {
570    List<Element> matches = getNamedChildren(e, name);
571    for (Element m : matches)
572      e.removeChild(m);    
573  }
574
575  public static void deleteAttr(Element e, String namespaceURI, String localName) {
576    if (e.hasAttributeNS(namespaceURI, localName))
577      e.removeAttributeNS(namespaceURI, localName);
578    
579  }
580
581  public static Node[] children(Element ed) {
582    Node[] res = new Node[ed.getChildNodes().getLength()];
583    for (int i = 0; i < ed.getChildNodes().getLength(); i++)
584      res[i] = ed.getChildNodes().item(i);
585    return res;
586  }
587
588  public static Element addChild(Document doc, Element element, String name, String namespace, int indent) {
589    Node node = doc.createTextNode("\n"+Utilities.padLeft("", ' ', indent));
590    Element child = doc.createElementNS(namespace, name);
591    element.appendChild(child);
592    element.appendChild(node);
593    return child;
594  }
595
596  public static Element insertChild(Document doc, Element element, String name, String namespace, int indent) {
597    Node node = doc.createTextNode("\n"+Utilities.padLeft("", ' ', indent));
598    Element child = doc.createElementNS(namespace, name);
599    element.insertBefore(child, element.getFirstChild());
600    element.insertBefore(node, element.getFirstChild());
601    return child;
602  }
603
604  public static Element insertChild(Document doc, Element element, String name, String namespace, Node before, int indent) {
605    if (before == null) {
606      Node node = doc.createTextNode("\n"+Utilities.padLeft("", ' ', indent));
607      element.insertBefore(node, before);
608    }
609    Element child = doc.createElementNS(namespace, name);
610    element.insertBefore(child, before);
611    if (before != null) {
612      Node node = doc.createTextNode("\n"+Utilities.padLeft("", ' ', indent));
613      element.insertBefore(node, before);
614    }
615    return child;
616  }
617
618  public static void addTextTag(Document doc, Element element, String name, String namespace, String text, int indent) {
619    Node node = doc.createTextNode("\n"+Utilities.padLeft("", ' ', indent));
620    element.appendChild(node);
621    Element child = doc.createElementNS(namespace, name);
622    element.appendChild(child);
623    child.setAttribute("value", text);    
624  }
625
626  public static Element addTextTag(Document doc, Element element, String name, String text, int indent) {
627    Node node = doc.createTextNode("\n"+Utilities.padLeft("", ' ', indent));
628    element.appendChild(node);
629    Element child = doc.createElement(name);
630    element.appendChild(child);
631    child.appendChild(doc.createTextNode(text));
632    return child;
633  }
634
635  public static void saveToFile(Element root, OutputStream stream) throws TransformerException {
636    Transformer transformer = XMLUtil.newXXEProtectedTransformerFactory().newTransformer();
637    Result output = new StreamResult(stream);
638    Source input = new DOMSource(root);
639
640    transformer.transform(input, output);
641  }
642
643  public static void spacer(Document doc, Element element, int indent) {
644    Node node = doc.createTextNode("\n"+Utilities.padLeft("", ' ', indent));
645    element.appendChild(node);
646   
647  }
648
649  public static String getNamedChildText(Element element, String name) {
650    Element e = getNamedChild(element, name);
651    return e == null ? null : e.getTextContent();
652  }
653
654  public static Element getFirstChild(Element res, String... names) {
655    Element node = getFirstChild(res);
656    while (node != null && !Utilities.existsInList(node.getLocalName(), names)) {
657      node = getNextSibling(node);
658    }
659    return node;
660  }
661
662  public static Element getLastChild(Element res, String... names) {
663    Element result = null;
664    Element node = getFirstChild(res);
665    while (node != null) {
666      if (Utilities.existsInList(node.getLocalName(), names)) {
667        result = node;
668      }
669      node = getNextSibling(node);
670    }
671    return result;
672  }
673
674  public static void clearChildren(Node node) {
675    NodeList nodeList = node.getChildNodes();
676    for (int i = nodeList.getLength() - 1; i >= 0; i--) {
677      Node item = nodeList.item(i);
678      if (item.hasChildNodes()) {
679        clearChildren(item);
680      }
681      node.removeChild(item);
682    };
683  }
684
685
686}