XMLParser.java

/**
 * The contents of this file are subject to the Mozilla Public License Version 1.1
 * (the "License"); you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at http://www.mozilla.org/MPL/
 * Software distributed under the License is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for the
 * specific language governing rights and limitations under the License.
 *
 * The Original Code is "XMLParser.java".  Description:
 * "Parses and encodes HL7 messages in XML form, according to HL7's normative XML encoding
 * specification."
 *
 * The Initial Developer of the Original Code is University Health Network. Copyright (C)
 * 2002.  All Rights Reserved.
 *
 * Contributor(s): ______________________________________.
 *
 * Alternatively, the contents of this file may be used under the terms of the
 * GNU General Public License (the  �GPL�), in which case the provisions of the GPL are
 * applicable instead of those above.  If you wish to allow use of your version of this
 * file only under the terms of the GPL and not to allow others to use your version
 * of this file under the MPL, indicate your decision by deleting  the provisions above
 * and replace  them with the notice and other provisions required by the GPL License.
 * If you do not delete the provisions above, a recipient may use your version of
 * this file under either the MPL or the GPL.
 */

package ca.uhn.hl7v2.parser;

import java.util.HashSet;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import ca.uhn.hl7v2.Version;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.w3c.dom.DOMException;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

import ca.uhn.hl7v2.ErrorCode;
import ca.uhn.hl7v2.HL7Exception;
import ca.uhn.hl7v2.HapiContext;
import ca.uhn.hl7v2.model.Composite;
import ca.uhn.hl7v2.model.DataTypeException;
import ca.uhn.hl7v2.model.GenericComposite;
import ca.uhn.hl7v2.model.GenericMessage;
import ca.uhn.hl7v2.model.GenericPrimitive;
import ca.uhn.hl7v2.model.Message;
import ca.uhn.hl7v2.model.Primitive;
import ca.uhn.hl7v2.model.Segment;
import ca.uhn.hl7v2.model.Type;
import ca.uhn.hl7v2.model.Varies;
import ca.uhn.hl7v2.util.Terser;
import ca.uhn.hl7v2.util.XMLUtils;

/**
 * Parses and encodes HL7 messages in XML form, according to HL7's normative XML encoding
 * specification. This is an abstract class that handles datatype and segment parsing/encoding, but
 * not the parsing/encoding of entire messages. To use the XML parser, you should create a subclass
 * for a certain message structure. This subclass must be able to identify the Segment objects that
 * correspond to various Segment nodes in an XML document, and call the methods <code>
 * parse(Segment segment, ElementNode segmentNode)</code> and
 * <code>encode(Segment segment, ElementNode segmentNode)
 * </code> as appropriate. XMLParser uses the Xerces parser, which must be installed in your
 * classpath.
 * 
 * @see ParserConfiguration for configuration options which may affect parser encoding and decoding behaviour
 * @author Bryan Tripp, Shawn Bellina
 */
public abstract class XMLParser extends Parser {

	private static final String ESCAPE_ATTRNAME = "V";
	private static final String ESCAPE_NODENAME = "escape";
	private static final Logger log = LoggerFactory.getLogger(XMLParser.class);
    protected static final String NS = "urn:hl7-org:v2xml";
    private static final Pattern NS_PATTERN = Pattern.compile("xmlns(.*)=\"" + NS + "\"");

	private String textEncoding;




	/** Constructor */
	public XMLParser() {
		super();
	}

    /**
     *
     * @param context the HAPI context
     */
	public XMLParser(HapiContext context) {
		super(context);
	}

	/**
	 * Constructor
	 * 
	 * @param theFactory custom factory to use for model class lookup
	 */
	public XMLParser(ModelClassFactory theFactory) {
		super(theFactory);

	}

	/**
	 * Returns a String representing the encoding of the given message, if the encoding is
	 * recognized. For example if the given message appears to be encoded using HL7 2.x XML rules
	 * then "XML" would be returned. If the encoding is not recognized then null is returned. That
	 * this method returns a specific encoding does not guarantee that the message is correctly
	 * encoded (e.g. well formed XML) - just that it is not encoded using any other encoding than
	 * the one returned. Returns null if the encoding is not recognized.
	 */
	public String getEncoding(String message) {
		return EncodingDetector.isXmlEncoded(message) ? getDefaultEncoding() : null;
	}

	/**
	 * @return the preferred encoding of this Parser
	 */
	public String getDefaultEncoding() {
		return "XML";
	}

	/**
	 * Sets the <i>keepAsOriginalNodes<i>
	 * 
	 * The nodes whose names match the <i>keepAsOriginalNodes<i> will be kept as original, meaning
	 * that no white space treaming will occur on them
     *
     * @param keepAsOriginalNodes of the nodes to be kept as original
     * @deprecated Use {@link ParserConfiguration#setXmlDisableWhitespaceTrimmingOnNodeNames(Set)} instead. That method works exactly the same as this one but has been renamed for a more clear meaning. 
	 */
	@Deprecated()
	public void setKeepAsOriginalNodes(String[] keepAsOriginalNodes) {
		getParserConfiguration().setXmlDisableWhitespaceTrimmingOnNodeNames(keepAsOriginalNodes);
	}

	/**
	 * Sets the <i>keepAsOriginalNodes<i>
	 * 
	 * @deprecated Use {@link ParserConfiguration#getXmlDisableWhitespaceTrimmingOnNodeNames()} instead
	 */
	@Deprecated
	public String[] getKeepAsOriginalNodes() {
		return getParserConfiguration().getXmlDisableWhitespaceTrimmingOnNodeNames().toArray(new String[getParserConfiguration().getXmlDisableWhitespaceTrimmingOnNodeNames().size()]);
	}

	/**
	 * <p>
	 * Creates and populates a Message object from an XML Document that contains an XML-encoded HL7
	 * message.
	 * </p>
	 * <p>
	 * The easiest way to implement this method for a particular message structure is as follows:
	 * <ol>
	 * <li>Create an instance of the Message type you are going to handle with your subclass of
	 * XMLParser</li>
	 * <li>Go through the given Document and find the Elements that represent the top level of each
	 * message segment.</li>
	 * <li>For each of these segments, call
	 * <code>parse(Segment segmentObject, Element segmentElement)</code>, providing the appropriate
	 * Segment from your Message object, and the corresponding Element.</li>
	 * </ol>
	 * At the end of this process, your Message object should be populated with data from the XML
	 * Document.
	 * </p>
	 *
     * @param xmlMessage DOM message object to be parsed
     * @param version HL7 version
	 * @throws HL7Exception if the message is not correctly formatted.
	 * @throws EncodingNotSupportedException if the message encoded is not supported by this parser.
	 */
	public abstract Message parseDocument(Document xmlMessage, String version) throws HL7Exception;

	/**
	 * <p>
	 * Parses a message string and returns the corresponding Message object. This method checks that
	 * the given message string is XML encoded, creates an XML Document object (using Xerces) from
	 * the given String, and calls the abstract method <code>parse(Document XMLMessage)</code>
	 * </p>
	 */
	protected Message doParse(String message, String version) throws HL7Exception {
		Message m;

		// parse message string into a DOM document
		Document doc;
		doc = parseStringIntoDocument(message);
		m = parseDocument(doc, version);

		return m;
	}

	/**
	 * Parses a string containing an XML document into a Document object.
	 * 
	 * Note that this method is synchronized currently, as the XML parser is not thread safe
	 * 
	 * @throws HL7Exception
	 */
	protected synchronized Document parseStringIntoDocument(String message) throws HL7Exception {
		try {
			return XMLUtils.parse(message);
		} catch (Exception e) {
			throw new HL7Exception("Exception parsing XML", e);
		}
	}

	/**
	 * Formats a Message object into an HL7 message string using the given encoding.
	 * 
	 * @throws HL7Exception if the data fields in the message do not permit encoding (e.g. required
	 *             fields are null)
	 * @throws EncodingNotSupportedException if the requested encoding is not supported by this
	 *             parser.
	 */
	protected String doEncode(Message source, String encoding) throws HL7Exception {
		if (!encoding.equals("XML"))
			throw new EncodingNotSupportedException("XMLParser supports only XML encoding");
		return encode(source);
	}

	/**
	 * Formats a Message object into an HL7 message string using this parser's default encoding (XML
	 * encoding). This method calls the abstract method <code>encodeDocument(...)</code> in order to
	 * obtain XML Document object representation of the Message, then serializes it to a String.
	 * 
	 * @throws HL7Exception if the data fields in the message do not permit encoding (e.g. required
	 *             fields are null)
	 */
	protected String doEncode(Message source) throws HL7Exception {
		if (source instanceof GenericMessage) {
			throw new HL7Exception(
					"Can't XML-encode a GenericMessage.  Message must have a recognized structure.");
		}

		Document doc = encodeDocument(source);
		// Element documentElement = doc.getDocumentElement();
		// if (!documentElement.hasAttribute("xmlns"))
		// documentElement.setAttribute("xmlns", "urn:hl7-org:v2xml");
		try {
			return XMLUtils.serialize(doc, getParserConfiguration().isPrettyPrintWhenEncodingXml());
		} catch (Exception e) {
			throw new HL7Exception("Exception serializing XML document to string", e);
		}
	}

	/**
	 * <p>
	 * Creates an XML Document that corresponds to the given Message object.
	 * </p>
	 * <p>
	 * If you are implementing this method, you should create an XML Document, and insert XML
	 * Elements into it that correspond to the groups and segments that belong to the message type
	 * that your subclass of XMLParser supports. Then, for each segment in the message, call the
	 * method <code>encode(Segment segmentObject, Element segmentElement)</code> using the Element
	 * for that segment and the corresponding Segment object from the given Message.
	 * </p>
     *
     * @param source message
     * @return the DOM document object of the encoded message
	 */
	public abstract Document encodeDocument(Message source) throws HL7Exception;


    protected void assertNamespaceURI(String ns) throws HL7Exception {
        if (!NS.equals(ns)) {
            throw new HL7Exception("Namespace URI must be " + NS);
        }
    }

	/**
	 * Populates the given Segment object with data from the given XML Element.
	 *
     * @param segmentObject the segment to parse into
     * @param segmentElement the DOM element to be parsed
	 * @throws HL7Exception if the XML Element does not have the correct name and structure for the
	 *             given Segment, or if there is an error while setting individual field values.
	 */
	public void parse(Segment segmentObject, Element segmentElement) throws HL7Exception {
		Set<String> done = new HashSet<String>();

		NodeList all = segmentElement.getChildNodes();
		for (int i = 0; i < all.getLength(); i++) {
			String elementName = all.item(i).getNodeName();

			if (all.item(i).getNodeType() == Node.ELEMENT_NODE && !done.contains(elementName)) {
                assertNamespaceURI(all.item(i).getNamespaceURI());
				done.add(elementName);

				int index = elementName.indexOf('.');
				if (index >= 0 && elementName.length() > index) { // properly formatted element
					String fieldNumString = elementName.substring(index + 1);
					int fieldNum = Integer.parseInt(fieldNumString);
					parseReps(segmentObject, segmentElement, elementName, fieldNum);
				} else {
					log.debug("Child of segment {} doesn't look like a field {}",
							segmentObject.getName(), elementName);
				}
			}
		}

		// set data type of OBX-5
		if (segmentObject.getClass().getName().contains("OBX")) {
			FixFieldDataType.fixOBX5(segmentObject, getFactory(), getHapiContext().getParserConfiguration());
		}
        // set data type of MFE-4
        if (segmentObject.getClass().getName().contains("MFE") &&
                Version.versionOf(segmentObject.getMessage().getVersion()).isGreaterThan(Version.V23)) {
            FixFieldDataType.fixMFE4(segmentObject, getFactory(), getHapiContext().getParserConfiguration());
        }
	}

	private void parseReps(Segment segmentObject, Element segmentElement, String fieldName,
			int fieldNum) throws HL7Exception {

		NodeList reps = segmentElement.getElementsByTagName(fieldName);
		for (int i = 0; i < reps.getLength(); i++) {
			parse(segmentObject.getField(fieldNum, i), (Element) reps.item(i));
		}
	}

	/**
	 * Populates the given Element with data from the given Segment, by inserting Elements
	 * corresponding to the Segment's fields, their components, etc. Returns true if there is at
	 * least one data value in the segment.
     *
     * @param segmentObject the segment to be encoded
     * @param segmentElement the DOM element to encode into
     * @return true if there is at least one data value in the segment
     * @throws HL7Exception if an erro occurred while encoding
	 */
	public boolean encode(Segment segmentObject, Element segmentElement) throws HL7Exception {
		boolean hasValue = false;
		int n = segmentObject.numFields();
		for (int i = 1; i <= n; i++) {
			String name = makeElementName(segmentObject, i);
			Type[] reps = segmentObject.getField(i);
			for (Type rep : reps) {
				Element newNode = segmentElement.getOwnerDocument().createElement(name);
				boolean componentHasValue = encode(rep, newNode);
				if (componentHasValue) {
					try {
						segmentElement.appendChild(newNode);
					} catch (DOMException e) {
						throw new HL7Exception("DOMException encoding Segment: ", e);
					}
					hasValue = true;
				}
			}
		}
		return hasValue;
	}

	/**
	 * Populates the given Type object with data from the given XML Element.
     *
     * @param datatypeObject the type to parse into
     * @param datatypeElement the DOM element to be parsed
     * @throws DataTypeException if the data did not match the expected type rules
	 */
	public void parse(Type datatypeObject, Element datatypeElement) throws HL7Exception {
		if (datatypeObject instanceof Varies) {
			parseVaries((Varies) datatypeObject, datatypeElement);
		} else if (datatypeObject instanceof Primitive) {
			parsePrimitive((Primitive) datatypeObject, datatypeElement);
		} else if (datatypeObject instanceof Composite) {
			parseComposite((Composite) datatypeObject, datatypeElement);
		}
	}

	/**
	 * Parses an XML element into a Varies by determining whether the element is primitive or
	 * composite, calling setData() on the Varies with a new generic primitive or composite as
	 * appropriate, and then calling parse again with the new Type object.
	 */
	private void parseVaries(Varies datatypeObject, Element datatypeElement)
			throws HL7Exception {
		// figure out what data type it holds
		// short nodeType = datatypeElement.getFirstChild().getNodeType();
		if (!hasChildElement(datatypeElement)) {
			// it's a primitive
			datatypeObject.setData(new GenericPrimitive(datatypeObject.getMessage()));
		} else {
			// it's a composite ... almost know what type, except that we don't have the version
			// here
			datatypeObject.setData(new GenericComposite(datatypeObject.getMessage()));
		}
		parse(datatypeObject.getData(), datatypeElement);
	}

	/** Returns true if any of the given element's children are (non-escape) elements */
	private boolean hasChildElement(Element e) {
		NodeList children = e.getChildNodes();
		boolean hasElement = false;
		int c = 0;
		while (c < children.getLength() && !hasElement) {
			if (children.item(c).getNodeType() == Node.ELEMENT_NODE
					&& !ESCAPE_NODENAME.equals(children.item(c).getNodeName())) {
				hasElement = true;
			}
			c++;
		}
		return hasElement;
	}

	/**
	 * Parses a primitive type by filling it with text child, if any. If the datatype element
	 * contains escape elements, resolve them properly.
	 */
	private void parsePrimitive(Primitive datatypeObject, Element datatypeElement)
			throws HL7Exception {
		NodeList children = datatypeElement.getChildNodes();
		StringBuilder builder = new StringBuilder();
		for (int c = 0; c < children.getLength(); c++) {
			Node child = children.item(c);
			try {
				if (child.getNodeType() == Node.TEXT_NODE) {
					String value = child.getNodeValue();
					if (value != null && value.length() > 0) {
						if (keepAsOriginal(child.getParentNode())) {
							builder.append(value);
						} else {
							builder.append(removeWhitespace(value));
						}
					}
					// Check for formatting elements
				} else if (child.getNodeType() == Node.ELEMENT_NODE
						&& ESCAPE_NODENAME.equals(child.getLocalName())) {
                    assertNamespaceURI(child.getNamespaceURI());
					EncodingCharacters ec = EncodingCharacters.getInstance(datatypeObject
							.getMessage());
					Element elem = (Element) child;
					String attr = elem.getAttribute(ESCAPE_ATTRNAME).trim();
					if (attr.length() > 0) {
						builder.append(ec.getEscapeCharacter()).append(attr)
								.append(ec.getEscapeCharacter());
					}
				}
			} catch (Exception e) {
				log.error("Error parsing primitive value from TEXT_NODE", e);
			}

		}
		datatypeObject.setValue(builder.toString());
	}

	/**
	 * Checks if <code>Node</code> content should be kept as original (ie.: whitespaces won't be
	 * removed)
	 * 
	 * @param node The target <code>Node</code>
	 * @return boolean <code>true</code> if whitespaces should not be removed from node content,
	 *         <code>false</code> otherwise
	 */
	protected boolean keepAsOriginal(Node node) {
		if (getParserConfiguration().isXmlDisableWhitespaceTrimmingOnAllNodes()) {
			return true;
		}
		return (node.getNodeName() != null) && getParserConfiguration().getXmlDisableWhitespaceTrimmingOnNodeNames().contains(node.getNodeName());
	}

	/**
	 * Removes all unnecessary whitespace from the given String (intended to be used with Primitive
	 * values). This includes leading and trailing whitespace, and repeated space characters.
	 * Carriage returns, line feeds, and tabs are replaced with spaces.
	 */
	protected String removeWhitespace(String s) {
		
		s = s.replace('\r', ' ');
		s = s.replace('\n', ' ');
		s = s.replace('\t', ' ');

		boolean repeatedSpacesExist = true;
		while (repeatedSpacesExist) {
			int loc = s.indexOf("  ");
			if (loc < 0) {
				repeatedSpacesExist = false;
			} else {
				StringBuilder buf = new StringBuilder();
				buf.append(s.substring(0, loc));
				buf.append(" ");
				buf.append(s.substring(loc + 2));
				s = buf.toString();
			}
		}
		return s.trim();
	}

	/**
	 * Populates a Composite type by looping through it's children, finding corresponding Elements
	 * among the children of the given Element, and calling parse(Type, Element) for each.
	 */
	private void parseComposite(Composite datatypeObject, Element datatypeElement)
			throws HL7Exception {
		if (datatypeObject instanceof GenericComposite) { // elements won't be named
															// GenericComposite.x
			NodeList children = datatypeElement.getChildNodes();
			int compNum = 0;
			for (int i = 0; i < children.getLength(); i++) {
				if (children.item(i).getNodeType() == Node.ELEMENT_NODE) {
					Element nextElement = (Element) children.item(i);
                    assertNamespaceURI(nextElement.getNamespaceURI());
					String localName = nextElement.getLocalName();
					int dotIndex = localName.indexOf(".");
					if (dotIndex > -1) {
						compNum = Integer.parseInt(localName.substring(dotIndex + 1)) - 1;
					} else {
						log.debug(
								"Datatype element {} doesn't have a valid numbered name, usgin default index of {}",
								datatypeElement.getLocalName(), compNum);
					}
					Type nextComponent = datatypeObject.getComponent(compNum);
					parse(nextComponent, nextElement);
					compNum++;
				}
			}
		} else {
			Type[] children = datatypeObject.getComponents();
			for (int i = 0; i < children.length; i++) {
				NodeList matchingElements = datatypeElement.getElementsByTagNameNS(NS, makeElementName(
						datatypeObject, i + 1));
				if (matchingElements.getLength() > 0) {
					parse(children[i], (Element) matchingElements.item(0));
				}
			}
			
			int nextExtraCmpIndex = 0;
			boolean foundExtraComponent;
			do {
				foundExtraComponent = false;
				NodeList matchingElements = datatypeElement.getElementsByTagNameNS(NS, makeElementName(datatypeObject, children.length + nextExtraCmpIndex + 1));
				if (matchingElements.getLength() > 0) {
					parse(datatypeObject.getExtraComponents().getComponent(nextExtraCmpIndex), (Element) matchingElements.item(0));
					foundExtraComponent = true;
				}
				nextExtraCmpIndex++;
			} while (foundExtraComponent);
			
			
		}
	}

	/** Returns the expected XML element name for the given child of the given Segment */
	private String makeElementName(Segment s, int child) {
		return s.getName() + "." + child;
	}

	/** Returns the expected XML element name for the given child of the given Composite */
	private String makeElementName(Composite composite, int child) {
		return composite.getName() + "." + child;
	}

	/**
	 * Populates the given Element with data from the given Type, by inserting Elements
	 * corresponding to the Type's components and values. Returns true if the given type contains a
	 * value (i.e. for Primitives, if getValue() doesn't return null, and for Composites, if at
	 * least one underlying Primitive doesn't return null).
	 */
	private boolean encode(Type datatypeObject, Element datatypeElement) throws DataTypeException {
		boolean hasData = false;
		if (datatypeObject instanceof Varies) {
			hasData = encodeVaries((Varies) datatypeObject, datatypeElement);
		} else if (datatypeObject instanceof Primitive) {
			hasData = encodePrimitive((Primitive) datatypeObject, datatypeElement);
		} else if (datatypeObject instanceof Composite) {
			hasData = encodeComposite((Composite) datatypeObject, datatypeElement);
		}
		return hasData;
	}

	/**
	 * Encodes a Varies type by extracting it's data field and encoding that. Returns true if the
	 * data field (or one of its components) contains a value.
	 */
	private boolean encodeVaries(Varies datatypeObject, Element datatypeElement)
			throws DataTypeException {
		boolean hasData = false;
		if (datatypeObject.getData() != null) {
			hasData = encode(datatypeObject.getData(), datatypeElement);
		}
		return hasData;
	}

	/**
	 * Encodes a Primitive in XML by adding it's value as a child of the given Element. Detects
	 * escape character and creates proper <escape> elements in the DOM tree. Returns true if the
	 * given Primitive contains a value.
	 */
	private boolean encodePrimitive(Primitive datatypeObject, Element datatypeElement)
			throws DataTypeException {
		String value = datatypeObject.getValue();
		boolean hasValue = (value != null && value.length() > 0);
		if (hasValue) {
			try {
				EncodingCharacters ec = EncodingCharacters.getInstance(datatypeObject.getMessage());
				char esc = ec.getEscapeCharacter();
				int pos;
				int oldpos = 0;
				boolean escaping = false;

				// Find next escape character
				while ((pos = value.indexOf(esc, oldpos)) >= 0) {

					// string until next escape character
					String v = value.substring(oldpos, pos);
					if (!escaping) {
						// currently in "text mode", so create textnode from it
						if (v.length() > 0)
							datatypeElement.appendChild(datatypeElement.getOwnerDocument()
									.createTextNode(v));
						escaping = true;
					} else {
						if (v.startsWith(".") || "H".equals(v) || "N".equals(v)) {
							// currently in "escape mode", so create escape element from it
							Element escape = datatypeElement.getOwnerDocument().createElement(
									ESCAPE_NODENAME);
							escape.setAttribute(ESCAPE_ATTRNAME, v);
							datatypeElement.appendChild(escape);
							escaping = false;
						} else {
							// no proper escape sequence, assume text
							datatypeElement.appendChild(datatypeElement.getOwnerDocument()
									.createTextNode(esc + v));
						}
					}
					oldpos = pos + 1;
				}
				// create text from the remainder
				if (oldpos <= value.length()) {

					StringBuilder sb = new StringBuilder();
					// If we are in escaping mode, there appears no closing escape character,
					// so we treat the string as text
					if (escaping)
						sb.append(esc);

					sb.append(value.substring(oldpos));
					datatypeElement.appendChild(datatypeElement.getOwnerDocument().createTextNode(
							sb.toString()));
				}

			} catch (Exception e) {
				throw new DataTypeException("Exception encoding Primitive: ", e);
			}

		}
		return hasValue;
	}

	/**
	 * Encodes a Composite in XML by looping through it's components, creating new children for each
	 * of them (with the appropriate names) and populating them by calling encode(Type, Element)
	 * using these children. Returns true if at least one component contains a value.
	 */
	private boolean encodeComposite(Composite datatypeObject, Element datatypeElement)
			throws DataTypeException {
		Type[] components = datatypeObject.getComponents();
		boolean hasValue = false;
		for (int i = 0; i < components.length; i++) {
			String name = makeElementName(datatypeObject, i + 1);
			Element newNode = datatypeElement.getOwnerDocument().createElement(name);
			boolean componentHasValue = encode(components[i], newNode);
			if (componentHasValue) {
				try {
					datatypeElement.appendChild(newNode);
				} catch (DOMException e) {
					throw new DataTypeException("DOMException encoding Composite: ", e);
				}
				hasValue = true;
			}
		}
		return hasValue;
	}

	/**
	 * <p>
	 * Returns a minimal amount of data from a message string, including only the data needed to
	 * send a response to the remote system. This includes the following fields:
	 * <ul>
	 * <li>field separator</li>
	 * <li>encoding characters</li>
	 * <li>processing ID</li>
	 * <li>message control ID</li>
	 * </ul>
	 * This method is intended for use when there is an error parsing a message, (so the Message
	 * object is unavailable) but an error message must be sent back to the remote system including
	 * some of the information in the inbound message. This method parses only that required
	 * information, hopefully avoiding the condition that caused the original error.
	 * </p>
	 */
	public Segment getCriticalResponseData(String message) throws HL7Exception {
		String version = getVersion(message);
		Segment criticalData = Parser.makeControlMSH(version, getFactory());

		Terser.set(criticalData, 1, 0, 1, 1, parseLeaf(message, "MSH.1", 0));
		Terser.set(criticalData, 2, 0, 1, 1, parseLeaf(message, "MSH.2", 0));
		Terser.set(criticalData, 10, 0, 1, 1, parseLeaf(message, "MSH.10", 0));
		String procID = parseLeaf(message, "MSH.11", 0);
		if (procID == null || procID.length() == 0) {
			procID = parseLeaf(message, "PT.1", message.indexOf("MSH.11"));
			// this field is a composite in later versions
		}
		Terser.set(criticalData, 11, 0, 1, 1, procID);

		return criticalData;
	}

	/**
	 * For response messages, returns the value of MSA-2 (the message ID of the message sent by the
	 * sending system). This value may be needed prior to main message parsing, so that
	 * (particularly in a multi-threaded scenario) the message can be routed to the thread that sent
	 * the request. We need this information first so that any parse exceptions are thrown to the
	 * correct thread. Implementers of Parsers should take care to make the implementation of this
	 * method very fast and robust. Returns null if MSA-2 can not be found (e.g. if the message is
	 * not a response message). Trims whitespace from around the MSA-2 field.
	 */
	public String getAckID(String message) {
		String ackID = null;
		try {
			ackID = parseLeaf(message, "msa.2", 0).trim();
		} catch (HL7Exception e) { /* OK ... assume it isn't a response message */
		}
		return ackID;
	}

	public String getVersion(String message) throws HL7Exception {
        String version = parseLeaf(message, "MSH.12", 0);
        if (version == null || version.trim().length() == 0) {
            version = parseLeaf(message, "VID.1", message.indexOf("MSH.12"));
        }
        return version;	    
	}

	/**
	 * Attempts to retrieve the value of a leaf tag without using DOM or SAX. This method searches
	 * the given message string for the given tag name, and returns everything after the given tag
	 * and before the start of the next tag. Whitespace is stripped. This is intended only for lead
	 * nodes, as the value is considered to end at the start of the next tag, regardless of whether
	 * it is the matching end tag or some other nested tag.
	 * 
	 * @param message a string message in XML form
	 * @param tagName the name of the XML tag, e.g. "MSA.2"
	 * @param startAt the character location at which to start searching
	 * @throws HL7Exception if the tag can not be found
	 */
	protected static String parseLeaf(String message, String tagName, int startAt) throws HL7Exception {

        // Workaround #176: XML may include explicit namespaces. It would be more stable to use some
        // kind of pull parser for this method instead of manually digging for tags in the XML structure.
        String prefix = "";
        Matcher m = NS_PATTERN.matcher(message);
        if (m.find()) {
            String ns = m.group(1);
            if (ns != null && ns.length() > 0) {
                prefix = ns.substring(1) + ":";
            }
        }

		int tagStart = message.indexOf("<" + prefix + tagName, startAt);
		if (tagStart < 0)
			tagStart = message.indexOf("<" + prefix + tagName.toUpperCase(), startAt);
		int valStart = message.indexOf(">", tagStart) + 1;
		int valEnd = message.indexOf("<", valStart);

        String value;
		if (tagStart >= 0 && valEnd >= valStart) {
			value = message.substring(valStart, valEnd);
		} else {
			throw new HL7Exception("Couldn't find " + tagName + " in message beginning: "
					+ message.substring(0, Math.min(150, message.length())),
					ErrorCode.REQUIRED_FIELD_MISSING);
		}

		// Escape codes, as defined at http://hdf.ncsa.uiuc.edu/HDF5/XML/xml_escape_chars.htm
		value = value.replaceAll("&quot;", "\"");
		value = value.replaceAll("&apos;", "'");
		value = value.replaceAll("&amp;", "&");
		value = value.replaceAll("&lt;", "<");
		value = value.replaceAll("&gt;", ">");

		return value;
	}

	/**
	 * Throws unsupported operation exception
	 * 
	 * @throws UnsupportedOperationException
	 */
	@Override
	public String doEncode(Segment structure, EncodingCharacters encodingCharacters)
			throws HL7Exception {
		throw new UnsupportedOperationException("Not supported yet.");
	}

	/**
	 * Throws unsupported operation exception
	 * 
	 * @throws UnsupportedOperationException
	 */
	@Override
	protected Message doParseForSpecificPackage(String theMessage, String theVersion,
			String thePackageName) throws HL7Exception {
		throw new UnsupportedOperationException("Not supported yet.");
	}

	/**
	 * Throws unsupported operation exception
	 * 
	 * @throws UnsupportedOperationException
	 */
	@Override
	public String doEncode(Type type, EncodingCharacters encodingCharacters) throws HL7Exception {
		throw new UnsupportedOperationException("Not supported yet.");
	}

	/**
	 * Throws unsupported operation exception
	 * 
	 * @throws UnsupportedOperationException
	 */
	@Override
	public void parse(Type type, String string, EncodingCharacters encodingCharacters)
			throws HL7Exception {
		throw new UnsupportedOperationException("Not supported yet.");
	}

	/**
	 * Throws unsupported operation exception
	 * 
	 * @throws UnsupportedOperationException
	 */
	@Override
	public void parse(Segment segment, String string, EncodingCharacters encodingCharacters)
			throws HL7Exception {
		throw new UnsupportedOperationException("Not supported yet.");
	}

	/**
	 * Returns the text encoding to be used in generating new messages. Note that this affects
	 * encoding to string only, not parsing.
	 * 
	 * @return text encoding
	 */
	public String getTextEncoding() {
		return textEncoding;
	}

	/**
	 * Sets the text encoding to be used in generating new messages. Note that this affects encoding
	 * to string only, not parsing.
	 * 
	 * @param textEncoding The encoding. Default is the platform default.
	 */
	public void setTextEncoding(String textEncoding) {
		this.textEncoding = textEncoding;
	}

}