/*
* Copyright (C) 2011 The Android Open Source Project
*
* Licensed under the Eclipse Public License, Version 1.0 (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.eclipse.org/org/documents/epl-v10.php
*
* 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 com.android.ide.eclipse.adt.internal.editors.layout.gle2;
import static com.android.SdkConstants.ANDROID_URI;
import static com.android.SdkConstants.ATTR_ID;
import static com.android.SdkConstants.ID_PREFIX;
import static com.android.SdkConstants.NEW_ID_PREFIX;
import static com.android.SdkConstants.TOOLS_URI;
import static org.eclipse.wst.xml.core.internal.provisional.contenttype.ContentTypeIdForXML.ContentTypeID_XML;
import com.android.annotations.NonNull;
import com.android.annotations.Nullable;
import com.android.ide.eclipse.adt.AdtPlugin;
import com.android.ide.eclipse.adt.internal.editors.AndroidXmlEditor;
import com.android.ide.eclipse.adt.internal.editors.descriptors.DescriptorsUtils;
import com.android.utils.Pair;
import org.eclipse.core.resources.IFile;
import org.eclipse.jface.text.IDocument;
import org.eclipse.wst.sse.core.StructuredModelManager;
import org.eclipse.wst.sse.core.internal.provisional.IModelManager;
import org.eclipse.wst.sse.core.internal.provisional.IStructuredModel;
import org.eclipse.wst.sse.core.internal.provisional.IndexedRegion;
import org.eclipse.wst.sse.core.internal.provisional.text.IStructuredDocument;
import org.eclipse.wst.sse.core.internal.provisional.text.IStructuredDocumentRegion;
import org.eclipse.wst.sse.core.internal.provisional.text.ITextRegion;
import org.eclipse.wst.xml.core.internal.provisional.document.IDOMModel;
import org.eclipse.wst.xml.core.internal.regions.DOMRegionContext;
import org.w3c.dom.Attr;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.InputSource;
import java.io.StringReader;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashSet;
import java.util.List;
import java.util.Locale;
import java.util.Set;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
/**
* Various utility methods for manipulating DOM nodes.
*/
@SuppressWarnings("restriction") // No replacement for restricted XML model yet
public class DomUtilities {
/**
* Finds the nearest common parent of the two given nodes (which could be one of the
* two nodes as well)
*
* @param node1 the first node to test
* @param node2 the second node to test
* @return the nearest common parent of the two given nodes
*/
@Nullable
public static Node getCommonAncestor(@NonNull Node node1, @NonNull Node node2) {
while (node2 != null) {
Node current = node1;
while (current != null && current != node2) {
current = current.getParentNode();
}
if (current == node2) {
return current;
}
node2 = node2.getParentNode();
}
return null;
}
/**
* Returns all elements below the given node (which can be a document,
* element, etc). This will include the node itself, if it is an element.
*
* @param node the node to search from
* @return all elements in the subtree formed by the node parameter
*/
@NonNull
public static List<Element> getAllElements(@NonNull Node node) {
List<Element> elements = new ArrayList<Element>(64);
addElements(node, elements);
return elements;
}
private static void addElements(@NonNull Node node, @NonNull List<Element> elements) {
if (node instanceof Element) {
elements.add((Element) node);
}
NodeList childNodes = node.getChildNodes();
for (int i = 0, n = childNodes.getLength(); i < n; i++) {
addElements(childNodes.item(i), elements);
}
}
/**
* Returns the depth of the given node (with the document node having depth 0,
* and the document element having depth 1)
*
* @param node the node to test
* @return the depth in the document
*/
public static int getDepth(@NonNull Node node) {
int depth = -1;
while (node != null) {
depth++;
node = node.getParentNode();
}
return depth;
}
/**
* Returns true if the given node has one or more element children
*
* @param node the node to test for element children
* @return true if the node has one or more element children
*/
public static boolean hasElementChildren(@NonNull Node node) {
NodeList children = node.getChildNodes();
for (int i = 0, n = children.getLength(); i < n; i++) {
if (children.item(i).getNodeType() == Node.ELEMENT_NODE) {
return true;
}
}
return false;
}
/**
* Returns the DOM document for the given file
*
* @param file the XML file
* @return the document, or null if not found or not parsed properly (no
* errors are generated/thrown)
*/
@Nullable
public static Document getDocument(@NonNull IFile file) {
IModelManager modelManager = StructuredModelManager.getModelManager();
if (modelManager == null) {
return null;
}
try {
IStructuredModel model = modelManager.getExistingModelForRead(file);
if (model == null) {
model = modelManager.getModelForRead(file);
}
if (model != null) {
if (model instanceof IDOMModel) {
IDOMModel domModel = (IDOMModel) model;
return domModel.getDocument();
}
try {
} finally {
model.releaseFromRead();
}
}
} catch (Exception e) {
// Ignore exceptions.
}
return null;
}
/**
* Returns the DOM document for the given editor
*
* @param editor the XML editor
* @return the document, or null if not found or not parsed properly (no
* errors are generated/thrown)
*/
@Nullable
public static Document getDocument(@NonNull AndroidXmlEditor editor) {
IStructuredModel model = editor.getModelForRead();
try {
if (model instanceof IDOMModel) {
IDOMModel domModel = (IDOMModel) model;
return domModel.getDocument();
}
} finally {
if (model != null) {
model.releaseFromRead();
}
}
return null;
}
/**
* Returns the XML DOM node corresponding to the given offset of the given
* document.
*
* @param document The document to look in
* @param offset The offset to look up the node for
* @return The node containing the offset, or null
*/
@Nullable
public static Node getNode(@NonNull IDocument document, int offset) {
Node node = null;
IModelManager modelManager = StructuredModelManager.getModelManager();
if (modelManager == null) {
return null;
}
try {
IStructuredModel model = modelManager.getExistingModelForRead(document);
if (model != null) {
try {
for (; offset >= 0 && node == null; --offset) {
node = (Node) model.getIndexedRegion(offset);
}
} finally {
model.releaseFromRead();
}
}
} catch (Exception e) {
// Ignore exceptions.
}
return node;
}
/**
* Returns the editing context at the given offset, as a pair of parent node and child
* node. This is not the same as just calling {@link DomUtilities#getNode} and taking
* its parent node, because special care has to be taken to return content element
* positions.
* <p>
* For example, for the XML {@code <foo>^</foo>}, if the caret ^ is inside the foo
* element, between the opening and closing tags, then the foo element is the parent,
* and the child is null which represents a potential text node.
* <p>
* If the node is inside an element tag definition (between the opening and closing
* bracket) then the child node will be the element and whatever parent (element or
* document) will be its parent.
* <p>
* If the node is in a text node, then the text node will be the child and its parent
* element or document node its parent.
* <p>
* Finally, if the caret is on a boundary of a text node, then the text node will be
* considered the child, regardless of whether it is on the left or right of the
* caret. For example, in the XML {@code <foo>^ </foo>} and in the XML
* {@code <foo> ^</foo>}, in both cases the text node is preferred over the element.
*
* @param document the document to search in
* @param offset the offset to look up
* @return a pair of parent and child elements, where either the parent or the child
* but not both can be null, and if non null the child.getParentNode() should
* return the parent. Note that the method can also return null if no
* document or model could be obtained or if the offset is invalid.
*/
@Nullable
public static Pair<Node, Node> getNodeContext(@NonNull IDocument document, int offset) {
Node node = null;
IModelManager modelManager = StructuredModelManager.getModelManager();
if (modelManager == null) {
return null;
}
try {
IStructuredModel model = modelManager.getExistingModelForRead(document);
if (model != null) {
try {
for (; offset >= 0 && node == null; --offset) {
IndexedRegion indexedRegion = model.getIndexedRegion(offset);
if (indexedRegion != null) {
node = (Node) indexedRegion;
if (node.getNodeType() == Node.TEXT_NODE) {
return Pair.of(node.getParentNode(), node);
}
// Look at the structured document to see if
// we have the special case where the caret is pointing at
// a -potential- text node, e.g. <foo>^</foo>
IStructuredDocument doc = model.getStructuredDocument();
IStructuredDocumentRegion region =
doc.getRegionAtCharacterOffset(offset);
ITextRegion subRegion = region.getRegionAtCharacterOffset(offset);
String type = subRegion.getType();
if (DOMRegionContext.XML_END_TAG_OPEN.equals(type)) {
// Try to return the text node if it's on the left
// of this element node, such that replace strings etc
// can be computed.
Node lastChild = node.getLastChild();
if (lastChild != null) {
IndexedRegion previousRegion = (IndexedRegion) lastChild;
if (previousRegion.getEndOffset() == offset) {
return Pair.of(node, lastChild);
}
}
return Pair.of(node, null);
}
return Pair.of(node.getParentNode(), node);
}
}
} finally {
model.releaseFromRead();
}
}
} catch (Exception e) {
// Ignore exceptions.
}
return null;
}
/**
* Like {@link #getNode(IDocument, int)}, but has a bias parameter which lets you
* indicate whether you want the search to look forwards or backwards.
* This is vital when trying to compute a node range. Consider the following
* XML fragment:
* {@code
* <a/><b/>[<c/><d/><e/>]<f/><g/>
* }
* Suppose we want to locate the nodes in the range indicated by the brackets above.
* If we want to search for the node corresponding to the start position, should
* we pick the node on its left or the node on its right? Similarly for the end
* position. Clearly, we'll need to bias the search towards the right when looking
* for the start position, and towards the left when looking for the end position.
* The following method lets us do just that. When passed an offset which sits
* on the edge of the computed node, it will pick the neighbor based on whether
* "forward" is true or false, where forward means searching towards the right
* and not forward is obviously towards the left.
* @param document the document to search in
* @param offset the offset to search for
* @param forward if true, search forwards, otherwise search backwards when on node boundaries
* @return the node which surrounds the given offset, or the node adjacent to the offset
* where the side depends on the forward parameter
*/
@Nullable
public static Node getNode(@NonNull IDocument document, int offset, boolean forward) {
Node node = getNode(document, offset);
if (node instanceof IndexedRegion) {
IndexedRegion region = (IndexedRegion) node;
if (!forward && offset <= region.getStartOffset()) {
Node left = node.getPreviousSibling();
if (left == null) {
left = node.getParentNode();
}
node = left;
} else if (forward && offset >= region.getEndOffset()) {
Node right = node.getNextSibling();
if (right == null) {
right = node.getParentNode();
}
node = right;
}
}
return node;
}
/**
* Returns a range of elements for the given caret range. Note that the two elements
* may not be at the same level so callers may want to perform additional input
* filtering.
*
* @param document the document to search in
* @param beginOffset the beginning offset of the range
* @param endOffset the ending offset of the range
* @return a pair of begin+end elements, or null
*/
@Nullable
public static Pair<Element, Element> getElementRange(@NonNull IDocument document,
int beginOffset, int endOffset) {
Element beginElement = null;
Element endElement = null;
Node beginNode = getNode(document, beginOffset, true);
Node endNode = beginNode;
if (endOffset > beginOffset) {
endNode = getNode(document, endOffset, false);
}
if (beginNode == null || endNode == null) {
return null;
}
// Adjust offsets if you're pointing at text
if (beginNode.getNodeType() != Node.ELEMENT_NODE) {
// <foo> <bar1/> | <bar2/> </foo> => should pick <bar2/>
beginElement = getNextElement(beginNode);
if (beginElement == null) {
// Might be inside the end of a parent, e.g.
// <foo> <bar/> | </foo> => should pick <bar/>
beginElement = getPreviousElement(beginNode);
if (beginElement == null) {
// We must be inside an empty element,
// <foo> | </foo>
// In that case just pick the parent.
beginElement = getParentElement(beginNode);
}
}
} else {
beginElement = (Element) beginNode;
}
if (endNode.getNodeType() != Node.ELEMENT_NODE) {
// In the following, | marks the caret position:
// <foo> <bar1/> | <bar2/> </foo> => should pick <bar1/>
endElement = getPreviousElement(endNode);
if (endElement == null) {
// Might be inside the beginning of a parent, e.g.
// <foo> | <bar/></foo> => should pick <bar/>
endElement = getNextElement(endNode);
if (endElement == null) {
// We must be inside an empty element,
// <foo> | </foo>
// In that case just pick the parent.
endElement = getParentElement(endNode);
}
}
} else {
endElement = (Element) endNode;
}
if (beginElement != null && endElement != null) {
return Pair.of(beginElement, endElement);
}
return null;
}
/**
* Returns the next sibling element of the node, or null if there is no such element
*
* @param node the starting node
* @return the next sibling element, or null
*/
@Nullable
public static Element getNextElement(@NonNull Node node) {
while (node != null && node.getNodeType() != Node.ELEMENT_NODE) {
node = node.getNextSibling();
}
return (Element) node; // may be null as well
}
/**
* Returns the previous sibling element of the node, or null if there is no such element
*
* @param node the starting node
* @return the previous sibling element, or null
*/
@Nullable
public static Element getPreviousElement(@NonNull Node node) {
while (node != null && node.getNodeType() != Node.ELEMENT_NODE) {
node = node.getPreviousSibling();
}
return (Element) node; // may be null as well
}
/**
* Returns the closest ancestor element, or null if none
*
* @param node the starting node
* @return the closest parent element, or null
*/
@Nullable
public static Element getParentElement(@NonNull Node node) {
while (node != null && node.getNodeType() != Node.ELEMENT_NODE) {
node = node.getParentNode();
}
return (Element) node; // may be null as well
}
/** Utility used by {@link #getFreeWidgetId(Element)} */
private static void addLowercaseIds(@NonNull Element root, @NonNull Set<String> seen) {
if (root.hasAttributeNS(ANDROID_URI, ATTR_ID)) {
String id = root.getAttributeNS(ANDROID_URI, ATTR_ID);
if (id.startsWith(NEW_ID_PREFIX)) {
// See getFreeWidgetId for details on locale
seen.add(id.substring(NEW_ID_PREFIX.length()).toLowerCase(Locale.US));
} else if (id.startsWith(ID_PREFIX)) {
seen.add(id.substring(ID_PREFIX.length()).toLowerCase(Locale.US));
} else {
seen.add(id.toLowerCase(Locale.US));
}
}
}
/**
* Returns a suitable new widget id (not including the {@code @id/} prefix) for the
* given element, which is guaranteed to be unique in this document
*
* @param element the element to compute a new widget id for
* @param reserved an optional set of extra, "reserved" set of ids that should be
* considered taken
* @param prefix an optional prefix to use for the generated name, or null to get a
* default (which is currently the tag name)
* @return a unique id, never null, which does not include the {@code @id/} prefix
* @see DescriptorsUtils#getFreeWidgetId
*/
public static String getFreeWidgetId(
@NonNull Element element,
@Nullable Set<String> reserved,
@Nullable String prefix) {
Set<String> ids = new HashSet<String>();
if (reserved != null) {
for (String id : reserved) {
// Note that we perform locale-independent lowercase checks; in "Image" we
// want the lowercase version to be "image", not "?mage" where ? is
// the char LATIN SMALL LETTER DOTLESS I.
ids.add(id.toLowerCase(Locale.US));
}
}
addLowercaseIds(element.getOwnerDocument().getDocumentElement(), ids);
if (prefix == null) {
prefix = DescriptorsUtils.getBasename(element.getTagName());
}
String generated;
int num = 1;
do {
generated = String.format("%1$s%2$d", prefix, num++); //$NON-NLS-1$
} while (ids.contains(generated.toLowerCase(Locale.US)));
return generated;
}
/**
* Returns the element children of the given element
*
* @param element the parent element
* @return a list of child elements, possibly empty but never null
*/
@NonNull
public static List<Element> getChildren(@NonNull Element element) {
// Convenience to avoid lots of ugly DOM access casting
NodeList children = element.getChildNodes();
// An iterator would have been more natural (to directly drive the child list
// iteration) but iterators can't be used in enhanced for loops...
List<Element> result = new ArrayList<Element>(children.getLength());
for (int i = 0, n = children.getLength(); i < n; i++) {
Node node = children.item(i);
if (node.getNodeType() == Node.ELEMENT_NODE) {
Element child = (Element) node;
result.add(child);
}
}
return result;
}
/**
* Returns true iff the given elements are contiguous siblings
*
* @param elements the elements to be tested
* @return true if the elements are contiguous siblings with no gaps
*/
public static boolean isContiguous(@NonNull List<Element> elements) {
if (elements.size() > 1) {
// All elements must be siblings (e.g. same parent)
Node parent = elements.get(0).getParentNode();
if (!(parent instanceof Element)) {
return false;
}
for (Element node : elements) {
if (parent != node.getParentNode()) {
return false;
}
}
// Ensure that the siblings are contiguous; no gaps.
// If we've selected all the children of the parent then we don't need
// to look.
List<Element> siblings = DomUtilities.getChildren((Element) parent);
if (siblings.size() != elements.size()) {
Set<Element> nodeSet = new HashSet<Element>(elements);
boolean inRange = false;
int remaining = elements.size();
for (Element node : siblings) {
boolean in = nodeSet.contains(node);
if (in) {
remaining--;
if (remaining == 0) {
break;
}
inRange = true;
} else if (inRange) {
return false;
}
}
}
}
return true;
}
/**
* Determines whether two element trees are equivalent. Two element trees are
* equivalent if they represent the same DOM structure (elements, attributes, and
* children in order). This is almost the same as simply checking whether the String
* representations of the two nodes are identical, but this allows for minor
* variations that are not semantically significant, such as variations in formatting
* or ordering of the element attribute declarations, and the text children are
* ignored (this is such that in for example layout where content is only used for
* indentation the indentation differences are ignored). Null trees are never equal.
*
* @param element1 the first element to compare
* @param element2 the second element to compare
* @return true if the two element hierarchies are logically equal
*/
public static boolean isEquivalent(@Nullable Element element1, @Nullable Element element2) {
if (element1 == null || element2 == null) {
return false;
}
if (!element1.getTagName().equals(element2.getTagName())) {
return false;
}
// Check attribute map
NamedNodeMap attributes1 = element1.getAttributes();
NamedNodeMap attributes2 = element2.getAttributes();
List<Attr> attributeNodes1 = new ArrayList<Attr>();
for (int i = 0, n = attributes1.getLength(); i < n; i++) {
Attr attribute = (Attr) attributes1.item(i);
// Ignore tools uri namespace attributes for equivalency test
if (TOOLS_URI.equals(attribute.getNamespaceURI())) {
continue;
}
attributeNodes1.add(attribute);
}
List<Attr> attributeNodes2 = new ArrayList<Attr>();
for (int i = 0, n = attributes2.getLength(); i < n; i++) {
Attr attribute = (Attr) attributes2.item(i);
// Ignore tools uri namespace attributes for equivalency test
if (TOOLS_URI.equals(attribute.getNamespaceURI())) {
continue;
}
attributeNodes2.add(attribute);
}
if (attributeNodes1.size() != attributeNodes2.size()) {
return false;
}
if (attributes1.getLength() > 0) {
Collections.sort(attributeNodes1, ATTRIBUTE_COMPARATOR);
Collections.sort(attributeNodes2, ATTRIBUTE_COMPARATOR);
for (int i = 0; i < attributeNodes1.size(); i++) {
Attr attr1 = attributeNodes1.get(i);
Attr attr2 = attributeNodes2.get(i);
if (attr1.getLocalName() == null || attr2.getLocalName() == null) {
if (!attr1.getName().equals(attr2.getName())) {
return false;
}
} else if (!attr1.getLocalName().equals(attr2.getLocalName())) {
return false;
}
if (!attr1.getValue().equals(attr2.getValue())) {
return false;
}
if (attr1.getNamespaceURI() == null) {
if (attr2.getNamespaceURI() != null) {
return false;
}
} else if (attr2.getNamespaceURI() == null) {
return false;
} else if (!attr1.getNamespaceURI().equals(attr2.getNamespaceURI())) {
return false;
}
}
}
NodeList children1 = element1.getChildNodes();
NodeList children2 = element2.getChildNodes();
int nextIndex1 = 0;
int nextIndex2 = 0;
while (true) {
while (nextIndex1 < children1.getLength() &&
children1.item(nextIndex1).getNodeType() != Node.ELEMENT_NODE) {
nextIndex1++;
}
while (nextIndex2 < children2.getLength() &&
children2.item(nextIndex2).getNodeType() != Node.ELEMENT_NODE) {
nextIndex2++;
}
Element nextElement1 = (Element) (nextIndex1 < children1.getLength()
? children1.item(nextIndex1) : null);
Element nextElement2 = (Element) (nextIndex2 < children2.getLength()
? children2.item(nextIndex2) : null);
if (nextElement1 == null) {
return nextElement2 == null;
} else if (nextElement2 == null) {
return false;
} else if (!isEquivalent(nextElement1, nextElement2)) {
return false;
}
nextIndex1++;
nextIndex2++;
}
}
/**
* Finds the corresponding element in a document to a given element in another
* document. Note that this does <b>not</b> do any kind of equivalence check
* (see {@link #isEquivalent(Element, Element)}), and currently the search
* is only by id; there is no structural search.
*
* @param element the element to find an equivalent for
* @param document the document to search for an equivalent element in
* @return an equivalent element, or null
*/
@Nullable
public static Element findCorresponding(@NonNull Element element, @NonNull Document document) {
// Make sure the method is called correctly -- the element is for a different
// document than the one we are searching
assert element.getOwnerDocument() != document;
// First search by id. This allows us to find the corresponding
String id = element.getAttributeNS(ANDROID_URI, ATTR_ID);
if (id != null && id.length() > 0) {
if (id.startsWith(ID_PREFIX)) {
id = NEW_ID_PREFIX + id.substring(ID_PREFIX.length());
}
return findCorresponding(document.getDocumentElement(), id);
}
// TODO: Search by structure - look in the document and
// find a corresponding element in the same location in the structure,
// e.g. 4th child of root, 3rd child, 6th child, then pick node with tag "foo".
return null;
}
/** Helper method for {@link #findCorresponding(Element, Document)} */
@Nullable
private static Element findCorresponding(@NonNull Element element, @NonNull String targetId) {
String id = element.getAttributeNS(ANDROID_URI, ATTR_ID);
if (id != null) { // Work around DOM bug
if (id.equals(targetId)) {
return element;
} else if (id.startsWith(ID_PREFIX)) {
id = NEW_ID_PREFIX + id.substring(ID_PREFIX.length());
if (id.equals(targetId)) {
return element;
}
}
}
NodeList children = element.getChildNodes();
for (int i = 0, n = children.getLength(); i < n; i++) {
Node node = children.item(i);
if (node.getNodeType() == Node.ELEMENT_NODE) {
Element child = (Element) node;
Element match = findCorresponding(child, targetId);
if (match != null) {
return match;
}
}
}
return null;
}
/**
* Parses the given XML string as a DOM document, using Eclipse's structured
* XML model (which for example allows us to distinguish empty elements
* (<foo/>) from elements with no children (<foo></foo>).
*
* @param xml the XML content to be parsed (must be well formed)
* @return the DOM document, or null
*/
@Nullable
public static Document parseStructuredDocument(@NonNull String xml) {
IStructuredModel model = createStructuredModel(xml);
if (model instanceof IDOMModel) {
IDOMModel domModel = (IDOMModel) model;
return domModel.getDocument();
}
return null;
}
/**
* Parses the given XML string and builds an Eclipse structured model for it.
*
* @param xml the XML content to be parsed (must be well formed)
* @return the structured model
*/
@Nullable
public static IStructuredModel createStructuredModel(@NonNull String xml) {
IStructuredModel model = createEmptyModel();
IStructuredDocument document = model.getStructuredDocument();
model.aboutToChangeModel();
document.set(xml);
model.changedModel();
return model;
}
/**
* Creates an empty Eclipse XML model
*
* @return a new Eclipse XML model
*/
@NonNull
public static IStructuredModel createEmptyModel() {
IModelManager modelManager = StructuredModelManager.getModelManager();
return modelManager.createUnManagedStructuredModelFor(ContentTypeID_XML);
}
/**
* Creates an empty Eclipse XML document
*
* @return an empty Eclipse XML document
*/
@Nullable
public static Document createEmptyDocument() {
IStructuredModel model = createEmptyModel();
if (model instanceof IDOMModel) {
IDOMModel domModel = (IDOMModel) model;
return domModel.getDocument();
}
return null;
}
/**
* Creates an empty non-Eclipse XML document.
* This is used when you need to use XML operations not supported by
* the Eclipse XML model (such as serialization).
* <p>
* The new document will not validate, will ignore comments, and will
* support namespace.
*
* @return the new document
*/
@Nullable
public static Document createEmptyPlainDocument() {
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
factory.setNamespaceAware(true);
factory.setValidating(false);
factory.setIgnoringComments(true);
DocumentBuilder builder;
try {
builder = factory.newDocumentBuilder();
return builder.newDocument();
} catch (ParserConfigurationException e) {
AdtPlugin.log(e, null);
}
return null;
}
/**
* Parses the given XML string as a DOM document, using the JDK parser.
* The parser does not validate, and is namespace aware.
*
* @param xml the XML content to be parsed (must be well formed)
* @param logParserErrors if true, log parser errors to the log, otherwise
* silently return null
* @return the DOM document, or null
*/
@Nullable
public static Document parseDocument(@NonNull String xml, boolean logParserErrors) {
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
InputSource is = new InputSource(new StringReader(xml));
factory.setNamespaceAware(true);
factory.setValidating(false);
try {
DocumentBuilder builder = factory.newDocumentBuilder();
return builder.parse(is);
} catch (Exception e) {
if (logParserErrors) {
AdtPlugin.log(e, null);
}
}
return null;
}
/** Can be used to sort attributes by name */
private static final Comparator<Attr> ATTRIBUTE_COMPARATOR = new Comparator<Attr>() {
@Override
public int compare(Attr a1, Attr a2) {
return a1.getName().compareTo(a2.getName());
}
};
}