/*
    * Copyright 1999-2006 Faculty of Mathematics, Physics and Informatics, Comenius
    * University, Bratislava. This file is protected by 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://euromath2.sourceforge.net/license.html Unless required by applicable
    * law or agreed to in writing, software distributed under the License is
    * distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
    * KIND, either express or implied. See the License for the specific language
   * governing permissions and limitations under the License.
   */
  package sk.uniba.euromath.document;
  import java.util.Collections;
  import java.util.HashMap;
  import java.util.HashSet;
  import java.util.Map;
  import java.util.Set;
  import java.util.StringTokenizer;
  import javax.xml.XMLConstants;
  import org.w3c.dom.Attr;
  import org.w3c.dom.Element;
  import org.w3c.dom.EntityReference;
  import org.w3c.dom.NamedNodeMap;
  import org.w3c.dom.Node;
  import org.w3c.dom.traversal.DocumentTraversal;
  import org.w3c.dom.traversal.NodeFilter;
  import org.w3c.dom.traversal.NodeIterator;
  import sk.baka.ikslibs.DOMUtils;
  import sk.baka.ikslibs.UnremovableNodeException;
  import sk.baka.ikslibs.ids.IDManager;
  import sk.baka.ikslibs.modify.DOMMutils;
  import sk.uniba.euromath.Const;
  import sk.uniba.euromath.config.EuromathConfig;
  import sk.uniba.euromath.config.bind.NamespaceType;
  import sk.uniba.euromath.document.lang.Messages;
  import sk.uniba.euromath.tools.StringTools;
  /***
   * <p>
   * Manages prefixes in given document. Upon constructing, namespace prefixes are
   * unified by following algorithm:
   * </p>
   * <ul>
   * <li>Prefix for all namespace definitions are remembered, one for each
   * namespace definition (by the <code>xmlns</code> attribute). First prefix
   * definition is taken.</li>
   * <li>If mapping defines no prefix for non-empty namespace (for example,
   * <code>xmlns="foo:bar"</code>), then this prefix definition is not
   * remembered. Instead, next prefix definition is remembered.</li>
   * <li>All <code>xmlns:foo=""</code> definitions are processed as if the
   * <code>xmlns=""</code> was encountered - empty namespaces are thus mapped to
   * empty prefix.</li>
   * <li>Then, all <code>xmlns</code> definitions are removed.</li>
   * <li>All namespaces, that doesn't have prefix defined, are given new prefix,
   * generated via <code>getPreferredPrefix()</code> function.</li>
   * <li>Then, all element's prefixes are set, so following is true: any two
   * elements, that have same namespace, has same prefix.</li>
   * </ul>
   * <p>
   * As a result, document (except descendants of entity reference nodes) is
   * stripped of <code>xmlns</code> attributes.
   * </p>
   * <p>
   * Thread unsafe.
   * </p>
   * <p>
   * Even when all elements/attributes from some namespaces are removed the
   * mapping is not deleted automatically. It is removed when the manager is
   * queried for all known namespaces, using {@link #getAllNamespaces()},
   * {@link #getCounts()} or {@link #getElementNamespaces()} methods.
   * </p>
   * @author Martin Vysny
   */
  public final class NamespaceManager {
  	/***
  	 * Returns preferred prefix for given namespace due to the emConfig.
  	 * @param namespaceUri return preferred prefix for this namespace.
  	 * @return preferred prefix from configFile, or <code>null</code> if none
  	 * had been found.
  	 */
  	private static String getPreferredPrefix(String namespaceUri) {
  		NamespaceType ns = EuromathConfig.getNamespace(namespaceUri);
  		if (ns == null) {
  			// we have no preferred prefixes for this namespace, return null.
  			return null;
  		}
  		return ns.getDefaultPrefix();
  	}
  	/***
  	 * Reference to document.
  	 */
  	private final DomCore doc;
  	/***
  	 * Maps namespace URI to prefix name. Must be consistent with
  	 * <code>mapPrefixToNs</code> map.
  	 */
  	private final Map<String, String> mapNsToPrefix = new HashMap<String, String>();
  	/***
  	 * Maps prefix to namespace URI. Must be consistent with
  	 * <code>mapNsToPrefix</code> map.
 	 */
 	private final Map<String, String> mapPrefixToNs = new HashMap<String, String>();
 	/***
 	 * <p>
 	 * Contains all namespaces present in the document. This may contain more
 	 * namespaces than the two maps because entity reference may introduce new
 	 * namespace and that is not prefix-normalized. It is always superset of
 	 * <code>mapNsToPrefix.keySet()</code>.
 	 * </p>
 	 * <p>
 	 * Maps namespace to a counter that counts elements and attributes with
 	 * given namespace. The counter may be zero only when namespace is declared
 	 * but no elements/attributes with the namespace are present in the
 	 * document. In this case, when
 	 */
 	private final Map<String, NodeCount> allNamespaces = new HashMap<String, NodeCount>();
 	/***
 	 * Class holding elements and attributes count. Mutable.
 	 * @author Martin Vysny
 	 */
 	public static final class NodeCount {
 		/***
 		 * Count of <code>Element</code> nodes.
 		 */
 		public int elements = 0;
 		/***
 		 * Count of <code>Attribute</code> nodes.
 		 */
 		public int attributes = 0;
 		/***
 		 * Constructs zero counter.
 		 */
 		public NodeCount() {
 			super();
 		}
 		/***
 		 * Copy-constructor.
 		 * @param other copies the object.
 		 */
 		public NodeCount(final NodeCount other) {
 			this();
 			elements = other.elements;
 			attributes = other.attributes;
 		}
 		/***
 		 * Returns count of all nodes.
 		 * @return sum of <code>elements</code> and <code>attributes</code>.
 		 */
 		public int getCount() {
 			assert elements >= 0 && attributes >= 0;
 			return elements + attributes;
 		}
 		/*
 		 * (non-Javadoc)
 		 * @see java.lang.Object#equals(java.lang.Object)
 		 */
 		@Override
 		public boolean equals(Object obj) {
 			if (this == obj)
 				return true;
 			if (!(obj instanceof NodeCount))
 				return false;
 			final NodeCount that = (NodeCount) obj;
 			return that.attributes == attributes && that.elements == elements;
 		}
 		/*
 		 * (non-Javadoc)
 		 * @see java.lang.Object#hashCode()
 		 */
 		@Override
 		public int hashCode() {
 			return attributes * 2407 + elements;
 		}
 		/*
 		 * (non-Javadoc)
 		 * @see java.lang.Object#toString()
 		 */
 		@Override
 		public String toString() {
 			return "e#" + elements + ";a#" + attributes; //$NON-NLS-1$ //$NON-NLS-2$
 		}
 	}
 	/***
 	 * Parent namespace mananger.
 	 */
 	private final NamespaceManager parent;
 	/***
 	 * Creates an empty namespace manager.
 	 * @param doc the document. It is not unified when using this constructor.
 	 * @param parent parent namespace manager.
 	 */
 	private NamespaceManager(DomCore doc, NamespaceManager parent) {
 		super();
 		this.doc = doc;
 		this.parent = parent;
 	}
 	/***
 	 * Constructs a namespace manager, and modifies the document by unificating
 	 * all namespace prefixes.
 	 * @param doc document, that will be managed.
 	 * @throws DocumentException if an unremovable xmlns attribute occured.
 	 */
 	NamespaceManager(DomCore doc) throws DocumentException {
 		this(doc, null);
 		// maps namespaceURI to prefix name, and serves for remembering of last
 		// wanted prefix name.
 		if (doc.getDocument().getDocumentElement() != null) {
 			Map<String, String> lastPrefixName = new HashMap<String, String>();
 			try {
 				// 1st part:
 				// - get map of all namespaces and their prefixes
 				// - remove all xmlns attributes
 				mapPrefixes(lastPrefixName);
 				// 2nd part:
 				// - complete the prefixes sets
 				// - unify all prefixes
 				unifyPrefixes(lastPrefixName);
 			} catch (UnremovableNodeException ex) {
 				throw new DocumentException(ex);
 			}
 		}
 	}
 	/***
 	 * Constructs a namespace manager, that is a child of given namespace
 	 * manager. Document is not modified, changes to this namespace manager are
 	 * not displayed in parent manager.
 	 * @param parent parent namespace manager.
 	 */
 	public NamespaceManager(NamespaceManager parent) {
 		this(parent.doc, parent);
 	}
 	/***
 	 * Get map of all namespaces and their prefixes. When colliding prefix is
 	 * encountered, it is not processed by this method. Removes all
 	 * <code>xmlns</code> attributes also.
 	 * @param lastPrefixName maps namespaceURI to prefix name, and serves for
 	 * remembering of last wanted prefix name.
 	 * @throws UnremovableNodeException if an unremovable xmlns attribute
 	 * occured.
 	 */
 	private void mapPrefixes(Map<String, String> lastPrefixName)
 			throws DocumentException {
 		NodeIterator iterator = ((DocumentTraversal) doc.getDocument())
 				.createNodeIterator(doc.getDocument().getDocumentElement(),
 						NodeFilter.SHOW_ELEMENT, null, false);
 		for (Element actNode = (Element) iterator.nextNode(); actNode != null; actNode = (Element) iterator
 				.nextNode()) {
 			checkEMReserved(actNode);
 			final boolean inEntity = DOMUtils.isInEntity(actNode);
 			final String namespace = StringTools.nonNullStr(actNode
 					.getNamespaceURI());
 			final String prefix = actNode.getPrefix();
 			if (DOMUtils.equalsURI(namespace, null)) {
 				addNode(actNode, inEntity);
 			} else {
 				if (processPrefix(namespace, prefix, lastPrefixName)) {
 					addNode(actNode, inEntity);
 				}
 			}
 			// remove the xmlns* attribute
 			DOMMutils.removeXmlns(actNode);
 			// check namespaces of all attributes
 			final NamedNodeMap attrs = actNode.getAttributes();
 			if (attrs != null) {
 				for (int i = 0; i < attrs.getLength(); i++) {
 					final Attr a = (Attr) attrs.item(i);
 					checkEMReserved(a);
 					// check if the attribute has same namespace as its owner
 					// element
 					if (DOMUtils.equalsURI(a.getNamespaceURI(), namespace))
 						throw new DocumentException(
 								Messages
 										.getString(
 												"ELEMENT_ATTR_NS_EQUALS_ERROR", DOMUtils.printQName(actNode), DOMUtils.printQName(a))); //$NON-NLS-1$
 					// process this prefix only if it unifiable.
 					if (isUnifiable(a)) {
 						if (processPrefix(StringTools.nonNullStr(a
 								.getNamespaceURI()), a.getPrefix(),
 								lastPrefixName)) {
 							addNode(a, inEntity);
 						}
 					}
 				}
 			}
 		}
 	}
 	/***
 	 * Process pair of namespace;prefix. If this prefix is empty, equal to
 	 * reserved XML or <code>emp</code> prefix or already defined, then it is
 	 * not added to <code>mapNsToPrefix</code> and <code>mapPrefixToNs</code>.
 	 * @param namespaceUri the namespace. Must not be empty string.
 	 * @param prefix desired prefix.
 	 * @param lastPrefixName if prefix is already used, then it is stored here
 	 * for later processing.
 	 * @return <code>true</code> if the prefix must be registered immediately,
 	 * <code>false</code> if it will be registered in second pass.
 	 */
 	private boolean processPrefix(String namespaceUri, String prefix,
 			Map<String, String> lastPrefixName) {
 		// if we don't know this namespace yet, then remember its prefix.
 		// empty namespace must be mapped to empty prefix, so there's no
 		// need to remember the empty namespace;anything pair.
 		if (!DOMUtils.equalsURI(namespaceUri, null)
 				&& !DOMUtils.equalsURI(namespaceUri, Const.EM_URI)
 				&& !mapNsToPrefix.containsKey(namespaceUri)
 				&& !isReservedPrefix(prefix)) {
 			// this works both for elements and attributes. With elements, we
 			// can't map non-empty namespace to empty prefix, nor reserved
 			// emp: prefix. With attributes, empty namespace prefix selects
 			// its parent element's namespace, that is already processed.
 			if ((StringTools.nullStr(prefix) != null)
 					&& (!prefix.equals(Const.EM_URI_PREFIX))
 					&& !isReservedPrefix(prefix)) {
 				if (mapPrefixToNs.containsKey(prefix)) {
 					// oops, this prefix is already used.
 					// just remember it as 'wanted' namespace prefix. it will
 					// be used later.
 					lastPrefixName.put(namespaceUri, prefix);
 				} else {
 					return true;
 				}
 			}
 		}
 		return false;
 	}
 	/***
 	 * Unifies the prefixes. First, it completes the prefix map and set, and
 	 * then unifies prefixes by replacing them with one prefix for each
 	 * namespace.
 	 * @param lastPrefixName helps picking correct prefix name, if needed.
 	 */
 	private void unifyPrefixes(Map<String, String> lastPrefixName) {
 		NodeIterator iterator = ((DocumentTraversal) doc.getDocument())
 				.createNodeIterator(doc.getDocument().getDocumentElement(),
 						NodeFilter.SHOW_ELEMENT
 								| NodeFilter.SHOW_ENTITY_REFERENCE, null, false);
 		for (Node actNode = iterator.nextNode(); actNode != null; actNode = iterator
 				.nextNode()) {
 			if (actNode.getNodeType() == Node.ENTITY_REFERENCE_NODE) {
 				addEntityNamespaces((EntityReference) actNode);
 				continue;
 			}
 			// the node is an element, we may unify its prefix
 			unifyPrefix(actNode, lastPrefixName);
 			NamedNodeMap attrs = actNode.getAttributes();
 			for (int i = 0; i < attrs.getLength(); i++) {
 				Attr attr = (Attr) attrs.item(i);
 				unifyPrefix(attr, lastPrefixName);
 			}
 		}
 		iterator.detach();
 	}
 	/***
 	 * Unifies prefix, and sets it to node, if required.
 	 * @param node node to unify
 	 * @param lastPrefixName helps picking correct prefix name, if needed.
 	 */
 	private void unifyPrefix(Node node, Map<String, String> lastPrefixName) {
 		// check if this node isn't reserved XML node. If yes, then quit with
 		// no modifications - its prefix can't be changed.
 		if (!isUnifiable(node))
 			return;
 		final String namespace = StringTools.nonNullStr(node.getNamespaceURI());
 		if (!DOMUtils.equalsURI(namespace, Const.EM_URI)) {
 			if (!DOMUtils.equalsURI(namespace, null)) {
 				// the prefix, picked for this namespace. All nodes with this
 				// namespace must have this prefix.
 				String prefix = mapNsToPrefix.get(namespace);
 				// we have non-null namespace, thus prefix must not be null
 				if (prefix == null) {
 					prefix = getAlternativePrefix(namespace, lastPrefixName);
 				}
 				if (!prefix.equals(node.getPrefix()))
 					node.setPrefix(prefix);
 			} else {
 				String prefix = node.getPrefix();
 				if (StringTools.nullStr(prefix) != null)
 					node.setPrefix(null);
 			}
 			// register this node.
 			addNode(node, DOMUtils.isInEntity(node));
 		}
 	}
 	/***
 	 * Registers a node into <code>mapNsToPrefix</code>,
 	 * <code>mapPrefixToNs</code> and <code>allNamespaces</code>. Function
 	 * fails if a namespace is already registered to a prefix and the prefix
 	 * does not match.
 	 * @param node node to register, element or attribute node only. Ignores
 	 * child nodes.
 	 * @param inEntity if <code>true</code> then the node is not registered in
 	 * <code>mapNsToPrefix</code> and <code>mapPrefixToNs</code> maps.
 	 */
 	private void addNode(final Node node, final boolean inEntity) {
 		final short nodeType = node.getNodeType();
 		assert (nodeType == Node.ATTRIBUTE_NODE)
 				|| (nodeType == Node.ELEMENT_NODE) : "Not an element/attribute node"; //$NON-NLS-1$
 		final String ns = StringTools.nonNullStr(node.getNamespaceURI());
 		addMapping(inEntity, ns, node.getPrefix());
 		// increase count of nodes from this namespace
 		final NodeCount cnt = allNamespaces.get(ns);
 		if (nodeType == Node.ELEMENT_NODE)
 			cnt.elements++;
 		else
 			cnt.attributes++;
 	}
 	/***
 	 * Registers a mapping into <code>mapNsToPrefix</code>,
 	 * <code>mapPrefixToNs</code> and <code>allNamespaces</code>. Function
 	 * fails if a namespace is already registered to a prefix and the prefix
 	 * does not match.
 	 * @param inEntity if <code>true</code> then the node is not registered in
 	 * <code>mapNsToPrefix</code> and <code>mapPrefixToNs</code> maps.
 	 * @param namespace the namespace
 	 * @param prefix prefix.
 	 */
 	private void addMapping(final boolean inEntity, String namespace,
 			String prefix) {
 		namespace = StringTools.nonNullStr(namespace);
 		prefix = StringTools.nonNullStr(prefix);
 		if (!inEntity) {
 			final String registeredPrefix = mapNsToPrefix.get(namespace);
 			if (registeredPrefix != null) {
 				// this namespace is already registered. perform sanity checks
 				if (!registeredPrefix.equals(prefix))
 					throw new IllegalArgumentException("New prefix '" + prefix //$NON-NLS-1$
 							+ "' does not match registered prefix '" //$NON-NLS-1$
 							+ registeredPrefix + "' for namespace [" //$NON-NLS-1$
 							+ namespace + "]"); //$NON-NLS-1$
 				assert mapPrefixToNs.get(registeredPrefix) != null : "mapPrefixToNs inconsistent with mapNsToPrefix"; //$NON-NLS-1$
 				assert mapPrefixToNs.get(registeredPrefix).equals(namespace) : "mapPrefixToNs inconsistent with mapNsToPrefix"; //$NON-NLS-1$
 			} else {
 				// we need to register this prefix.
 				if (DOMUtils.equalsURI(namespace, null) && !prefix.equals("")) //$NON-NLS-1$
 					throw new IllegalArgumentException(
 							"Null namespace must map to null prefix."); //$NON-NLS-1$
 				if (!DOMUtils.equalsURI(namespace, null) && prefix.equals("")) //$NON-NLS-1$
 					throw new IllegalArgumentException(
 							"Non-null namespace must map to non-null prefix."); //$NON-NLS-1$
 				assert !mapPrefixToNs.containsKey(prefix) : "mapPrefixToNs inconsistent with mapNsToPrefix"; //$NON-NLS-1$
 				mapNsToPrefix.put(namespace, prefix);
 				mapPrefixToNs.put(prefix, namespace);
 			}
 		}
 		if (!allNamespaces.containsKey(namespace))
 			allNamespaces.put(namespace, new NodeCount());
 	}
 	/***
 	 * Unregisters a node from <code>mapNsToPrefix</code>,
 	 * <code>mapPrefixToNs</code> and <code>allNamespaces</code>, but only
 	 * if no more nodes with same namespace exists. Function fails if a
 	 * namespace is not registered.
 	 * @param node node to unregister, element or attribute node only. Ignores
 	 * child nodes.
 	 * @param inEntity if <code>true</code> then the node is not unregistered
 	 * from <code>mapNsToPrefix</code> and <code>mapPrefixToNs</code> maps.
 	 */
 	private void removeNode(final Node node, final boolean inEntity) {
 		final short nodeType = node.getNodeType();
 		assert (nodeType == Node.ATTRIBUTE_NODE)
 				|| (nodeType == Node.ELEMENT_NODE) : "Not an element/attribute node"; //$NON-NLS-1$
 		final String ns = StringTools.nonNullStr(node.getNamespaceURI());
 		// decrease count of nodes from this namespace
 		final NodeCount cnt = allNamespaces.get(ns);
 		if (cnt == null)
 			throw new IllegalArgumentException("Unregistered namespace [" + ns //$NON-NLS-1$
 					+ "]"); //$NON-NLS-1$
 		if (nodeType == Node.ELEMENT_NODE) {
 			cnt.elements--;
 			if (cnt.elements < 0)
 				throw new IllegalArgumentException(
 						"Removing unregistered element"); //$NON-NLS-1$
 		} else {
 			cnt.attributes--;
 			if (cnt.attributes < 0)
 				throw new IllegalArgumentException(
 						"Removing unregistered attribute"); //$NON-NLS-1$
 		}
 		// if no nodes with this namespace exists, remove the mapping.
 		if (cnt.getCount() == 0) {
 			removeMapping(ns, inEntity);
 		}
 	}
 	/***
 	 * Removes given mapping from <code>mapNsToPrefix</code>,
 	 * <code>mapPrefixToNs</code> and <code>allNamespaces</code>. Fails if
 	 * the mapping is not yet registered.
 	 * @param namespace the namespace to unregister.
 	 * @param inEntity if <code>true</code> then the node is not unregistered
 	 * from <code>mapNsToPrefix</code> and <code>mapPrefixToNs</code> maps.
 	 */
 	private void removeMapping(String namespace, final boolean inEntity) {
 		namespace = StringTools.nonNullStr(namespace);
 		// remove nodecount info.
 		final NodeCount cnt = allNamespaces.get(namespace);
 		if (cnt == null)
 			throw new IllegalArgumentException("Unknown namespace: [" //$NON-NLS-1$
 					+ namespace + "]"); //$NON-NLS-1$
 		if (cnt.getCount() != 0)
 			throw new IllegalStateException("There are still some nodes for [" //$NON-NLS-1$
 					+ namespace + "]"); //$NON-NLS-1$
 		if (!inEntity) {
 			// remove prefix-namespace mappings if necessary
 			final String prefix = mapNsToPrefix.get(namespace);
 			if (prefix != null) {
 				assert mapPrefixToNs.get(prefix).equals(namespace) : "maps are inconsistent"; //$NON-NLS-1$
 				mapNsToPrefix.remove(namespace);
 				mapPrefixToNs.remove(prefix);
 			}
 		}
 		allNamespaces.remove(namespace);
 	}
 	/***
 	 * <p>
 	 * Finds alternative prefix for given namespace. Alternate prefix is
 	 * returned by these rules:
 	 * <ol>
 	 * <li>Prefix defined in the emConfig file, if defined.</li>
 	 * <li>lastPrefixName, if defined.</li>
 	 * <li>Last path element from uri path.</li>
 	 * <li>The string <code>"nsp"</code>, meaning namespace prefix.</li>
 	 * </ol>
 	 * </p>
 	 * <p>
 	 * If returned prefix is already used, then some number is added to prefix
 	 * name, until unique prefix name is found.
 	 * </p>
 	 * @param namespaceUri namespace, for which the prefix will be created. Must
 	 * not be <code>null</code> nor empty string.
 	 * @param lastPrefixName last used prefix name for this namespace. If
 	 * <code>null</code>, second step is skipped.
 	 * @return unique prefix, never <code>null</code> nor empty string.
 	 */
 	private String getAlternativePrefix(String namespaceUri,
 			Map<String, String> lastPrefixName) {
 		String result = NamespaceManager.getPreferredPrefix(namespaceUri);
 		if (!isValidPrefix(result))
 			result = lastPrefixName == null ? null : lastPrefixName
 					.get(namespaceUri);
 		if (!isValidPrefix(result))
 			result = getLastPathElement(namespaceUri);
 		if (!isValidPrefix(result))
 			result = "nsp"; //$NON-NLS-1$
 		// ok, we got prefix. Now, try to get unique prefix by adding some
 		// number, if needed.
 		if (!mapPrefixToNs.containsKey(result))
 			return result;
 		int additionalNumber = 2;
 		String newPrefix;
 		do {
 			newPrefix = result + Integer.toString(additionalNumber++);
 		} while (mapPrefixToNs.containsKey(newPrefix));
 		return newPrefix;
 	}
 	/***
 	 * Checks whether the given node can be subject to prefix unification. If
 	 * node must not be unified then it must NOT require its namespace to be
 	 * defined. Currently these prefixes are not unifiable: xml reserved
 	 * prefixes starting with the string <code>xml</code> and <code>emp</code>
 	 * prefix.
 	 * @param node node to check.
 	 * @return true if this node prefix-namespace pair can be unified.
 	 */
 	private boolean isUnifiable(Node node) {
 		if (isReserved(node))
 			return false;
 		if (DOMUtils.equalsURI(node.getNamespaceURI(), Const.EM_URI))
 			return false;
 		return true;
 	}
 	/***
 	 * Checks, if given prefix name may be placed safely into the xml file. It
 	 * doesn't check if this prefix is already used, it just check that it isn't
 	 * reserved <code>emp:</code> prefix, and it doesn't start with reserved
 	 * <code>xml</code> prefix.
 	 * @param prefix prefix to check.
 	 * @return true if this prefix is assignable to a normal node.
 	 */
 	private boolean isValidPrefix(String prefix) {
 		if (prefix == null)
 			return false;
 		if (prefix.equals(Const.EM_URI_PREFIX))
 			return false;
 		return !isReservedPrefix(prefix);
 	}
 	/***
 	 * Checks, if given prefix name is reserved for XML use.
 	 * @param prefix prefix to check.
 	 * @return true if prefix is reserved.
 	 */
 	private boolean isReservedPrefix(String prefix) {
 		if (prefix == null)
 			return false;
 		if (prefix.length() < 3)
 			return false;
 		if (prefix.substring(0, 3).equalsIgnoreCase(XMLConstants.XML_NS_PREFIX))
 			return true;
 		return false;
 	}
 	/***
 	 * Checks, if given node is reserved for XML use.
 	 * @param node node to check.
 	 * @return true if this prefix is syntactically placeable into xml.
 	 */
 	private boolean isReserved(Node node) {
 		// only attributes forms a reserved node.
 		if (node.getNodeType() != Node.ATTRIBUTE_NODE)
 			return false;
 		return isReservedPrefix(node.getPrefix())
 				|| DOMUtils.isXmlns((Attr)node);
 	}
 	/***
 	 * Checks if given node namespace is reserved by EuroMath2.
 	 * @param node node to check.
 	 * @return <code>true</code> if namespace is reserved and can not be used
 	 * by users.
 	 */
 	private boolean isEMReserved(Node node) {
 		if (node.getNamespaceURI() == null)
 			return false;
 		return node.getNamespaceURI().startsWith(Const.EM_URI);
 	}
 	/***
 	 * Checks if given node namespace is reserved by EuroMath2.
 	 * @param node node to check
 	 * @throws DocumentException if reserved node is found. <code>emp:id</code>
 	 * is ignored - no exception is thrown.
 	 */
 	private void checkEMReserved(Node node) throws DocumentException {
 		if (DOMUtils.equalsNodeQName(node, Const.EM_ATTRIBUTE_ID_QNAME))
 			return;
 		if (isEMReserved(node)) {
 			throw new DocumentException(
 					Messages
 							.getString(
 									"EM_RESERVED_NAMESPACE_FOUND", node.getNodeName(), node.getNamespaceURI())); //$NON-NLS-1$
 		}
 	}
 	/***
 	 * Returns last longest path element, that doesn't contain whitespace, nor
 	 * one of the following: <code>: / &gt; &lt; ;</code>.
 	 * @param uri uri to parse.
 	 * @return last path element, or <code>null</code> if it doesn't exist.
 	 */
 	private String getLastPathElement(String uri) {
 		StringTokenizer i = new StringTokenizer(uri, "\t\n\r\f/:<>;"); //$NON-NLS-1$
 		String result = null;
 		while (i.hasMoreTokens()) {
 			result = i.nextToken();
 		}
 		return result;
 	}
 	/***
 	 * For each used namespace, except empty namespace, creates xmlns mapping.
 	 * Erases all other xmlns definitions.
 	 * @param e element, where the <code>xmlns</code> attributes will be
 	 * re-created.
 	 */
 	public void createXmlnsAttributes(Element e) {
 		DOMMutils.removeXmlns(e);
 		createXmlnsAttributes(e, mapNsToPrefix.keySet());
 	}
 	/***
 	 * Adds and/or replaces xmlns mapping for all given namespaces in given
 	 * element.
 	 * @param e the element.
 	 * @param namespaces Set of Strings. All these namespaces' mappings are
 	 * added to element.
 	 */
 	public void createXmlnsAttributes(Element e,
 			Set< ? extends String> namespaces) {
 		for (String namespace : namespaces) {
 			Attr attr = createXmlnsAttribute(e, namespace);
 			if (attr != null)
 				e.setAttributeNodeNS(attr);
 		}
 	}
 	/***
 	 * <p>
 	 * Returns all namespaces known to this manager. Returned set cannot be
 	 * modified in any way. <code>null</code> namespace is represented as
 	 * empty string (<code>""</code>), and always maps to empty (
 	 * <code>""</code>) namespace. It never contains the EuroMath namespace,
 	 * xmlns namespace nor xml namespace.
 	 * </p>
 	 * <p>
 	 * All mappings of namespaces no longer present in the document are removed,
 	 * but only for root manager.
 	 * </p>
 	 * @return all namespaces in document.
 	 */
 	public Set<String> getAllNamespaces() {
 		if (parent == null)
 			cleanMappings();
 		return getAllNamespacesInt();
 	}
 	/***
 	 * Returns namespaces of all elements present in the document.Returned set
 	 * cannot be modified in any way. <code>null</code> namespace is
 	 * represented as empty string (<code>""</code>), and always maps to
 	 * empty ( <code>""</code>) namespace. It never contains the EuroMath
 	 * namespace, xmlns namespace nor xml namespace.
 	 * </p>
 	 * <p>
 	 * All mappings of namespaces no longer present in the document are removed.
 	 * </p>
 	 * @return set of all namespaces present in elements.
 	 */
 	public Set<String> getElementNamespaces() {
 		cleanMappings();
 		final Set<String> result = new HashSet<String>();
 		if (parent != null)
 			result.addAll(parent.getElementNamespaces());
 		// walk through all namespaces and add only those present in elements.
 		for (final String namespace : allNamespaces.keySet()) {
 			final NodeCount nc = allNamespaces.get(namespace);
 			if (nc.elements != 0)
 				result.add(namespace);
 		}
 		return result;
 	}
 	/***
 	 * Returns all namespaces known to this manager. Returned set cannot be
 	 * modified in any way. <code>null</code> namespace is represented as
 	 * empty string (<code>""</code>), and always maps to empty (
 	 * <code>""</code>) namespace. It never contains the EuroMath namespace,
 	 * null namespace, xmlns namespace nor xml namespace.
 	 * @return all namespaces in document.
 	 */
 	private Set<String> getAllNamespacesInt() {
 		if (parent == null)
 			return Collections.unmodifiableSet(allNamespaces.keySet());
 		final Set<String> result = new HashSet<String>(parent
 				.getAllNamespaces());
 		result.addAll(allNamespaces.keySet());
 		return Collections.unmodifiableSet(result);
 	}
 	/***
 	 * <p>
 	 * Returns counts of nodes for each namespace. Clones internal map,
 	 * therefore the result may be cached when used multiple times.
 	 * </p>
 	 * <p>
 	 * All mappings of namespaces no longer present in the document are removed.
 	 * </p>
 	 * @return maps namespace URI to a count of nodes with given namespace.
 	 * <code>null</code> namespace is represented as an empty string.
 	 */
 	public Map<String, NodeCount> getCounts() {
 		cleanMappings();
 		final Map<String, NodeCount> result;
 		if (parent == null) {
 			result = new HashMap<String, NodeCount>(allNamespaces.size());
 		} else {
 			result = parent.getCounts();
 		}
 		// clone all NodeCount, just to be sure.
 		for (final String ns : allNamespaces.keySet()) {
 			if (!result.containsKey(ns)) {
 				final NodeCount cnt = allNamespaces.get(ns);
 				result.put(ns, new NodeCount(cnt));
 			}
 		}
 		return result;
 	}
 	/***
 	 * Removes all mappings of namespaces not present in the document. Cleans
 	 * only mappings registered in this instance of manager, it does not clean
 	 * parent manager.
 	 */
 	public void cleanMappings() {
 		// get the obsolete mappings
 		final Set<String> obsolete = new HashSet<String>();
 		for (final String ns : allNamespaces.keySet()) {
 			final NodeCount cnt = allNamespaces.get(ns);
 			if (cnt.getCount() == 0)
 				obsolete.add(ns);
 		}
 		// remove all obsolete mappings
 		for (final String ns : obsolete) {
 			removeMapping(ns, false);
 		}
 	}
 	/***
 	 * <p>
 	 * When creating new element/attribute from another namespace as their
 	 * parent, we can specify new prefix. This function returns the best
 	 * suggestion of new prefix.
 	 * </p>
 	 * <p>
 	 * However, you can ask for every element/attribute's prefix, but there are
 	 * cases, when this prefix is not changeable.
 	 * </p>
 	 * <p>
 	 * Warning: when creating attributes with same namespace as their owner
 	 * element (local namespaces), their prefix AND namespace MUST be null.
 	 * </p>
 	 * @param namespaceUri namespace of new nametree being created.
 	 * @return best prefix name. If no prefix is the best choice, then
 	 * <code>null</code> is returned.
 	 */
 	public String getBestPrefix(String namespaceUri) {
 		if (StringTools.nullStr(namespaceUri) == null)
 			return null;
 		if (DOMUtils.equalsURI(namespaceUri, XMLConstants.XML_NS_URI))
 			return XMLConstants.XML_NS_PREFIX;
 		String result = getPrefix(namespaceUri);
 		if (result != null)
 			return result;
 		return getAlternativePrefix(namespaceUri, null);
 	}
 	/***
 	 * Checks, if the prefix, returned by the <code>getBestPrefix()</code>
 	 * function, is only the best choice for new prefix, or if returned prefix
 	 * MUST be used.
 	 * @param namespaceUri namespace to check.
 	 * @return false, if user can choose virtually any prefix, that is accepted
 	 * by the <code>acceptsNewPrefix()</code> function. True, if only one
 	 * prefix can be used.
 	 */
 	public boolean isBestPrefixRequired(String namespaceUri) {
 		if (StringTools.nullStr(namespaceUri) == null)
 			return true;
 		if (DOMUtils.equalsURI(namespaceUri, XMLConstants.XML_NS_URI))
 			return true;
 		return getPrefix(namespaceUri) != null;
 	}
 	/***
 	 * When creating new element/attribute, check, whether chosen prefix can be
 	 * used.
 	 * @param namespaceUri namespace.
 	 * @param newPrefix desired prefix. When no prefix is desired,
 	 * <code>null</code> must be specified. Only <code>null</code> namespace
 	 * may have <code>null</code> prefix.
 	 * @return true, if this prefix can be set to new element/attribute, false
 	 * if not. The function will not check if the prefix contains illegal
 	 * characters, it merely checks if there is no other registered prefix with
 	 * same name.
 	 */
 	public boolean acceptsNewPrefix(String namespaceUri, String newPrefix) {
 		if (StringTools.nullStr(namespaceUri) == null)
 			return StringTools.nullStr(newPrefix) == null;
 		if (StringTools.nullStr(newPrefix) == null)
 			return false;
 		if (DOMUtils.equalsURI(namespaceUri, Const.EM_URI))
 			return false;
 		if (DOMUtils.equalsURI(namespaceUri, XMLConstants.XML_NS_URI))
 			return XMLConstants.XML_NS_PREFIX.equals(newPrefix);
 		// check if this namespace already exists. If yes then we must use the
 		// prefix already defined.
 		String prefix = getPrefix(namespaceUri);
 		if (prefix != null)
 			return prefix.equals(newPrefix);
 		// check for presence of given prefix. If a prefix is already bound to
 		// some namespace, it cannot be used.
 		String ns = getNamespace(newPrefix);
 		if (ns != null)
 			return false;
 		return true;
 	}
 	/***
 	 * Creates an <code>xmlns</code> attribute, that maps known namespace to
 	 * registered prefix. EuroMath namespace is always mapped to
 	 * <code>emp:</code> prefix. When an empty namespace is given, function
 	 * returns <code>null</code>: empty namespace is always mapped to empty
 	 * prefix, and thus need not to be declared by the <code>xmlns:</code>
 	 * attribute. When an XML namespace is given then <code>null</code> is
 	 * returned aswell.
 	 * @param e element, where to create element.
 	 * @param namespaceUri creates xmlns mapping for this namespace.
 	 * @return xmlns attribute node, or <code>null</code> if no prefix is
 	 * currently mapped to given namespace.
 	 */
 	public Attr createXmlnsAttribute(Element e, String namespaceUri) {
 		if (StringTools.nullStr(namespaceUri) == null)
 			return null;
 		if (DOMUtils.equalsURI(namespaceUri, XMLConstants.XMLNS_ATTRIBUTE_NS_URI))
 			return null;
 		if (DOMUtils.equalsURI(namespaceUri, XMLConstants.XML_NS_URI))
 			return null;
 		final String prefix = getPrefix(namespaceUri);
 		if (prefix == null)
 			return null;
 		final Attr result = DOMMutils.createXmlnsAttribute(e,namespaceUri,prefix);
 		return result;
 	}
 	/***
 	 * Returns prefix, that is currently mapped to given namespace. If no prefix
 	 * is currently mapped, function returns <code>null</code>. EuroMath
 	 * namespace is always mapped to <code>emp:</code> prefix. Empty or
 	 * <code>null</code> namespace ("") is always mapped to empty prefix ("").
 	 * XML namespace is always mapped to <code>xml</code> prefix.
 	 * @param namespaceUri namespace.
 	 * @return prefix, that maps to given namespace. If no prefix is currently
 	 * known for given namespace, it return <code>null</code>.
 	 */
 	public String getPrefix(String namespaceUri) {
 		if (StringTools.nonNullStr(namespaceUri).equals(Const.EM_URI))
 			return Const.EM_URI_PREFIX;
 		if (StringTools.nullStr(namespaceUri) == null)
 			return ""; //$NON-NLS-1$
 		if (DOMUtils.equalsURI(namespaceUri, XMLConstants.XML_NS_URI))
 			return XMLConstants.XML_NS_PREFIX;
 		if (parent != null) {
 			final String result = parent.getPrefix(namespaceUri);
 			if (result != null)
 				return result;
 		}
 		return mapNsToPrefix.get(namespaceUri);
 	}
 	/***
 	 * Returns namespace, that is currently mapped to given prefix. If no
 	 * namespace is currently mapped, function returns <code>null</code>.
 	 * EuroMath namespace is always mapped to <code>emp:</code> prefix. Empty
 	 * or <code>null</code> prefix is always mapped to empty namespace ("").
 	 * @param prefix the prefix.
 	 * @return namespace, that maps to given prefix. If no namespace is
 	 * currently known for given prefix, it returns <code>null</code>.
 	 */
 	public String getNamespace(String prefix) {
 		if (StringTools.nullStr(prefix) == null)
 			return ""; //$NON-NLS-1$
 		if (prefix.equals(Const.EM_URI_PREFIX))
 			return Const.EM_URI;
 		if (parent != null) {
 			final String result = parent.getNamespace(prefix);
 			if (result != null)
 				return result;
 		}
 		return mapPrefixToNs.get(StringTools.nonNullStr(prefix));
 	}
 	/***
 	 * Checks, if given namespace is <strong>defined</strong> in given element.
 	 * For empty namespace always returns true.
 	 * @param namespaceUri namespace
 	 * @param e element
 	 * @return <code>true</code> if this namespace is defined in given element
 	 * with the <code>xmlns:</code> attribute, or if a prefix is registered.
 	 */
 	public boolean isDefined(String namespaceUri, Element e) {
 		if (StringTools.nullStr(namespaceUri) == null)
 			return true;
 		final String prefix = getPrefix(namespaceUri);
 		if (prefix == null)
 			return false;
 		return DOMUtils.getXmlnsNode(prefix, e)!=null;
 	}
 	/***
 	 * Declares the namespace-prefix pair. This operation is not applicable to a
 	 * default namespace manager - it is updated automatically when the document
 	 * is modified. Neither the namespace, nor the prefix can exist in a parent.
 	 * @param namespaceUri the namespace.
 	 * @param prefix the prefix.
 	 * @throws IllegalArgumentException if such prefix-namespace pair cannot be
 	 * registered.
 	 */
 	public void declare(String namespaceUri, String prefix) {
 		if (parent == null)
 			throw new IllegalStateException(
 					"This operation is not applicable to default namespace manager."); //$NON-NLS-1$
 		if (StringTools.nullStr(namespaceUri) == null) {
 			if (StringTools.nullStr(prefix) != null)
 				throw new IllegalArgumentException(
 						"Prefix name must be null when namespace is null."); //$NON-NLS-1$
 			addMapping(false, namespaceUri, prefix);
 		}
 		if (StringTools.nullStr(prefix) == null)
 			throw new IllegalArgumentException("Invalid prefix value."); //$NON-NLS-1$
 		if (parent != null) {
 			if (parent.getPrefix(namespaceUri) != null)
 				throw new IllegalArgumentException(
 						"Namespace is already declared in parent."); //$NON-NLS-1$
 			if (parent.getNamespace(prefix) != null)
 				throw new IllegalArgumentException(
 						"Prefix is already declared in parent."); //$NON-NLS-1$
 		}
 		addMapping(false, namespaceUri, prefix);
 	}
 	/***
 	 * Undeclares given namespace. If the namespace is not declared in this
 	 * manager then the function will fail - we cannot modify parent.
 	 * @param namespaceUri the namespace part of pair.
 	 */
 	public void undeclareNamespace(String namespaceUri) {
 		if (parent == null)
 			throw new IllegalStateException(
 					"This operation is not applicable to default namespace manager."); //$NON-NLS-1$
 		if (StringTools.nullStr(namespaceUri) == null)
 			throw new IllegalArgumentException(
 					"Null namespace cannot be undeclared."); //$NON-NLS-1$
 		String prefix = mapNsToPrefix.get(namespaceUri);
 		if (prefix == null)
 			throw new IllegalArgumentException(
 					"The namespace is not defined in this manager."); //$NON-NLS-1$
 		removeMapping(namespaceUri, false);
 	}
 	/*
 	 * (non-Javadoc)
 	 * @see java.lang.Object#toString()
 	 */
 	@Override
 	public String toString() {
 		final StringBuilder builder = new StringBuilder();
 		for (String ns : getAllNamespacesInt()) {
 			final String prefix = getPrefix(ns);
 			builder.append("[" + prefix + "=" + ns + "] "); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
 		}
 		return builder.toString();
 	}
 	/***
 	 * Listens for changes in the document.
 	 * @author Martin Vysny
 	 */
 	private final class ModifierListener implements IModifierListener {
 		/*
 		 * (non-Javadoc)
 		 * @see sk.uniba.euromath.document.IModifierListener#nodeAdded(org.w3c.dom.Node,
 		 * boolean)
 		 */
 		public void nodeAdded(Node node, boolean changesIdLevel) {
 			// This function must not be called directly!
 			if (parent != null)
 				throw new IllegalStateException(
 						"This method can be called on main manager only"); //$NON-NLS-1$
 			if (node.getNodeType() == Node.ATTRIBUTE_NODE) {
 				final boolean inEntity = DOMUtils.isInEntity(((Attr) node)
 						.getOwnerElement());
 				attributeAdded((Attr) node, inEntity);
 				return;
 			}
 			if ((node.getNodeType() != Node.ELEMENT_NODE)
 					&& (node.getNodeType() != Node.ENTITY_REFERENCE_NODE))
 				return;
 			// walk through the node and its descendants and search for new
 			// namespaces
 			NodeIterator iterator = ((DocumentTraversal) doc.getDocument())
 					.createNodeIterator(node, NodeFilter.SHOW_ELEMENT
 							| NodeFilter.SHOW_ENTITY_REFERENCE, null, false);
 			for (Node e = iterator.nextNode(); e != null; e = iterator
 					.nextNode()) {
 				if (e.getNodeType() == Node.ENTITY_REFERENCE_NODE) {
 					addEntityNamespaces((EntityReference) e);
 					continue;
 				}
 				final boolean inEntity = DOMUtils.isInEntity(e);
 				final String ns = StringTools.nonNullStr(e.getNamespaceURI());
 				final String validPrefix = mapNsToPrefix.get(ns);
 				if (validPrefix != null) {
 					// namespace is known. check the prefix
 					if (!validPrefix.equals(e.getPrefix()))
 						throw new IllegalArgumentException("Element " + e //$NON-NLS-1$
 								+ " must have prefix " + validPrefix); //$NON-NLS-1$
 				} else {
 					// namespace is unknown, register it, but check it first.
 					if (isBestPrefixRequired(ns)) {
 						String forcedPrefix = getBestPrefix(ns);
 						if (!forcedPrefix.equals(e.getPrefix()))
 							throw new IllegalArgumentException("Element " + e //$NON-NLS-1$
 									+ " must have prefix " + forcedPrefix); //$NON-NLS-1$
 					}
 					addNode(e, inEntity);
 				}
 				// check attributes
 				NamedNodeMap attrs = e.getAttributes();
 				if (attrs != null) {
 					for (int i = 0; i < attrs.getLength(); i++) {
 						Attr attr = (Attr) attrs.item(i);
 						attributeAdded(attr, inEntity);
 					}
 				}
 			}
 			iterator.detach();
 		}
 		/***
 		 * Informs that the attribute was added.
 		 * @param attr the attribute that was added.
 		 * @param inEntity if <code>true</code> then owner element resides in
 		 * an entity.
 		 */
 		private void attributeAdded(final Attr attr, final boolean inEntity) {
 			// em2 reserved attributes are not managed
 			if (DOMUtils.equalsURI(attr.getNamespaceURI(), Const.EM_URI)
 					|| isReserved(attr))
 				return;
 			addNode(attr, inEntity);
 		}
 		/*
 		 * (non-Javadoc)
 		 * @see sk.uniba.euromath.document.IModifierListener#nodeDelete(org.w3c.dom.Node,
 		 * boolean)
 		 */
 		public void nodeDelete(Node node, boolean changesIdLevel) {
 			if (parent != null)
 				throw new IllegalStateException(
 						"This method can be called on main manager only"); //$NON-NLS-1$
 			// update node count.
 			nodeDeleteInt(node, DOMUtils.isInEntity(node));
 		}
 		/*
 		 * (non-Javadoc)
 		 * @see sk.uniba.euromath.document.IModifierListener#nodeModified(sk.uniba.euromath.document.ChangeTracer,
 		 * boolean)
 		 */
 		public void nodeModified(ChangeTracer tracer, boolean changesIdLevel) {
 			if (parent != null)
 				throw new IllegalStateException(
 						"This method can be called on main manager only"); //$NON-NLS-1$
 			// do nothing - node modification cannot change namespace
 		}
 	}
 	/***
 	 * The modeifier listener instance.
 	 */
 	final IModifierListener modifierListener = new ModifierListener();
 	/***
 	 * Walks through the descendants of the entity and adds all namespaces found
 	 * in the entity. The entity is not modified - prefixes are not unified.
 	 * @param eRef the entity to check.
 	 */
 	private void addEntityNamespaces(EntityReference eRef) {
 		for (Node child = eRef.getFirstChild(); child != null; child = child
 				.getNextSibling()) {
 			if (child.getNodeType() == Node.ENTITY_REFERENCE_NODE) {
 				addEntityNamespaces((EntityReference) child);
 				continue;
 			}
 			if (child.getNodeType() != Node.ELEMENT_NODE)
 				continue;
 			// the node is an element
 			// check the element itself
 			NodeIterator iterator = ((DocumentTraversal) doc.getDocument())
 					.createNodeIterator(child, NodeFilter.SHOW_ELEMENT
 							| NodeFilter.SHOW_ENTITY_REFERENCE, null, false);
 			for (Node e = iterator.nextNode(); e != null; e = iterator
 					.nextNode()) {
 				if (e.getNodeType() == Node.ENTITY_REFERENCE_NODE) {
 					addEntityNamespaces((EntityReference) e);
 					continue;
 				}
 				// the node is an element
 				if (isUnifiable(e)) {
 					addNode(e, true);
 				}
 				// check attributes
 				NamedNodeMap attrs = e.getAttributes();
 				if (attrs != null) {
 					for (int i = 0; i < attrs.getLength(); i++) {
 						Attr attr = (Attr) attrs.item(i);
 						if ((StringTools.nullStr(attr.getNamespaceURI()) != null)
 								&& isUnifiable(attr)) {
 							addNode(attr, true);
 						}
 					}
 				}
 			}
 			iterator.detach();
 		}
 	}
 	/***
 	 * Calls {@link #removeNode(Node, boolean)} on each descendant node,
 	 * including given node.
 	 * @param node node to unmap
 	 * @param inEntity if <code>true</code> then the node resides in an
 	 * entity.
 	 */
 	private void nodeDeleteInt(final Node node, final boolean inEntity) {
 		switch (node.getNodeType()) {
 			case Node.ENTITY_REFERENCE_NODE: {
 				for (Node child = node.getFirstChild(); child != null; child = child
 						.getNextSibling()) {
 					nodeDeleteInt(child, true);
 				}
 			}
 				break;
 			case Node.ATTRIBUTE_NODE: {
 				if (isUnifiable(node))
 					removeNode(node, inEntity);
 			}
 				break;
 			case Node.ELEMENT_NODE: {
 				if (isUnifiable(node))
 					removeNode(node, inEntity);
 				for (Node child = node.getFirstChild(); child != null; child = child
 						.getNextSibling()) {
 					nodeDeleteInt(child, inEntity);
 				}
 				final NamedNodeMap atts = node.getAttributes();
 				if (atts != null) {
 					for (int i = 0; i < atts.getLength(); i++) {
 						nodeDeleteInt(atts.item(i), inEntity);
 					}
 				}
 			}
 				break;
 		}
 	}
 }