public String createDrawingXML(String drawing) {
try {
DocumentBuilderFactory docFactory = DocumentBuilderFactory.newInstance();
DocumentBuilder docBuilder = docFactory.newDocumentBuilder();
Document doc = docBuilder.newDocument();
Element rootElement = doc.createElement("message");
rootElement.setAttribute("drawing", drawing);
rootElement.setAttribute("user", user);
rootElement.setAttribute("cmd", "create");
doc.appendChild(rootElement);
TransformerFactory tf = TransformerFactory.newInstance();
Transformer transformer = tf.newTransformer();
StringWriter writer = new StringWriter();
transformer.transform(new DOMSource(doc), new StreamResult(writer));
String xml = writer.getBuffer().toString().replaceAll("\n|\r", "");
postData(xml);
return null;
} catch (ParserConfigurationException ex) {
Logger.getLogger(XMLManager.class.getName()).log(Level.SEVERE, null, ex);
return null;
} catch (TransformerConfigurationException ex) {
Logger.getLogger(XMLManager.class.getName()).log(Level.SEVERE, null, ex);
return null;
} catch (TransformerException ex) {
Logger.getLogger(XMLManager.class.getName()).log(Level.SEVERE, null, ex);
return null;
}
}
public static void main(String[] args) {
String outputDir = "./";
for (int i = 0; i < args.length; i++) {
String arg = args[i];
if ("-o".equals(arg)) {
outputDir = args[++i];
continue;
} else {
System.out.println("XMLSchemaGenerator -o <path to newly created xsd schema file>");
return;
}
}
File f = new File(outputDir, "JGroups-" + Version.major + "." + Version.minor + ".xsd");
try {
FileWriter fw = new FileWriter(f, false);
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = factory.newDocumentBuilder();
DOMImplementation impl = builder.getDOMImplementation();
Document xmldoc = impl.createDocument("http://www.w3.org/2001/XMLSchema", "xs:schema", null);
xmldoc.getDocumentElement().setAttribute("targetNamespace", "urn:org:jgroups");
xmldoc.getDocumentElement().setAttribute("elementFormDefault", "qualified");
Element xsElement = xmldoc.createElement("xs:element");
xsElement.setAttribute("name", "config");
xmldoc.getDocumentElement().appendChild(xsElement);
Element complexType = xmldoc.createElement("xs:complexType");
xsElement.appendChild(complexType);
Element allType = xmldoc.createElement("xs:choice");
allType.setAttribute("maxOccurs", "unbounded");
complexType.appendChild(allType);
Set<Class<?>> classes = getClasses("bboss.org.jgroups.protocols", Protocol.class);
for (Class<?> clazz : classes) {
classToXML(xmldoc, allType, clazz, "");
}
classes = getClasses("bboss.org.jgroups.protocols.pbcast", Protocol.class);
for (Class<?> clazz : classes) {
classToXML(xmldoc, allType, clazz, "pbcast.");
}
DOMSource domSource = new DOMSource(xmldoc);
StreamResult streamResult = new StreamResult(fw);
TransformerFactory tf = TransformerFactory.newInstance();
Transformer serializer = tf.newTransformer();
serializer.setOutputProperty(OutputKeys.METHOD, "xml");
serializer.setOutputProperty(OutputKeys.INDENT, "yes");
serializer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "1");
serializer.transform(domSource, streamResult);
fw.flush();
fw.close();
} catch (Exception e) {
e.printStackTrace();
}
}
/** Turns a List<CubicCurve2D.Float> into a SVG Element representing a sketch of that spline. */
Element splineToSketch(SVGDocument document, List<CubicCurve2D.Float> spline) {
String svgNS = SVGDOMImplementation.SVG_NAMESPACE_URI;
// <g> is an SVG group
// TODO: add a random(ish) rotation to the group
Element group = document.createElementNS(svgNS, "g");
// For each curve in the path, draw along it using a "brush". In
// our case the brush is a simple circle, but this could be changed
// to something more advanced.
for (CubicCurve2D.Float curve : spline) {
// TODO: magic number & step in loop guard
for (double i = 0.0; i <= 1.0; i += 0.01) {
Point2D result = evalParametric(curve, i);
// Add random jitter at some random positive or negative
// distance along the unit normal to the tangent of the
// curve
Point2D n = vectorUnitNormal(evalParametricTangent(curve, i));
float dx = (float) ((Math.random() - 0.5) * n.getX());
float dy = (float) ((Math.random() - 0.5) * n.getY());
Element brush = document.createElementNS(svgNS, "circle");
brush.setAttribute("cx", Double.toString(result.getX() + dx));
brush.setAttribute("cy", Double.toString(result.getY() + dy));
// TODO: magic number for circle radius
brush.setAttribute("r", Double.toString(1.0));
brush.setAttribute("fill", "green");
brush.setAttributeNS(null, "z-index", Integer.toString(zOrder.CONTOUR.ordinal()));
group.appendChild(brush);
}
}
return group;
}
private static void exportThisSeries(
String name,
String target_sea_state_datum,
NamedList thisList,
String[] sea_state_headings,
Element itt,
Document doc) {
// ok, put us into the element
org.w3c.dom.Element datum = doc.createElement(target_sea_state_datum);
datum.setAttribute("Type", name);
// and step through its values
Collection<Double> indices = thisList.getValues();
int ctr = 0;
for (Iterator<Double> iter = indices.iterator(); iter.hasNext(); ) {
Double val = (Double) iter.next();
if (val != null) {
datum.setAttribute(sea_state_headings[ctr], writeThis(val.doubleValue()));
ctr++;
} else break;
}
itt.appendChild(datum);
}
@Override
public Element export(ExportSupport support) throws IOException {
Element layerEl = support.createElement("layer");
layerEl.setAttribute("type", "osm-data");
layerEl.setAttribute("version", "0.1");
Element file = support.createElement("file");
layerEl.appendChild(file);
if (requiresZip()) {
String zipPath = "layers/" + String.format("%02d", support.getLayerIndex()) + "/data.osm";
file.appendChild(support.createTextNode(zipPath));
addDataFile(support.getOutputStreamZip(zipPath));
} else {
URI uri = layer.getAssociatedFile().toURI();
URL url = null;
try {
url = uri.toURL();
} catch (MalformedURLException e) {
throw new IOException(e);
}
file.appendChild(support.createTextNode(url.toString()));
}
return layerEl;
}
public Element toXML() {
Element e = super.toXML();
if (value != null) e.setAttribute("value", value.toString());
if (defaultValue != null) e.setAttribute("defaultValue", defaultValue.toString());
e.setAttribute("className", "org.rosuda.deducer.widgets.param.ParamNumeric");
return e;
}
void _serializeString(String key, String value) {
NodeList elements = stringElements.getElementsByTagName(ENTRY_FLAG);
final int size = elements.getLength();
for (int i = 0; i < size; ++i) {
Element e = (Element) elements.item(i);
Attr nameAttr = e.getAttributeNode(KEY_FLAG);
if (nameAttr == null) {
throw newMalformedKeyAttrException(Repository.STRING);
}
if (key.equals(nameAttr.getValue())) {
Attr valueAttr = e.getAttributeNode(VALUE_FLAG);
if (valueAttr == null) {
throw newMalformedValueAttrException(key, Repository.STRING);
}
valueAttr.setValue(value);
return;
}
}
// no existing element found
Element element = xmlDoc.createElement(ENTRY_FLAG);
element.setAttribute(KEY_FLAG, key);
element.setAttribute(VALUE_FLAG, value);
stringElements.appendChild(element);
}
private void processPlugin(final Element root, final ArtifactInformation a) {
if (!Helper.isBundle(a.getMetaData())) {
return;
}
final String id =
a.getMetaData().get(new MetaKey(OsgiExtractor.NAMESPACE, OsgiExtractor.KEY_NAME));
final String version =
a.getMetaData().get(new MetaKey(OsgiExtractor.NAMESPACE, OsgiExtractor.KEY_VERSION));
if (id == null || version == null) {
return;
}
boolean unpack = false;
try {
final String biString =
a.getMetaData()
.get(new MetaKey(OsgiExtractor.NAMESPACE, OsgiExtractor.KEY_BUNDLE_INFORMATION));
final BundleInformation bi = BundleInformation.fromJson(biString);
unpack = "dir".equals(bi.getEclipseBundleShape());
} catch (final Exception e) {
}
final Element p = root.getOwnerDocument().createElement("plugin");
root.appendChild(p);
p.setAttribute("id", id);
p.setAttribute("version", version);
p.setAttribute("unpack", "" + unpack);
}
/**
* Similar to the XMLRepresentation interface, this method will append an XML representation of
* some preferences to an existing node.
*
* @param prefs the preferences node to write out.
* @param deep - true to include a subtree with all child preferences nodes.
* @param domDoc the document in which the node will reside.
* @param node the node to which a child is applied.
*/
public static void toXML(
Preferences prefs, boolean deep, org.w3c.dom.Document domDoc, Element node, Map options)
throws IOException {
String[] keys;
String[] children;
Element childElement, entry;
String value;
int i;
// System.err.println( "node = "+prefs.name() );
try {
keys = prefs.keys();
childElement = (Element) node.appendChild(domDoc.createElement("map"));
for (i = 0; i < keys.length; i++) {
value = prefs.get(keys[i], null);
// System.err.println( " key = "+keys[i]+"; value = "+value );
if (value == null) continue;
entry = (Element) childElement.appendChild(domDoc.createElement("entry"));
entry.setAttribute("key", keys[i]);
entry.setAttribute("value", value);
}
if (deep) {
children = prefs.childrenNames();
for (i = 0; i < children.length; i++) {
childElement = (Element) node.appendChild(domDoc.createElement("node"));
childElement.setAttribute("name", children[i]);
toXML(prefs.node(children[i]), deep, domDoc, childElement, options);
}
}
} catch (DOMException e1) {
throw IOUtil.map(e1);
} catch (BackingStoreException e2) {
throw IOUtil.map(e2);
}
}
@Override
public final Element put(final Element parentElement, final Object value) {
Element newElement = document.createElementNS(XMLNS_ITEM, parentElement.getLocalName());
if (value == null) {
newElement.setAttribute("isNull", "yes");
return newElement;
}
Map<String, Object> attributes = XmlHelper.extractAttributes(value);
for (String key : attributes.keySet()) {
try {
newElement.setAttribute(key, attributes.get(key).toString());
} catch (Exception e) {
// XXX: ignore exceptions silenty
}
}
Map<String, Collection<?>> collections = XmlHelper.extractCollections(value);
for (String key : collections.keySet()) {
try {
Element container = document.createElementNS(XMLNS_DATA, key);
newElement.appendChild(container);
for (Object item : collections.get(key)) {
put(container, item);
}
} catch (Exception e) {
// XXX: ignore exceptions silenty
}
}
newElement.appendChild(document.createTextNode(value.toString()));
parentElement.appendChild(newElement);
return newElement;
}
/**
* This method exports the single pattern decision instance to the XML. It MUST be called by an
* XML exporter, as this will not have a complete header.
*
* @param ratDoc The ratDoc generated by the XML exporter
* @return the SAX representation of the object.
*/
public Element toXML(Document ratDoc) {
Element decisionE;
RationaleDB db = RationaleDB.getHandle();
// Now, add pattern to doc
String entryID = db.getRef(this);
if (entryID == null) {
entryID = db.addPatternDecisionRef(this);
}
decisionE = ratDoc.createElement("DR:patternDecision");
decisionE.setAttribute("rid", entryID);
decisionE.setAttribute("name", name);
decisionE.setAttribute("type", type.toString());
decisionE.setAttribute("phase", devPhase.toString());
decisionE.setAttribute("status", status.toString());
// decisionE.setAttribute("artifact", artifact);
Element descE = ratDoc.createElement("description");
Text descText = ratDoc.createTextNode(description);
descE.appendChild(descText);
decisionE.appendChild(descE);
// Add child pattern references...
Iterator<Pattern> cpi = candidatePatterns.iterator();
while (cpi.hasNext()) {
Pattern cur = cpi.next();
Element curE = ratDoc.createElement("refChildPattern");
Text curText = ratDoc.createTextNode("p" + new Integer(cur.getID()).toString());
curE.appendChild(curText);
decisionE.appendChild(curE);
}
return decisionE;
}
/**
* generated <code><col><code> tags.
* @param sheet
* @param table container.
*/
private void generateColumns(XSSFSheet sheet, Element table) {
List<CTCols> colsList = sheet.getCTWorksheet().getColsList();
MathContext mc = new MathContext(3);
for (CTCols cols : colsList) {
long oldLevel = 1;
for (CTCol col : cols.getColArray()) {
while (true) {
if (oldLevel == col.getMin()) {
break;
}
Element column = htmlDocumentFacade.createTableColumn();
// htmlDocumentFacade.addStyleClass(column, "col", "width:2cm;");
column.setAttribute("style", "width:2cm;");
table.appendChild(column);
oldLevel++;
}
Element column = htmlDocumentFacade.createTableColumn();
String width =
new BigDecimal(sheet.getColumnWidth(Long.bitCount(oldLevel)) / 1440.0, mc).toString();
column.setAttribute("style", "width:".concat(width).concat("cm;"));
table.appendChild(column);
oldLevel++;
}
}
}
private void processSheet(Element container, XSSFSheet sheet) {
Element table = htmlDocumentFacade.createTable();
int sIndex = sheet.getWorkbook().getSheetIndex(sheet);
String sId = "sheet_".concat(String.valueOf(sIndex));
table.setAttribute("id", sId);
table.setAttribute("border", "1");
table.setAttribute("cellpadding", "2");
table.setAttribute("cellspacing", "0");
table.setAttribute("style", "border-collapse: collapse;");
css.append("#")
.append(sId)
.append(" tr{height:")
.append(sheet.getDefaultRowHeightInPoints() / 28.34)
.append("cm}\n");
css.append("#")
.append(sId)
.append(" td{width:")
.append(sheet.getDefaultColumnWidth() * 0.21)
.append("cm}\n");
// cols
generateColumns(sheet, table);
// rows
Iterator<Row> rows = sheet.iterator();
while (rows.hasNext()) {
Row row = rows.next();
if (row instanceof XSSFRow) processRow(table, (XSSFRow) row, sheet);
}
container.appendChild(table);
}
/*
* If the element contains an attribute 'makeOnly' with a value of 'true',
* create a child element before any existing children which will display a node
* which will display only the elements records.
* Compute the query attribute, which is the appended result of all of the children
* appended to this element name. If noQuery=true. then do not generate a query term
* for this element.
*/
String computeQuery(Element e) {
String query = "";
if (!(e.getAttribute("noQuery").equalsIgnoreCase("true"))) {
query = e.getAttribute("name");
}
String makeOnly = e.getAttribute("makeOnly");
boolean madeOnly = false;
NodeList children = e.getChildNodes();
for (int i = 0; i < children.getLength(); i++) {
Node child = children.item(i);
if (child.getNodeType() == Node.ELEMENT_NODE) {
if (makeOnly.equalsIgnoreCase("true") && !madeOnly) {
// need to make an ...-Only node and populate it
String onlyTagName = e.getTagName() + "-Only";
Element only = ((Document) dom.getNode()).createElement(onlyTagName);
only.setAttribute("name", e.getAttribute("name") + "-Only");
only.setAttribute("query", e.getAttribute("name"));
e.insertBefore(only, child);
i++;
madeOnly = true;
}
if (query.length() > 0) {
query += ",";
}
query += computeQuery((Element) child);
}
}
log.info("setting query for " + e.getNodeName() + " " + query);
e.setAttribute("query", query);
return query;
}
private void formatError(String type, Test test, Throwable t) {
if (test != null) {
endTest(test);
failedTests.put(test, test);
}
Element nested = doc.createElement(type);
Element currentTest = null;
if (test != null) {
currentTest = (Element) testElements.get(test);
} else {
currentTest = rootElement;
}
currentTest.appendChild(nested);
String message = t.getMessage();
if (message != null && message.length() > 0) {
nested.setAttribute(ATTR_MESSAGE, t.getMessage());
}
nested.setAttribute(ATTR_TYPE, t.getClass().getName());
String strace = JUnitTestRunner.getFilteredTrace(t);
Text trace = doc.createTextNode(strace);
nested.appendChild(trace);
}
private Element getOptions(Object service, String project, Document doc) {
List options;
if (service instanceof ISource) {
options = ((ISource) service).listOptions(project);
} else if (service instanceof IBuilder) {
options = ((IBuilder) service).getOptions();
} else if (service instanceof IDeployer) {
options = Collections.EMPTY_LIST;
} else {
return null;
}
Element optionsElement = doc.createElement("options");
for (Iterator i = options.iterator(); i.hasNext(); ) {
Option o = (Option) i.next();
Element option = doc.createElement("option");
;
if (o instanceof BooleanOption) {
option.setAttribute("type", "boolean");
} else if (o instanceof ListOption) {
option.setAttribute("type", "list");
for (Iterator j = ((ListOption) o).getChoices().iterator(); j.hasNext(); ) {
Element choice = doc.createElement("choice");
choice.setAttribute("value", (String) j.next());
option.appendChild(choice);
}
}
option.setAttribute("name", o.getName());
option.setAttribute("label", o.getLabel());
optionsElement.appendChild(option);
}
return optionsElement;
}
public Node convertToXML(Document parent) {
Element targetNode = parent.createElement(ELEMENT_NAME);
if (ident != null) targetNode.setAttribute(ATTRIBUTE_IDENT, ident);
if (decoy != null) targetNode.setAttribute(ATTRIBUTE_DECOY, decoy);
if (networkInterface != null) targetNode.setAttribute(ATTRIBUTE_INTERFACE, networkInterface);
if (node != null) {
Node nodeNode = node.convertToXML(parent);
targetNode.appendChild(nodeNode);
}
if (user != null) {
Node userNode = user.convertToXML(parent);
targetNode.appendChild(userNode);
}
if (process != null) {
Node processNode = process.convertToXML(parent);
targetNode.appendChild(processNode);
}
if (service != null) {
Node serviceNode = service.convertToXML(parent);
targetNode.appendChild(serviceNode);
}
if (fileList != null) {
targetNode.appendChild(fileList.convertToXML(parent));
}
return targetNode;
}
/**
* Convert an item in the Segment relation into XML, inserting it at the specified location in the
* XML tree.
*
* @param deep whether to create a deep structure of <syllable> and <ph> elements or not.
*/
protected String insertSegment(Item segmentItem, Element syllable, boolean deep) {
// allow for syllable == null if not deep:
if (segmentItem == null || deep && syllable == null) {
throw new NullPointerException("Null arguments to insertSegment()");
}
if (deep && !syllable.getTagName().equals(MaryXML.SYLLABLE)) {
throw new IllegalArgumentException("Segments can only be inserted in <syllable> elements");
}
String segmentString = segmentItem.toString();
Voice maryVoice = FreeTTSVoices.getMaryVoice(segmentItem.getUtterance().getVoice());
if (deep) {
Document doc = syllable.getOwnerDocument();
Element segment = MaryXML.createElement(doc, MaryXML.PHONE);
syllable.appendChild(segment);
segment.setAttribute("p", segmentString);
if (segmentItem.getFeatures().isPresent("end")) {
float endInSeconds = segmentItem.getFeatures().getFloat("end");
int endInMillis = (int) (1000 * endInSeconds);
segment.setAttribute("end", String.valueOf(endInMillis));
}
if (segmentItem.getFeatures().isPresent("mbr_dur")) {
int mbrDur = segmentItem.getFeatures().getInt("mbr_dur");
segment.setAttribute("d", String.valueOf(mbrDur));
}
if (segmentItem.getFeatures().isPresent("mbr_targets")) {
String mbrTargets = segmentItem.getFeatures().getString("mbr_targets");
if (!mbrTargets.equals("")) {
segment.setAttribute("f0", mbrTargets);
}
}
}
return segmentString;
}
protected void getAlbumsElements(Document doc, GalleryAlbums gallery) {
Element galleryNameElement = doc.createElement("galleryName");
galleryNameElement.appendChild(doc.createTextNode(gallery.getGalleryName()));
Element homePageElement = doc.createElement("homePage");
homePageElement.appendChild(doc.createTextNode(gallery.getGalleryHomePage()));
Element root = doc.getDocumentElement();
root.appendChild(galleryNameElement);
root.appendChild(homePageElement);
Element albumsElement = doc.createElement("albums");
AlbumBean[] albums = gallery.getAllAlbums();
for (AlbumBean album : albums) {
Element albumElement = doc.createElement("album");
albumElement.setAttribute("img", album.getImgThumbnail());
albumElement.setAttribute("folderName", album.getFolderName());
albumElement.setAttribute("name", album.getName());
albumElement.setAttribute("tags", album.getTagsInOneLine());
albumsElement.appendChild(albumElement);
}
root.appendChild(albumsElement);
}
/**
* Creates a SignatureRequest document element.
*
* @param document
* @param details
* @return
*/
private Element createSignatureRequestElement(
Document document, ObjectAndSignatureRequestDetails details) {
SignatureRequest request = details.signatureRequest;
Element requestElem = document.createElement("SignatureRequest");
requestElem.setAttribute("type", request.getSignatureType());
requestElem.setAttribute("signed", String.valueOf(request.isSigned()));
requestElem.appendChild(
createObjectElement(
document, details.key, details.bucketName, details.metadata, "RequestObject"));
if (request.isSigned()) {
requestElem.appendChild(
createObjectElement(
document,
request.getObjectKey(),
request.getBucketName(),
request.getObjectMetadata(),
"SignedObject"));
requestElem.appendChild(
createPropertyElement(document, null, request.getSignedUrl(), "SignedURL"));
} else if (request.getDeclineReason() != null) {
requestElem.appendChild(
createPropertyElement(document, null, request.getDeclineReason(), "DeclineReason"));
}
return requestElem;
}
void _serializeNumber(String key, Number value) {
NodeList elements = numberElements.getElementsByTagName(ENTRY_FLAG);
final int size = elements.getLength();
for (int i = 0; i < size; ++i) {
Element e = (Element) elements.item(i);
Attr nameAttr = e.getAttributeNode(KEY_FLAG);
if (nameAttr == null) {
throw newMalformedKeyAttrException(Repository.NUMBER);
}
if (key.equals(nameAttr.getValue())) {
Attr valueAttr = e.getAttributeNode(VALUE_FLAG);
if (valueAttr == null) {
throw newMalformedValueAttrException(key, Repository.NUMBER);
}
Attr typeAttr = e.getAttributeNode(TYPE_FLAG);
if (typeAttr == null) {
throw newMalformedTypeAttrException(key, Repository.NUMBER);
}
typeAttr.setValue(Configs.resolveNumberType(value).name());
valueAttr.setValue(value.toString());
return;
}
}
// no existing element found
Element element = xmlDoc.createElement(ENTRY_FLAG);
element.setAttribute(KEY_FLAG, key);
element.setAttribute(VALUE_FLAG, value.toString());
element.setAttribute(TYPE_FLAG, Configs.resolveNumberType(value).name());
numberElements.appendChild(element);
}
/**
* Creates and element to contain information about an object.
*
* @param document
* @param key
* @param bucketName
* @param metadata
* @param elementName
* @return
*/
private Element createObjectElement(
Document document, String key, String bucketName, Map metadata, String elementName) {
if (key == null) {
key = "";
}
if (bucketName == null) {
bucketName = "";
}
Element objectElement = document.createElement(elementName);
objectElement.setAttribute("key", key);
objectElement.setAttribute("bucketName", bucketName);
Iterator iter = metadata.entrySet().iterator();
while (iter.hasNext()) {
Map.Entry entry = (Map.Entry) iter.next();
String metadataName = (String) entry.getKey();
String metadataValue = (String) entry.getValue();
if (metadataValue == null) {
metadataValue = "";
}
objectElement.appendChild(
createPropertyElement(document, metadataName, metadataValue, "Metadata"));
}
return objectElement;
}
/**
* This method serialises the state and action labels
*
* @param document
*/
private static void serialiseStateAndActionLabels(final Element tree, final Document document) {
HashMap<String, ArrayList<String>> retrievedStateLabels =
QueryManager.getData().getStateLabels();
HashMap<String, ArrayList<String>> stateLabels = new HashMap<String, ArrayList<String>>();
ArrayList<String> actionLabels = new ArrayList<String>();
// only add the state and action labels to the respective array lists
// that are actually
// occurring in the macro
ArrayList<PerformanceTreeNode> nodesArray = MacroWriter.macro.getMacroNodes();
Iterator<PerformanceTreeNode> ni = nodesArray.iterator();
while (ni.hasNext()) {
PerformanceTreeNode node = ni.next();
if (node instanceof StatesNode) {
StatesNode statesNode = (StatesNode) node;
if (statesNode.getNodeLabelObject() != null) {
String stateLabel = statesNode.getNodeLabel();
ArrayList<String> states = retrievedStateLabels.get(stateLabel);
stateLabels.put(stateLabel, states);
}
} else if (node instanceof ActionsNode) {
ActionsNode actionsNode = (ActionsNode) node;
if (actionsNode.getNodeLabelObject() != null) {
String actionLabel = actionsNode.getNodeLabel();
actionLabels.add(actionLabel);
}
}
}
// serialise state labels
Element stateLabelsElement = document.createElement("stateLabels");
tree.appendChild(stateLabelsElement);
Iterator<String> i = stateLabels.keySet().iterator();
while (i.hasNext()) {
Element stateLabelElement = document.createElement("statelabel");
stateLabelsElement.appendChild(stateLabelElement);
String stateLabel = i.next();
ArrayList<String> stateLabelsStates = stateLabels.get(stateLabel);
stateLabelElement.setAttribute("name", stateLabel);
Iterator<String> j = stateLabelsStates.iterator();
while (j.hasNext()) {
Element stateElement = document.createElement("state");
stateLabelElement.appendChild(stateElement);
String stateName = j.next();
stateElement.setAttribute("name", stateName);
}
}
// serialise action labels
Element actionLabelsElement = document.createElement("actionLabels");
tree.appendChild(actionLabelsElement);
Element actionLabelElement;
i = actionLabels.iterator();
while (i.hasNext()) {
actionLabelElement = document.createElement("actionlabel");
actionLabelsElement.appendChild(actionLabelElement);
String actionLabel = i.next();
actionLabelElement.setAttribute("label", actionLabel);
}
}
protected void encodeObject(
org.w3c.dom.Document document,
org.w3c.dom.Element node,
edu.cmu.cs.stage3.io.DirectoryTreeStorer storer,
edu.cmu.cs.stage3.alice.core.ReferenceGenerator referenceGenerator)
throws java.io.IOException {
java.util.Dictionary dict = getDictionaryValue();
if (dict != null) {
java.util.Enumeration enum0 = dict.keys();
while (enum0.hasMoreElements()) {
Object key = enum0.nextElement();
Object value = dict.get(key);
org.w3c.dom.Element entryNode = document.createElement("entry");
org.w3c.dom.Element keyNode = document.createElement("key");
keyNode.setAttribute("class", key.getClass().getName());
keyNode.appendChild(createNodeForString(document, key.toString()));
org.w3c.dom.Element valueNode = document.createElement("value");
valueNode.setAttribute("class", value.getClass().getName());
valueNode.appendChild(createNodeForString(document, value.toString()));
entryNode.appendChild(keyNode);
entryNode.appendChild(valueNode);
node.appendChild(entryNode);
}
}
}
/**
* @param monitor
* @throws Exception
*/
private void addServletToGwtXml(IProgressMonitor monitor) throws Exception {
monitor = Util.getNonNullMonitor(monitor);
try {
monitor.beginTask("", 1);
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = factory.newDocumentBuilder();
File moduleFile = getModuleFile();
Document document = builder.parse(moduleFile);
Node module = document.getDocumentElement();
Element newServlet = document.createElement("servlet");
newServlet.setAttribute("path", "/" + serviceUri); // $NON-NLS-2$
newServlet.setAttribute(
"class",
getPackageFragment().getElementName() + '.' + getTypeName() + "Impl"); // $NON-NLS-2$
module.appendChild(newServlet);
Transformer writer = TransformerFactory.newInstance().newTransformer();
writer.transform(new DOMSource(document), new StreamResult(moduleFile));
} finally {
monitor.done();
}
}
/** The whole testsuite ended. */
public void endTestSuite(JUnitTest suite) throws BuildException {
rootElement.setAttribute(ATTR_TESTS, "" + suite.runCount());
rootElement.setAttribute(ATTR_FAILURES, "" + suite.failureCount());
rootElement.setAttribute(ATTR_ERRORS, "" + suite.errorCount());
rootElement.setAttribute(ATTR_TIME, "" + (suite.getRunTime() / 1000.0));
if (out != null) {
Writer wri = null;
try {
wri = new BufferedWriter(new OutputStreamWriter(out, "UTF8"));
wri.write("<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n");
(new DOMElementWriter()).write(rootElement, wri, 0, " ");
wri.flush();
} catch (IOException exc) {
throw new BuildException("Unable to write log file", exc);
} finally {
if (out != System.out && out != System.err) {
if (wri != null) {
try {
wri.close();
} catch (IOException e) {
// ignore
}
}
}
}
}
}
/**
* Test adding a second md-record to ContentRelation. One md-record already exists.
*
* @throws Exception Thrown if adding one md-record failed.
*/
@Test
public void testAddMdRecord() throws Exception {
// add one more md-record
Document relationCreated = getDocument(relationXml);
NodeList mdRecordsCreated =
selectNodeList(relationCreated, "/content-relation/md-records/md-record");
int numberMdRecordsCreated = mdRecordsCreated.getLength();
Element mdRecord =
relationCreated.createElementNS(
"http://www.escidoc.de/schemas/metadatarecords/0.5",
"escidocMetadataRecords:md-record");
mdRecord.setAttribute("name", "md2");
mdRecord.setAttribute("schema", "bla");
Element mdRecordContent = relationCreated.createElement("md");
mdRecord.appendChild(mdRecordContent);
mdRecordContent.setTextContent("bla");
selectSingleNode(relationCreated, "/content-relation/md-records").appendChild(mdRecord);
String relationWithNewMdRecord = toString(relationCreated, false);
String updatedXml = update(this.relationId, relationWithNewMdRecord);
// check updated
assertXmlValidContentRelation(updatedXml);
Document updatedRelationDocument = getDocument(updatedXml);
NodeList mdRecordsUpdated =
selectNodeList(updatedRelationDocument, "/content-relation/md-records/md-record");
int numberMdRecordsUpdated = mdRecordsUpdated.getLength();
assertEquals(
"the content relation should have one additional" + " md-record after update ",
numberMdRecordsUpdated,
numberMdRecordsCreated + 1);
}
/**
* Interface TestListener.
*
* <p>A Test is finished.
*/
public void endTest(Test test) {
// Fix for bug #5637 - if a junit.extensions.TestSetup is
// used and throws an exception during setUp then startTest
// would never have been called
if (!testStarts.containsKey(test)) {
startTest(test);
}
Element currentTest = null;
if (!failedTests.containsKey(test)) {
currentTest = doc.createElement(TESTCASE);
currentTest.setAttribute(ATTR_NAME, JUnitVersionHelper.getTestCaseName(test));
// a TestSuite can contain Tests from multiple classes,
// even tests with the same name - disambiguate them.
currentTest.setAttribute(ATTR_CLASSNAME, test.getClass().getName());
rootElement.appendChild(currentTest);
testElements.put(test, currentTest);
} else {
currentTest = (Element) testElements.get(test);
}
Long l = (Long) testStarts.get(test);
currentTest.setAttribute(
ATTR_TIME, "" + ((System.currentTimeMillis() - l.longValue()) / 1000.0));
}
protected boolean logUserStoreLogin(
User user,
AdminService admin,
String remoteIP,
String remoteHost,
UserStoreKey userStoreKey) {
try {
Document doc = XMLTool.createDocument("logentry");
Element rootElement = doc.getDocumentElement();
// UserStoreKey userStoreKey = user.getUserStoreKey();
if (userStoreKey != null) {
rootElement.setAttribute("userstorekey", String.valueOf(userStoreKey));
}
rootElement.setAttribute("sitekey", String.valueOf(0));
rootElement.setAttribute("typekey", String.valueOf(LogType.LOGIN_USERSTORE.asInteger()));
rootElement.setAttribute("inetaddress", remoteIP);
XMLTool.createElement(doc, rootElement, "data");
admin.createLogEntries(user, XMLTool.documentToString(doc));
} catch (VerticalSecurityException vse) {
String message = "Failed to create log entry because of security error: %t";
VerticalAdminLogger.error(this.getClass(), 1, message, vse);
return false;
}
return true;
}
/**
* Add attachement element for the javadoc artifact if present.
*
* <pre>
* <attach file="${basedir}/target/my-project-1.0-javadoc.jar"
* type="jar"
* classifier="javadoc"/>
* </pre>
*
* @param el element to add the attachment to.
* @param ba The bundle archive to add a source artifact for.
* @param prefix Whitespace to add before the new element.
*/
private void addJavadocAttachment(final Element el, final BundleArchive ba, final String prefix) {
String javadocPath = ba.file.getAbsolutePath();
// Remove ".jar" suffix.
javadocPath = javadocPath.substring(0, javadocPath.length() - 4);
javadocPath = javadocPath + "-javadoc.jar";
final File javadocFile = new File(javadocPath);
if (javadocFile.exists()) {
final Document doc = el.getOwnerDocument();
final String prefix1 = prefix + " ";
final String prefix2 = prefix1 + " ";
final Element javadocAttachment = doc.createElement("javadoc-attachment");
el.appendChild(doc.createTextNode("\n" + prefix1));
el.appendChild(javadocAttachment);
el.appendChild(doc.createTextNode("\n" + prefix));
final Element attach = doc.createElement("attach");
javadocAttachment.appendChild(doc.createTextNode("\n" + prefix2));
javadocAttachment.appendChild(attach);
javadocAttachment.appendChild(doc.createTextNode("\n" + prefix1));
attach.setAttribute("file", javadocPath);
attach.setAttribute("type", "jar");
attach.setAttribute("classifier", "javadoc");
}
}