/* */ public XMLElement[] getChildren(String path)
/* */ {
/* 641 */ if (path.indexOf('/') != -1) {
/* 642 */ return getChildrenRecursive(PApplet.split(path, '/'), 0);
/* */ }
/* */
/* */
/* 646 */ if (Character.isDigit(path.charAt(0))) {
/* 647 */ return new XMLElement[] { getChild(Integer.parseInt(path)) };
/* */ }
/* 649 */ int childCount = getChildCount();
/* 650 */ XMLElement[] matches = new XMLElement[childCount];
/* 651 */ int matchCount = 0;
/* 652 */ for (int i = 0; i < childCount; i++) {
/* 653 */ XMLElement kid = getChild(i);
/* 654 */ String kidName = kid.getName();
/* 655 */ if ((kidName != null) && (kidName.equals(path))) {
/* 656 */ matches[(matchCount++)] = kid;
/* */ }
/* */ }
/* 659 */ return (XMLElement[])PApplet.subset(matches, 0, matchCount);
/* */ }
/**
* Get any children that match this name or path. Similar to getChild(), but will grab multiple
* matches rather than only the first.
*
* @param name element name or path/to/element
* @return array of child elements that match
* @author processing.org
*/
public XML[] getChildren(String name) {
if (name.length() > 0 && name.charAt(0) == '/') {
throw new IllegalArgumentException("getChildren() should not begin with a slash");
}
if (name.indexOf('/') != -1) {
return getChildrenRecursive(PApplet.split(name, '/'), 0);
}
// if it's a number, do an index instead
// (returns a single element array, since this will be a single match
if (Character.isDigit(name.charAt(0))) {
return new XML[] {getChild(Integer.parseInt(name))};
}
int childCount = getChildCount();
XML[] matches = new XML[childCount];
int matchCount = 0;
for (int i = 0; i < childCount; i++) {
XML kid = getChild(i);
String kidName = kid.getName();
if (kidName != null && kidName.equals(name)) {
matches[matchCount++] = kid;
}
}
return (XML[]) PApplet.subset(matches, 0, matchCount);
}
/**
* Improve efficiency by removing allocated but unused entries from the internal array used to
* store the data. Set to private, though it could be useful to have this public if lists are
* frequently making drastic size changes (from very large to very small).
*/
private void crop() {
if (count != data.length) {
data = PApplet.subset(data, 0, count);
}
}
/**
* Format this XML data as a String.
*
* @webref xml:method
* @brief Formats XML data as a String
* @param indent -1 for a single line (and no declaration), >= 0 for indents and newlines
* @return the content
* @see XML#toString()
*/
public String format(int indent) {
try {
// entities = doctype.getEntities()
boolean useIndentAmount = false;
TransformerFactory factory = TransformerFactory.newInstance();
if (indent != -1) {
try {
factory.setAttribute("indent-number", indent);
} catch (IllegalArgumentException e) {
useIndentAmount = true;
}
}
Transformer transformer = factory.newTransformer();
// Add the XML declaration at the top if this node is the root and we're
// not writing to a single line (indent = -1 means single line).
if (indent == -1 || parent == null) {
transformer.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION, "yes");
} else {
transformer.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION, "no");
}
// transformer.setOutputProperty(OutputKeys.DOCTYPE_SYSTEM, "sample.dtd");
transformer.setOutputProperty(OutputKeys.METHOD, "xml");
// transformer.setOutputProperty(OutputKeys.CDATA_SECTION_ELEMENTS, "yes"); // huh?
// transformer.setOutputProperty(OutputKeys.DOCTYPE_PUBLIC,
// "-//W3C//DTD XHTML 1.0 Transitional//EN");
// transformer.setOutputProperty(OutputKeys.DOCTYPE_SYSTEM,
// "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd");
// For Android, because (at least 2.3.3) doesn't like indent-number
if (useIndentAmount) {
transformer.setOutputProperty(
"{http://xml.apache.org/xslt}indent-amount", String.valueOf(indent));
}
// transformer.setOutputProperty(OutputKeys.ENCODING,"ISO-8859-1");
// transformer.setOutputProperty(OutputKeys.ENCODING,"UTF8");
transformer.setOutputProperty(OutputKeys.ENCODING, "UTF-8");
// transformer.setOutputProperty(OutputKeys.CDATA_SECTION_ELEMENTS
// Always indent, otherwise the XML declaration will just be jammed
// onto the first line with the XML code as well.
transformer.setOutputProperty(OutputKeys.INDENT, "yes");
// Properties p = transformer.getOutputProperties();
// for (Object key : p.keySet()) {
// System.out.println(key + " -> " + p.get(key));
// }
// If you smell something, that's because this code stinks. No matter
// the settings of the Transformer object, if the XML document already
// has whitespace elements, it won't bother re-indenting/re-formatting.
// So instead, transform the data once into a single line string.
// If indent is -1, then we're done. Otherwise re-run and the settings
// of the factory will kick in. If you know a better way to do this,
// please contribute. I've wasted too much of my Sunday on it. But at
// least the Giants are getting blown out by the Falcons.
final String decl = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>";
final String sep = System.getProperty("line.separator");
StringWriter tempWriter = new StringWriter();
StreamResult tempResult = new StreamResult(tempWriter);
transformer.transform(new DOMSource(node), tempResult);
String[] tempLines = PApplet.split(tempWriter.toString(), sep);
// PApplet.println(tempLines);
if (tempLines[0].startsWith("<?xml")) {
// Remove XML declaration from the top before slamming into one line
int declEnd = tempLines[0].indexOf("?>") + 2;
// if (tempLines[0].length() == decl.length()) {
if (tempLines[0].length() == declEnd) {
// If it's all the XML declaration, remove it
// PApplet.println("removing first line");
tempLines = PApplet.subset(tempLines, 1);
} else {
// PApplet.println("removing part of first line");
// If the first node has been moved to this line, be more careful
// tempLines[0] = tempLines[0].substring(decl.length());
tempLines[0] = tempLines[0].substring(declEnd);
}
}
String singleLine = PApplet.join(PApplet.trim(tempLines), "");
if (indent == -1) {
return singleLine;
}
// Might just be whitespace, which won't be valid XML for parsing below.
// https://github.com/processing/processing/issues/1796
// Since indent is not -1, that means they want valid XML,
// so we'll give them the single line plus the decl... Lame? sure.
if (singleLine.trim().length() == 0) {
// You want whitespace? I've got your whitespace right here.
return decl + sep + singleLine;
}
// Since the indent is not -1, bring back the XML declaration
// transformer.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION, "no");
StringWriter stringWriter = new StringWriter();
StreamResult xmlOutput = new StreamResult(stringWriter);
// DOMSource source = new DOMSource(node);
Source source = new StreamSource(new StringReader(singleLine));
transformer.transform(source, xmlOutput);
String outgoing = stringWriter.toString();
// Add the XML declaration to the top if it's not there already
if (outgoing.startsWith(decl)) {
int declen = decl.length();
int seplen = sep.length();
if (outgoing.length() > declen + seplen
&& !outgoing.substring(declen, declen + seplen).equals(sep)) {
// make sure there's a line break between the XML decl and the code
return outgoing.substring(0, decl.length()) + sep + outgoing.substring(decl.length());
}
return outgoing;
} else {
return decl + sep + outgoing;
}
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
protected void crop() {
if (count != keys.length) {
keys = PApplet.subset(keys, 0, count);
values = PApplet.subset(values, 0, count);
}
}