/*******************************************************************************
* Copyright (c) 2003, 2016 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
*******************************************************************************/
package org.eclipse.wst.server.discovery.internal;
import java.io.*;
import java.util.*;
import org.w3c.dom.*;
import org.xml.sax.*;
import javax.xml.parsers.*;
import javax.xml.transform.*;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
/**
* A Memento is a class independent container for persistence
* info. It is a reflection of 3 storage requirements.
*
* 1) We need the ability to persist an object and restore it.
* 2) The class for an object may be absent. If so we would
* like to skip the object and keep reading.
* 3) The class for an object may change. If so the new class
* should be able to read the old persistence info.
*
* We could ask the objects to serialize themselves into an
* ObjectOutputStream, DataOutputStream, or Hashtable. However
* all of these approaches fail to meet the second requirement.
*
* Memento supports binary persistance with a version ID.
*/
public final class XMLMemento implements IMemento {
private Document factory;
private Element element;
private ProcessingInstruction processInstrn;
/**
* Answer a memento for the document and element. For simplicity
* you should use createReadRoot and createWriteRoot to create the initial
* mementos on a document.
*/
private XMLMemento(Document doc, Element el) {
factory = doc;
element = el;
}
/*
* @see IMemento
*/
public IMemento createChild(String type) {
Element child = factory.createElement(type);
element.appendChild(child);
return new XMLMemento(factory, child);
}
/**
* Create a Document from a Reader and answer a root memento for reading
* a document.
*/
protected static XMLMemento createReadRoot(InputStream in) {
Document document = null;
try {
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
DocumentBuilder parser = factory.newDocumentBuilder();
document = parser.parse(new InputSource(in));
Node node = document.getFirstChild();
ProcessingInstruction newPI = null;
if (node instanceof ProcessingInstruction){
newPI = (ProcessingInstruction)node;
node = node.getNextSibling();
if (node instanceof Comment)
node = node.getNextSibling();
}
if (node instanceof Element){
XMLMemento memento = new XMLMemento(document, (Element) node);
if (newPI != null)
memento.setProcessingInstruction(newPI);
return memento;
}
} catch (Exception e) {
// ignore
} finally {
try {
in.close();
} catch (Exception e) {
// ignore
}
}
return null;
}
/**
* Answer a root memento for writing a document.
*
* @param type a type
* @return a memento
*/
public static XMLMemento createWriteRoot(String type) {
Document document;
try {
document = DocumentBuilderFactory.newInstance().newDocumentBuilder().newDocument();
Element element = document.createElement(type);
document.appendChild(element);
return new XMLMemento(document, element);
} catch (ParserConfigurationException e) {
throw new Error(e);
}
}
/**
* Answer a root memento for writing a document.
*
* @param type a type
* @param target a processingInstruction target
* @param data a processingInstruction data
* @return a memento
*/
public static XMLMemento createWriteRoot(String type, String target, String data, String commentString) {
Document document;
try {
document = DocumentBuilderFactory.newInstance().newDocumentBuilder().newDocument();
ProcessingInstruction newProcessInstrn = document.createProcessingInstruction(target, data);
document.appendChild(newProcessInstrn);
Comment comment =document.createComment(commentString);
document.appendChild(comment);
Element element = document.createElement(type);
document.appendChild(element);
return new XMLMemento(document, element);
} catch (ParserConfigurationException e) {
throw new Error(e);
}
}
/*
* @see IMemento
*/
public IMemento getChild(String type) {
// Get the nodes.
NodeList nodes = element.getChildNodes();
int size = nodes.getLength();
if (size == 0)
return null;
// Find the first node which is a child of this node.
for (int nX = 0; nX < size; nX ++) {
Node node = nodes.item(nX);
if (node instanceof Element) {
Element element2 = (Element)node;
if (element2.getNodeName().equals(type))
return new XMLMemento(factory, element2);
}
}
// A child was not found.
return null;
}
/*
* @see IMemento
*/
public IMemento [] getChildren(String type) {
// Get the nodes.
NodeList nodes = element.getChildNodes();
int size = nodes.getLength();
if (size == 0)
return new IMemento[0];
// Extract each node with given type.
List<Element> list = new ArrayList<Element>(size);
for (int nX = 0; nX < size; nX ++) {
Node node = nodes.item(nX);
if (node instanceof Element) {
Element element2 = (Element)node;
if (element2.getNodeName().equals(type))
list.add(element2);
}
}
// Create a memento for each node.
size = list.size();
IMemento [] results = new IMemento[size];
for (int x = 0; x < size; x ++) {
results[x] = new XMLMemento(factory, list.get(x));
}
return results;
}
/**
* Return the contents of this memento as a byte array.
*
* @return byte[]
* @throws IOException if anything goes wrong
*/
public byte[] getContents() throws IOException {
ByteArrayOutputStream out = new ByteArrayOutputStream();
save(out);
return out.toByteArray();
}
/**
* Returns an input stream for writing to the disk with a local locale.
*
* @return java.io.InputStream
* @throws IOException if anything goes wrong
*/
public InputStream getInputStream() throws IOException {
ByteArrayOutputStream out = new ByteArrayOutputStream();
save(out);
return new ByteArrayInputStream(out.toByteArray());
}
/*
* @see IMemento
*/
public Float getFloat(String key) {
Attr attr = element.getAttributeNode(key);
if (attr == null)
return null;
String strValue = attr.getValue();
try {
return new Float(strValue);
} catch (NumberFormatException e) {
return null;
}
}
/*
* @see IMemento
*/
public Integer getInteger(String key) {
Attr attr = element.getAttributeNode(key);
if (attr == null)
return null;
String strValue = attr.getValue();
try {
return new Integer(strValue);
} catch (NumberFormatException e) {
return null;
}
}
/*
* @see IMemento
*/
public String getString(String key) {
Attr attr = element.getAttributeNode(key);
if (attr == null)
return null;
return attr.getValue();
}
public List<String> getNames() {
NamedNodeMap map = element.getAttributes();
int size = map.getLength();
List<String> list = new ArrayList<String>();
for (int i = 0; i < size; i++) {
Node node = map.item(i);
String name = node.getNodeName();
list.add(name);
}
return list;
}
/**
* Loads a memento from the given filename.
*
* @param in java.io.InputStream
* @return org.eclipse.ui.IMemento
*/
public static IMemento loadMemento(InputStream in) {
return createReadRoot(in);
}
/**
* Loads a memento from the given filename.
*
* @param filename java.lang.String
* @return org.eclipse.ui.IMemento
* @exception java.io.IOException
*/
public static IMemento loadMemento(String filename) throws IOException {
InputStream in = null;
try {
in = new BufferedInputStream(new FileInputStream(filename));
return XMLMemento.createReadRoot(in);
} finally {
try {
if (in != null)
in.close();
} catch (Exception e) {
// ignore
}
}
}
/*
* @see IMemento
*/
public void putInteger(String key, int n) {
element.setAttribute(key, String.valueOf(n));
}
/*
* @see IMemento
*/
public void putString(String key, String value) {
if (value == null)
return;
element.setAttribute(key, value);
}
/**
* Save this Memento to a Writer.
*
* @throws IOException if there is a problem saving
*/
public void save(OutputStream os) throws IOException {
Result result = new StreamResult(os);
Source source = new DOMSource(factory);
try {
Transformer transformer = TransformerFactory.newInstance().newTransformer();
transformer.setOutputProperty(OutputKeys.INDENT, "yes");
transformer.setOutputProperty(OutputKeys.METHOD, "xml");
transformer.setOutputProperty(OutputKeys.ENCODING, "UTF-8");
transformer.setOutputProperty("{http://xml.apache.org/xalan}indent-amount", "2");
transformer.transform(source, result);
} catch (Exception e) {
throw (IOException) (new IOException().initCause(e));
}
}
/**
* Saves the memento to the given file.
*
* @param filename java.lang.String
* @exception java.io.IOException
*/
public void saveToFile(String filename) throws IOException {
BufferedOutputStream w = null;
try {
w = new BufferedOutputStream(new FileOutputStream(filename));
save(w);
} catch (IOException e) {
throw e;
} catch (Exception e) {
throw new IOException(e.getLocalizedMessage());
} finally {
if (w != null) {
try {
w.close();
} catch (Exception e) {
// ignore
}
}
}
}
public String saveToString() throws IOException {
ByteArrayOutputStream out = new ByteArrayOutputStream();
save(out);
return out.toString("UTF-8");
}
/*
* @see IMemento#getBoolean(String)
*/
public Boolean getBoolean(String key) {
Attr attr = element.getAttributeNode(key);
if (attr == null)
return null;
String strValue = attr.getValue();
if ("true".equalsIgnoreCase(strValue))
return new Boolean(true);
return new Boolean(false);
}
/*
* @see IMemento#putBoolean(String, boolean)
*/
public void putBoolean(String key, boolean value) {
element.setAttribute(key, value ? "true" : "false");
}
/**
* Returns the Text node of the memento. Each memento is allowed only
* one Text node.
*
* @return the Text node of the memento, or <code>null</code> if
* the memento has no Text node.
*/
private Text getTextNode() {
// Get the nodes.
NodeList nodes = element.getChildNodes();
int size = nodes.getLength();
if (size == 0) {
return null;
}
for (int nX = 0; nX < size; nX++) {
Node node = nodes.item(nX);
if (node instanceof Text) {
return (Text) node;
}
}
// a Text node was not found
return null;
}
/* (non-Javadoc)
*/
public void putTextData(String data) {
Text textNode = getTextNode();
if (textNode == null) {
textNode = factory.createTextNode(data);
// Always add the text node as the first child (fixes bug 93718)
element.insertBefore(textNode, element.getFirstChild());
} else {
textNode.setData(data);
}
}
public ProcessingInstruction getProcessingInstruction(){
return processInstrn;
}
protected void setProcessingInstruction(ProcessingInstruction processInstrn){
this.processInstrn = processInstrn;
}
}