refresh
diff --git a/bundles/org.eclipse.wst.sse.ui/src-contentproperties/org/eclipse/wst/sse/ui/contentproperties/SimpleNodeOperator.java b/bundles/org.eclipse.wst.sse.ui/src-contentproperties/org/eclipse/wst/sse/ui/contentproperties/SimpleNodeOperator.java
new file mode 100644
index 0000000..9c6fa63
--- /dev/null
+++ b/bundles/org.eclipse.wst.sse.ui/src-contentproperties/org/eclipse/wst/sse/ui/contentproperties/SimpleNodeOperator.java
@@ -0,0 +1,351 @@
+/*******************************************************************************
+ * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * IBM Corporation - initial API and implementation
+ * Jens Lukowski/Innoopract - initial renaming/restructuring
+ *
+ *******************************************************************************/
+package org.eclipse.wst.sse.ui.contentproperties;
+
+
+
+import java.io.File;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.util.HashMap;
+import java.util.Hashtable;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Set;
+
+import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.parsers.FactoryConfigurationError;
+import javax.xml.parsers.ParserConfigurationException;
+import javax.xml.transform.OutputKeys;
+import javax.xml.transform.Source;
+import javax.xml.transform.Transformer;
+import javax.xml.transform.TransformerConfigurationException;
+import javax.xml.transform.TransformerException;
+import javax.xml.transform.TransformerFactory;
+import javax.xml.transform.TransformerFactoryConfigurationError;
+import javax.xml.transform.dom.DOMSource;
+import javax.xml.transform.stream.StreamResult;
+
+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.w3c.dom.traversal.NodeIterator;
+import org.xml.sax.SAXException;
+
+class SimpleNodeOperator {
+
+ class CreateContentSettingsFailureException extends Exception {
+ public CreateContentSettingsFailureException(String reason) {
+ super(reason);
+ }
+ }
+
+
+ class ReadContentSettingsFailureException extends Exception {
+ public ReadContentSettingsFailureException(String reason) {
+ super(reason);
+ }
+ }
+
+ static class WriteContentSettingsFailureException extends Exception {
+ public WriteContentSettingsFailureException(String reason) {
+ super(reason);
+ }
+ }
+
+ // writer class for .contentSettings.
+ class XMLDocumentWriter {
+ OutputStream fOut;
+
+ protected XMLDocumentWriter(OutputStream out) {
+ this.fOut = out;
+ }
+
+ protected final void close() {
+ try {
+ fOut.close();
+ } catch (IOException e) {
+ // do nothing, shouldn't matter
+ }
+ }
+
+ protected void serialize(Document sourceDocument) throws WriteContentSettingsFailureException {
+ // JAXP transformation
+ Source domSource = new DOMSource(sourceDocument);
+ try {
+ Transformer serializer = TransformerFactory.newInstance().newTransformer();
+ try {
+ serializer.setOutputProperty(OutputKeys.INDENT, "yes"); //$NON-NLS-1$
+ serializer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "4"); //$NON-NLS-1$ //$NON-NLS-2$
+ } catch (IllegalArgumentException e) {
+ // unsupported properties
+ }
+ serializer.transform(domSource, new StreamResult(fOut));
+ } catch (TransformerConfigurationException e) {
+ throw new WriteContentSettingsFailureException(e.getMessage());
+ } catch (TransformerFactoryConfigurationError e) {
+ throw new WriteContentSettingsFailureException(e.getMessage());
+ } catch (TransformerException e) {
+ throw new WriteContentSettingsFailureException(e.getMessage());
+ }
+ }
+ }
+
+ public static void main(String[] args) {
+ SimpleNodeOperator a = null;
+ try {
+ a = new SimpleNodeOperator("workspace/org.eclipse.examples.contentsettings/.contentsettings.xml");//$NON-NLS-1$
+ } catch (Exception e) {
+ System.exit(0);
+ }
+
+ // print all Elements
+ //a.printTree(iter);
+
+ // add Element
+ Map attMap = new Hashtable();
+ attMap.put("path", "hogepath");//$NON-NLS-1$ //$NON-NLS-2$
+ attMap.put("fDocument-type", "documenthogehoge");//$NON-NLS-1$ //$NON-NLS-2$
+ a.addElementUnderRoot("file", attMap);//$NON-NLS-1$
+
+ try {
+ a.writeDocument(System.out);
+ } catch (Exception e) {
+ System.err.println(e.toString());
+ }
+
+ }
+
+ //never used
+ //private DOMParser parser;
+ private Document fDocument;
+ private Node root;
+
+ private String settingsFileName;
+
+
+ public SimpleNodeOperator(Document doc) throws CreateContentSettingsFailureException {
+
+ if (doc == null)
+ throw new CreateContentSettingsFailureException("Document doc==null");//$NON-NLS-1$
+ fDocument = doc;
+ root = fDocument.getLastChild();
+ if (root == null)
+ throw new CreateContentSettingsFailureException("Node root==null");//$NON-NLS-1$
+ }
+
+ public SimpleNodeOperator(String fullPath) throws ReadContentSettingsFailureException {
+ this.settingsFileName = fullPath;
+ createObjectOfDocument();
+ }
+
+ // add attribute(attName=attValue) of ele without checking overlapping of
+ // another attributes of ele.
+ // if overlapping ,override
+ protected Node addAttributeAt(Element ele, String attName, String attValue) {
+ Attr att = fDocument.createAttribute(attName);
+ att.setValue(attValue);
+ if (ele != null)
+ ele.setAttributeNode(att);
+ return ele;
+ }
+
+ protected Node addElementUnder(Node parent, String tagName, Map attMap) {
+ if (parent == null || tagName == null)
+ return null;
+ Element e = fDocument.createElement(tagName);
+ if (attMap != null) {
+ if (!attMap.isEmpty()) {
+ Set attKeys = attMap.keySet();
+ Iterator iter = attKeys.iterator();
+ while (iter.hasNext()) {
+ String key = (String) iter.next();
+ e.setAttribute(key, (String) attMap.get(key));
+ }
+ }
+ }
+ parent.appendChild(e);
+ return e;
+ }
+
+ protected final Node addElementUnderRoot(String tagName) {
+ return addElementUnder(root, tagName, null);
+ }
+
+ // add element with attMap as attribute without checking overlapping.
+ protected final Node addElementUnderRoot(String tagName, Map attMap) {
+ return addElementUnder(root, tagName, attMap);
+ }
+
+ /*
+ * private void createObjectOfDocument() throws
+ * ReadContentSettingsFailureException{ try { //parser = new DOMParser();
+ * parser = ParseUtil.getDOMParser(); parser.parse(settingsFileName);
+ * //fDocument = parser.getDocument(); fDocument =
+ * ParseUtil._getDocument(parser); //get the root of the XML fDocument
+ * root = fDocument.getLastChild(); if (root == null) { throw new
+ * ReadContentSettingsFailureException("Error: Node
+ * root==null");//$NON-NLS-1$ } filter = new AllElements(); } catch
+ * (SAXException e){ com.ibm.sed.util.Logger.log(e); throw new
+ * ReadContentSettingsFailureException(e.toString()); } catch (IOException
+ * e){ com.ibm.sed.util.Logger.log(e); throw new
+ * ReadContentSettingsFailureException(e.toString()); } catch
+ * (ClassNotFoundException e){ com.ibm.sed.util.Logger.log(e); throw new
+ * ReadContentSettingsFailureException(e.toString()); } }
+ */
+ private void createObjectOfDocument() throws ReadContentSettingsFailureException {
+ try {
+ fDocument = DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(new File(settingsFileName));
+ } catch (SAXException e) {
+ Logger.logException("exception parsing" + settingsFileName, e); //$NON-NLS-1$
+ } catch (IOException e) {
+ Logger.logException("I/O exception parsing" + settingsFileName, e); //$NON-NLS-1$
+ } catch (ParserConfigurationException e) {
+ Logger.logException("exception accessing DOMImplementation", e); //$NON-NLS-1$
+ } catch (FactoryConfigurationError e) {
+ Logger.logException("exception accessing DOMImplementation", e); //$NON-NLS-1$
+ }
+ //get the root of the XML fDocument
+ root = fDocument.getLastChild();
+ if (root == null) {
+ throw new ReadContentSettingsFailureException("Error: Node root==null");//$NON-NLS-1$
+ }
+ }
+
+ protected Map getAttributesOf(Node node) {
+ if (!node.hasAttributes())
+ return null;
+ Map map = new HashMap();
+ NamedNodeMap attrs = node.getAttributes();
+ int size = attrs.getLength();
+ for (int i = 0; i < size; i++) {
+ Attr attr = (Attr) attrs.item(i);
+ map.put(attr.getName(), attr.getValue());
+ }
+ return (map);
+ }
+
+ private Node getElementWithAttribute(Node first, String attName, String attValue) {
+ Node navpoint = first;
+ while (navpoint != null) {
+ if (navpoint.getNodeType() == Node.ELEMENT_NODE) {
+ NamedNodeMap m = navpoint.getAttributes();
+ if (m == null)
+ continue;
+ if (m.getNamedItem(attName) != null) {
+ if (attValue.equals(((Attr) m.getNamedItem(attName)).getNodeValue()))
+ return navpoint;
+ }
+ NodeList childNodes = navpoint.getChildNodes();
+ if (childNodes != null && childNodes.getLength() > 0) {
+ Node holdNode = getElementWithAttribute(navpoint.getFirstChild(), attName, attValue);
+ if (holdNode != null) {
+ return holdNode;
+ }
+ }
+ }
+ navpoint = navpoint.getNextSibling();
+ }
+ return null;
+ }
+
+
+ // return a (first) Element with attr(attName=attValue) it if exists,
+ // otherwise return null
+ protected Node getElementWithAttribute(String attName, String attValue) {
+ if (attName == null || attValue == null || !fDocument.hasChildNodes())
+ return null;
+ return getElementWithAttribute(fDocument.getFirstChild(), attName, attValue);
+ }
+
+ // retrun Element which has nodeName as Node Name
+ protected Node getElementWithNodeName(String nodeName) {
+ if (nodeName == null)
+ return null;
+ NodeList nodes = fDocument.getElementsByTagName(nodeName);
+ if (nodes.getLength() > 0) {
+ return nodes.item(0);
+ }
+ return null;
+ }
+
+ public void printTree(NodeIterator iter) {
+ Node n;
+ while ((n = iter.nextNode()) != null) {
+ System.out.println(n.getNodeName() + ":");//$NON-NLS-1$
+ NamedNodeMap m = n.getAttributes();
+ if (m == null)
+ continue;
+ for (int i = 0; i < m.getLength(); i++) {
+ String attName = m.item(i).getNodeName();
+ System.out.print(" " + attName + "=" + m.item(i).getNodeValue());//$NON-NLS-1$ //$NON-NLS-2$
+ }
+ System.out.println("");//$NON-NLS-1$
+ }
+ }
+
+
+ // remove attribute(attName) at ele.
+ protected Attr removeAttributeAt(Element ele, String attName) {
+ if (ele == null || attName == null)
+ return null;
+ Attr att = ele.getAttributeNode(attName);
+ ele.removeAttribute(attName);
+ return att;
+ }
+
+ protected Element removeElementWith(String nodeName) {
+ NodeList nodes = fDocument.getElementsByTagName(nodeName);
+ for (int i = 0; i < nodes.getLength(); i++) {
+ nodes.item(i).getParentNode().removeChild(nodes.item(i));
+ }
+ return null;
+ }
+
+ // remove a (first) Element with attr(attName=attValue) and return it if
+ // exists, otherwise return null
+ protected Element removeElementWith(String attName, String attValue) {
+ if (fDocument.hasChildNodes()) {
+ Node element = getElementWithAttribute(attName, attValue);
+ if (element != null && element.getNodeType() == Node.ELEMENT_NODE) {
+ element.getParentNode().removeChild(element);
+ return (Element) element;
+ }
+ }
+ return null;
+
+ }
+
+ // update attribute(attName=newValue) at ele if both ele and attribute of
+ // ele exist
+ protected void updateAttributeAt(Element ele, String attName, String newValue) {
+ Attr att = null;
+ if (ele != null)
+ if ((att = ele.getAttributeNode(attName)) != null)
+ att.setValue(newValue);
+ }
+
+ protected void writeDocument(OutputStream out) throws WriteContentSettingsFailureException {
+ XMLDocumentWriter writer = new XMLDocumentWriter(out);
+ try {
+ writer.serialize(fDocument);
+ } finally {
+ writer.close();
+ }
+ }
+
+
+}