private void guardaRes(String resu, CliGol cliGol)
throws ParserConfigurationException, SAXException, IOException {
String[] nodos = {"NoHit", "Hit", "Buro"};
DocumentBuilder db = DocumentBuilderFactory.newInstance().newDocumentBuilder();
InputSource is = new InputSource(new StringReader(resu));
Document xml = db.parse(is);
Element raiz = xml.getDocumentElement();
String nombre = obtenerNombre(raiz);
for (String s : nodos) {
Node nodo =
raiz.getElementsByTagName(s) == null ? null : raiz.getElementsByTagName(s).item(0);
if (nodo != null) {
String informacion = sustraerInformacionNodo(cliGol, nodo);
guardarEnListas(nodo.getNodeName(), nombre + "," + informacion);
}
}
}
/**
* WhiteboardObjectTextJabberImpl constructor.
*
* @param xml the XML string object to parse.
*/
public WhiteboardObjectTextJabberImpl(String xml) {
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder;
try {
builder = factory.newDocumentBuilder();
InputStream in = new ByteArrayInputStream(xml.getBytes());
Document doc = builder.parse(in);
Element e = doc.getDocumentElement();
String elementName = e.getNodeName();
if (elementName.equals("text")) {
// we have a text
String id = e.getAttribute("id");
double x = Double.parseDouble(e.getAttribute("x"));
double y = Double.parseDouble(e.getAttribute("y"));
String fill = e.getAttribute("fill");
String fontFamily = e.getAttribute("font-family");
int fontSize = Integer.parseInt(e.getAttribute("font-size"));
String text = e.getTextContent();
this.setID(id);
this.setWhiteboardPoint(new WhiteboardPoint(x, y));
this.setFontName(fontFamily);
this.setFontSize(fontSize);
this.setText(text);
this.setColor(Color.decode(fill).getRGB());
}
} catch (ParserConfigurationException ex) {
if (logger.isDebugEnabled()) logger.debug("Problem WhiteboardObject : " + xml);
} catch (IOException ex) {
if (logger.isDebugEnabled()) logger.debug("Problem WhiteboardObject : " + xml);
} catch (Exception ex) {
if (logger.isDebugEnabled()) logger.debug("Problem WhiteboardObject : " + xml);
}
}
// Lee la configuracion que se encuentra en conf/RegistryConf
private void readConfXml() {
try {
File inputFile = new File("src/java/Conf/RegistryConf.xml");
DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();
DocumentBuilder dBuilder = dbFactory.newDocumentBuilder();
Document doc = dBuilder.parse(inputFile);
doc.getDocumentElement().normalize();
NodeList nList = doc.getElementsByTagName("RegistryConf");
for (int i = 0; i < nList.getLength(); i++) {
Node nNode = nList.item(i);
if (nNode.getNodeType() == Node.ELEMENT_NODE) {
Element eElement = (Element) nNode;
RegistryConf reg = new RegistryConf();
String aux;
int idSensor;
int value;
aux = eElement.getElementsByTagName("idSensor").item(0).getTextContent();
idSensor = Integer.parseInt(aux);
reg.setIdSensor(idSensor);
aux = eElement.getElementsByTagName("saveType").item(0).getTextContent();
reg.setSaveTypeString(aux);
aux = eElement.getElementsByTagName("value").item(0).getTextContent();
value = Integer.parseInt(aux);
reg.setValue(value);
registryConf.add(reg);
lastRead.put(idSensor, 0);
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
public ArrayList<String> parseXML() throws Exception {
ArrayList<String> ret = new ArrayList<String>();
handshake();
URL url =
new URL(
"http://mangaonweb.com/page.do?cdn="
+ cdn
+ "&cpn=book.xml&crcod="
+ crcod
+ "&rid="
+ (int) (Math.random() * 10000));
String page = DownloaderUtils.getPage(url.toString(), "UTF-8", cookies);
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = factory.newDocumentBuilder();
InputSource is = new InputSource(new StringReader(page));
Document d = builder.parse(is);
Element doc = d.getDocumentElement();
NodeList pages = doc.getElementsByTagName("page");
total = pages.getLength();
for (int i = 0; i < pages.getLength(); i++) {
Element e = (Element) pages.item(i);
ret.add(e.getAttribute("path"));
}
return (ret);
}
/**
* Set a property of a resource to a value.
*
* @param name the property name
* @param value the property value
* @exception com.ibm.webdav.WebDAVException
*/
public void setProperty(String name, Element value) throws WebDAVException {
// load the properties
Document propertiesDocument = resource.loadProperties();
Element properties = propertiesDocument.getDocumentElement();
String ns = value.getNamespaceURI();
Element property = null;
if (ns == null) {
property = (Element) ((Element) properties).getElementsByTagName(value.getTagName()).item(0);
} else {
property = (Element) properties.getElementsByTagNameNS(ns, value.getLocalName()).item(0);
}
if (property != null) {
try {
properties.removeChild(property);
} catch (DOMException exc) {
}
}
properties.appendChild(propertiesDocument.importNode(value, true));
// write out the properties
resource.saveProperties(propertiesDocument);
}
public static void main(String args[]) throws Exception {
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
DocumentBuilder parser = dbf.newDocumentBuilder();
Document xmldoc = parser.parse("addr.xml");
Element root = xmldoc.getDocumentElement();
System.out.println(root);
}
public static void testEnum() throws Exception {
Builder b = new Builder();
b.addClasspath(new File("bin"));
b.setProperty("Export-Package", "test.metatype");
b.setProperty("-metatype", "*");
b.build();
assertEquals(0, b.getErrors().size());
assertEquals(0, b.getWarnings().size());
Resource r = b.getJar().getResource("OSGI-INF/metatype/test.metatype.MetatypeTest$Enums.xml");
IO.copy(r.openInputStream(), System.err);
Document d = db.parse(r.openInputStream());
assertEquals(
"http://www.osgi.org/xmlns/metatype/v1.1.0", d.getDocumentElement().getNamespaceURI());
Properties p = new Properties();
p.setProperty("r", "requireConfiguration");
p.setProperty("i", "ignoreConfiguration");
p.setProperty("o", "optionalConfiguration");
Enums enums = Configurable.createConfigurable(Enums.class, (Map<Object, Object>) p);
assertEquals(Enums.X.requireConfiguration, enums.r());
assertEquals(Enums.X.ignoreConfiguration, enums.i());
assertEquals(Enums.X.optionalConfiguration, enums.o());
}
/**
* Given a DICOM object encoded as an XML document convert it to a list of attributes.
*
* @param document the XML document
* @return the list of DICOM attributes
* @exception DicomException
*/
public AttributeList getAttributeList(Document document) throws DicomException {
AttributeList list = new AttributeList();
org.w3c.dom.Node element = document.getDocumentElement(); // should be DicomObject
addAttributesFromNodeToList(list, element);
// System.err.println("XMLRepresentationOfDicomObjectFactory.getAttributeList(Document
// document): List is "+list);
return list;
}
public WarXMLReader(String fileName, War w)
throws ParserConfigurationException, SAXException, IOException {
this.war = w;
factory = DocumentBuilderFactory.newInstance();
builder = factory.newDocumentBuilder();
document = builder.parse(new File(fileName));
root = document.getDocumentElement();
}
private void loadFromXml(String fileName)
throws ParserConfigurationException, SAXException, IOException, ParseException {
System.out.println("NeuralNetwork : loading network topology from file " + fileName);
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
DocumentBuilder parser = factory.newDocumentBuilder();
Document doc = parser.parse(fileName);
Node nodeNeuralNetwork = doc.getDocumentElement();
if (!nodeNeuralNetwork.getNodeName().equals("neuralNetwork"))
throw new ParseException(
"[Error] NN-Load: Parse error in XML file, neural network couldn't be loaded.", 0);
// nodeNeuralNetwork ok
// indexNeuralNetworkContent -> indexStructureContent -> indexLayerContent -> indexNeuronContent
// -> indexNeuralInputContent
NodeList nodeNeuralNetworkContent = nodeNeuralNetwork.getChildNodes();
for (int innc = 0; innc < nodeNeuralNetworkContent.getLength(); innc++) {
Node nodeStructure = nodeNeuralNetworkContent.item(innc);
if (nodeStructure.getNodeName().equals("structure")) { // for structure element
NodeList nodeStructureContent = nodeStructure.getChildNodes();
for (int isc = 0; isc < nodeStructureContent.getLength(); isc++) {
Node nodeLayer = nodeStructureContent.item(isc);
if (nodeLayer.getNodeName().equals("layer")) { // for layer element
NeuralLayer neuralLayer = new NeuralLayer(this);
this.listLayers.add(neuralLayer);
NodeList nodeLayerContent = nodeLayer.getChildNodes();
for (int ilc = 0; ilc < nodeLayerContent.getLength(); ilc++) {
Node nodeNeuron = nodeLayerContent.item(ilc);
if (nodeNeuron.getNodeName().equals("neuron")) { // for neuron in layer
Neuron neuron =
new Neuron(
Double.parseDouble(((Element) nodeNeuron).getAttribute("threshold")),
neuralLayer);
neuralLayer.listNeurons.add(neuron);
NodeList nodeNeuronContent = nodeNeuron.getChildNodes();
for (int inc = 0; inc < nodeNeuronContent.getLength(); inc++) {
Node nodeNeuralInput = nodeNeuronContent.item(inc);
// if (nodeNeuralInput==null) System.out.print("-"); else System.out.print("*");
if (nodeNeuralInput.getNodeName().equals("input")) {
// System.out.println("neuron at
// STR:"+innc+" LAY:"+isc+" NEU:"+ilc+" INP:"+inc);
NeuralInput neuralInput =
new NeuralInput(
Double.parseDouble(((Element) nodeNeuralInput).getAttribute("weight")),
neuron);
neuron.listInputs.add(neuralInput);
}
}
}
}
}
}
}
}
}
/**
* ** Gets a virtual DBRecord from the specified remote service ** @param servReq The remote web
* service ** @return The virtual DBRecord (cannot be saved or reloaded)
*/
@SuppressWarnings("unchecked")
public gDBR getVirtualDBRecord(final ServiceRequest servReq) throws DBException {
String CMD_dbget = DBFactory.CMD_dbget;
String TAG_Response = servReq.getTagResponse();
String TAG_Record = DBFactory.TAG_Record;
String ATTR_command = servReq.getAttrCommand();
String ATTR_result = servReq.getAttrResult();
/* send request / get response */
Document xmlDoc = null;
try {
xmlDoc =
servReq.sendRequest(
CMD_dbget,
new ServiceRequest.RequestBody() {
public StringBuffer appendRequestBody(StringBuffer sb, int indent) {
return DBRecordKey.this.toRequestXML(sb, indent);
}
});
} catch (IOException ioe) {
Print.logException("Error", ioe);
throw new DBException("Request read error", ioe);
}
/* parse 'GTSResponse' */
Element gtsResponse = xmlDoc.getDocumentElement();
if (!gtsResponse.getTagName().equalsIgnoreCase(TAG_Response)) {
Print.logError("Request XML does not start with '%s'", TAG_Response);
throw new DBException("Response XML does not begin eith '" + TAG_Response + "'");
}
/* request command/argument */
String cmd = StringTools.trim(gtsResponse.getAttribute(ATTR_command));
String result = StringTools.trim(gtsResponse.getAttribute(ATTR_result));
if (StringTools.isBlank(result)) {
result = StringTools.trim(gtsResponse.getAttribute("type"));
}
if (!result.equalsIgnoreCase("success")) {
Print.logError("Response indicates failure");
throw new DBException("Response does not indicate 'success'");
}
/* Record */
NodeList rcdList = XMLTools.getChildElements(gtsResponse, TAG_Record);
if (rcdList.getLength() <= 0) {
Print.logError("No 'Record' tags");
throw new DBException("GTSResponse does not contain any 'Record' tags");
}
Element rcdElem = (Element) rcdList.item(0);
/* return DBRecord */
gDBR dbr = (gDBR) DBFactory.parseXML_DBRecord(rcdElem);
dbr.setVirtual(true);
return dbr;
}
private static Element readXmlFile(GenericFile file) {
try {
BufferedReader reader = new BufferedReader(file.getReader());
StringBuilder sBuilder = new StringBuilder();
for (String line = reader.readLine(); line != null; line = reader.readLine()) {
sBuilder.append(line);
sBuilder.append("\n");
}
DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();
DocumentBuilder dBuilder = dbFactory.newDocumentBuilder();
Document doc = dBuilder.parse(new ByteArrayInputStream(sBuilder.toString().getBytes()));
doc.getDocumentElement().normalize();
return doc.getDocumentElement();
} catch (Exception e) {
e.printStackTrace();
System.err.println(e.getMessage());
return null;
}
}
/**
* Advanced users only; use loadXML() in PApplet.
*
* <p>Added extra code to handle \u2028 (Unicode NLF), which is sometimes inserted by web browsers
* (Safari?) and not distinguishable from a "real" LF (or CRLF) in some text editors (i.e.
* TextEdit on OS X). Only doing this for XML (and not all Reader objects) because LFs are
* essential. https://github.com/processing/processing/issues/2100
*
* @nowebref
*/
public XML(final Reader reader, String options)
throws IOException, ParserConfigurationException, SAXException {
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
// Prevent 503 errors from www.w3.org
try {
factory.setAttribute("http://apache.org/xml/features/nonvalidating/load-external-dtd", false);
} catch (IllegalArgumentException e) {
// ignore this; Android doesn't like it
}
// without a validating DTD, this doesn't do anything since it doesn't know what is ignorable
// factory.setIgnoringElementContentWhitespace(true);
factory.setExpandEntityReferences(false);
// factory.setExpandEntityReferences(true);
// factory.setCoalescing(true);
// builderFactory.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
DocumentBuilder builder = factory.newDocumentBuilder();
// builder.setEntityResolver()
// SAXParserFactory spf = SAXParserFactory.newInstance();
// spf.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
// SAXParser p = spf.newSAXParser();
// builder = DocumentBuilderFactory.newDocumentBuilder();
// builder = new SAXBuilder();
// builder.setValidation(validating);
Document document =
builder.parse(
new InputSource(
new Reader() {
@Override
public int read(char[] cbuf, int off, int len) throws IOException {
int count = reader.read(cbuf, off, len);
for (int i = 0; i < count; i++) {
if (cbuf[off + i] == '\u2028') {
cbuf[off + i] = '\n';
}
}
return count;
}
@Override
public void close() throws IOException {
reader.close();
}
}));
node = document.getDocumentElement();
}
public void load(InputStream is) throws IOException, ParserConfigurationException, SAXException {
doc = db.parse(is);
docElt = doc.getDocumentElement();
if (docElt.getTagName().equals(docElementName)) {
NodeList nl = docElt.getElementsByTagName(trackElementName);
for (int i = 0; i < nl.getLength(); i++) {
Element elt = (Element) nl.item(i);
Track track = new Track(elt);
tracks.add(track);
hash.put(track.getKey(), track);
}
}
}
@Override
public VPackage parse() {
logger.debug("Starting parsing package: " + xmlFile.getAbsolutePath());
long startParsing = System.currentTimeMillis();
try {
Document document = getDocument();
Element root = document.getDocumentElement();
_package = new VPackage(xmlFile);
Node name = root.getElementsByTagName(EL_NAME).item(0);
_package.setName(name.getTextContent());
Node descr = root.getElementsByTagName(EL_DESCRIPTION).item(0);
_package.setDescription(descr.getTextContent());
NodeList list = root.getElementsByTagName(EL_CLASS);
boolean initPainters = false;
for (int i = 0; i < list.getLength(); i++) {
PackageClass pc = parseClass((Element) list.item(i));
if (pc.getPainterName() != null) {
initPainters = true;
}
}
if (initPainters) {
_package.initPainters();
}
logger.info(
"Parsing the package '{}' finished in {}ms.\n",
_package.getName(),
(System.currentTimeMillis() - startParsing));
} catch (Exception e) {
collector.collectDiagnostic(e.getMessage(), true);
if (RuntimeProperties.isLogDebugEnabled()) {
e.printStackTrace();
}
}
try {
checkProblems("Error parsing package file " + xmlFile.getName());
} catch (Exception e) {
return null;
}
return _package;
}
public static void main(String[] args) {
try {
// Find the implementation
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
factory.setNamespaceAware(true);
DocumentBuilder builder = factory.newDocumentBuilder();
DOMImplementation impl = builder.getDOMImplementation();
// Create the document
DocumentType svgDOCTYPE =
impl.createDocumentType(
"svg",
"-//W3C//DTD SVG 1.0//EN",
"http://www.w3.org/TR/2001/REC-SVG-20010904/DTD/svg10.dtd");
Document doc = impl.createDocument("http://www.w3.org/2000/svg", "svg", svgDOCTYPE);
// Fill the document
Node rootElement = doc.getDocumentElement();
ProcessingInstruction xmlstylesheet =
doc.createProcessingInstruction(
"xml-stylesheet", "type=\"text/css\" href=\"standard.css\"");
Comment comment = doc.createComment("An example from Chapter 10 of Processing XML with Java");
doc.insertBefore(comment, rootElement);
doc.insertBefore(xmlstylesheet, rootElement);
Node desc = doc.createElementNS("http://www.w3.org/2000/svg", "desc");
rootElement.appendChild(desc);
Text descText = doc.createTextNode("An example from Processing XML with Java");
desc.appendChild(descText);
// Serialize the document onto System.out
TransformerFactory xformFactory = TransformerFactory.newInstance();
Transformer idTransform = xformFactory.newTransformer();
Source input = new DOMSource(doc);
Result output = new StreamResult(System.out);
idTransform.transform(input, output);
} catch (FactoryConfigurationError e) {
System.out.println("Could not locate a JAXP factory class");
} catch (ParserConfigurationException e) {
System.out.println("Could not locate a JAXP DocumentBuilder class");
} catch (DOMException e) {
System.err.println(e);
} catch (TransformerConfigurationException e) {
System.err.println(e);
} catch (TransformerException e) {
System.err.println(e);
}
}
public static void main(String[] args) {
try {
DocumentBuilderFactory dBuilderFactory = DocumentBuilderFactory.newInstance();
DocumentBuilder dBuilder = dBuilderFactory.newDocumentBuilder();
Document document = dBuilder.parse("DOMSample.xml");
Element rootElement = document.getDocumentElement();
System.out.println("Root Element's Value : " + rootElement.getTextContent());
} catch (Exception e) {
e.printStackTrace(System.err);
}
}
public static final Skeleton loadSkeleton(File file) {
try {
FileInputStream input_stream = new FileInputStream(file);
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
factory.setValidating(true);
DocumentBuilder builder = factory.newDocumentBuilder();
builder.setErrorHandler(new GeometryErrorHandler());
Document document = builder.parse(input_stream);
Element root = document.getDocumentElement();
return parseSkeleton(root);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
/**
* Get all the properties of this resource. This implementation stores properties in an XML
* document containing a properties root element. The properties file name is derived from the URI
* by adding the extension PropertiesManager.propertiesSuffix. This applies to collections as well
* as other resources.
*
* <p>Since the properties are stored in a file, and all methods that query and update the
* properties must read the XML file into memory and parse it, many of the other property methods
* are implemented by calling this method. Subclasses of ResourceImpl may want to use other
* techniques depending on how the properties are stored.
*
* @return a MultiStatus containing response elements with prop elements containing the properties
* and their statuses.
* @exception com.ibm.webdav.WebDAVException
*/
public MultiStatus getProperties() throws WebDAVException {
Document propertiesDocument = resource.loadProperties();
// create a MultiStatus to hold the results
MultiStatus results = new MultiStatus();
// create a response element to hold the properties for this resource
PropertyResponse response = null;
String urlstring;
if (false) {
// I consider this to be the more correct way and the
// way used in the examples in the spec... but it is
// redundant and creates the possibility of the two
// redundant parts being out of synch.
urlstring = resource.getURL().toString();
} else {
// this is the way that mod_dav and a few others do it. This
// way also makes it easier to debug clients even if
// redirecting through a dedicated proxy. Without this
// it's inconvenient to debug IE5. It gets confused if
// the host:port (if provided) don't match who it thinks
// it's connecting to.
urlstring = resource.getURL().getFile();
}
response = new PropertyResponse(urlstring);
// add the properties to the response
NodeList properties = propertiesDocument.getDocumentElement().getChildNodes();
Node temp = null;
for (int i = 0; i < properties.getLength(); i++) {
temp = properties.item(i);
// Skip ignorable TXText elements
if (!(temp.getNodeType() == Node.ELEMENT_NODE)) {
continue;
}
Element property = (Element) temp;
PropertyName pn = new PropertyName(property);
response.addProperty(pn, property, WebDAVStatus.SC_OK);
}
results.addResponse(response);
return results;
}
public void read(Document doc) {
try {
Element root = doc.getDocumentElement();
NodeList nList = doc.getElementsByTagName("user");
for (int i = 0; i < nList.getLength(); i++) {
Node node = nList.item(i);
if (node.getNodeType() == Node.ELEMENT_NODE) {
Element element = (Element) node;
}
}
// Element e1 = (Element) nList.item(0);
} catch (Exception e) {
}
}
public void save(String filename) {
try {
Document document = element.getOwnerDocument();
document.getDocumentElement().normalize();
TransformerFactory tFactory = TransformerFactory.newInstance();
tFactory.setAttribute("indent-number", new Integer(4));
Transformer transformer = tFactory.newTransformer();
transformer.setOutputProperty(OutputKeys.INDENT, "yes");
DOMSource source = new DOMSource(document);
File file = new File(filename);
StreamResult result = new StreamResult(file);
transformer.transform(source, result);
} catch (Exception e) {
severe("Could not save XML file: " + e.getMessage());
}
}
/**
* Method that reads a XML-file, and returns a Model that contains the information
*
* @param file
* @return
* @return
*/
public static Model readXML(String file) {
// initialize table to be filled with content of XML file
Model t = new Model();
try {
// Create file to be parsed by document parser
File xmlfile = new File(file);
// create parser
DocumentBuilder parser = DocumentBuilderFactory.newInstance().newDocumentBuilder();
// parse the file
Document parsedfile = parser.parse(xmlfile);
// normalize the parsed file (make it more user-friendly)
parsedfile.getDocumentElement().normalize();
NodeList cells = parsedfile.getElementsByTagName("CELL");
for (int i = 0; i < cells.getLength(); i++) {
// Get cell at list index i
Node currentcell = cells.item(i);
// read the elements "location" attributes row/column
if (Node.ELEMENT_NODE == currentcell.getNodeType()) {
Element cellinfo = (Element) currentcell;
// get the row number from node attribute
int row = Integer.parseInt(cellinfo.getAttribute("row")) - 1;
// get the column number from the node attribute
int col = Integer.parseInt(cellinfo.getAttribute("column")) - 1;
// get content from node
String content = cellinfo.getTextContent();
if (content != null) {
content = content.replace("\n", "");
}
// Make the content an Integer (if it is a number), easier
// for
// using it later on
// put content in table, with row/column inserted as x/y
t.setContent(row, col, (String) content);
}
}
} catch (ParserConfigurationException e) {
System.out.println("Fileparser could not be made");
} catch (IOException f) {
System.out.println("File could not be parsed, did you enter the correct file name?");
} catch (SAXException g) {
System.out.println("Something went wrong in parsing the file");
}
return t;
}
/**
* Unmarshall a Chromosome instance from a given XML Document representation. Its genes will be
* unmarshalled from the gene sub-elements.
*
* @param a_activeConfiguration the current active Configuration object that is to be used during
* construction of the Chromosome instances
* @param a_xmlDocument the XML Document representation of the Chromosome
* @return a new Chromosome instance setup with the data from the XML Document representation
* @throws ImproperXMLException if the given Document is improperly structured or missing data
* @throws InvalidConfigurationException if the given Configuration is in an inconsistent state
* @throws UnsupportedRepresentationException if the actively configured Gene implementation does
* not support the string representation of the alleles used in the given XML document
* @throws GeneCreationException if there is a problem creating or populating a Gene instance
* @author Neil Rotstan
* @since 1.0
*/
public static Chromosome getChromosomeFromDocument(
Configuration a_activeConfiguration, Document a_xmlDocument)
throws ImproperXMLException, InvalidConfigurationException,
UnsupportedRepresentationException, GeneCreationException {
// Extract the root element, which should be a chromosome element.
// After verifying that the root element is not null and that it
// in fact is a chromosome element, then convert it into a Chromosome
// instance.
// ------------------------------------------------------------------
Element rootElement = a_xmlDocument.getDocumentElement();
if (rootElement == null || !(rootElement.getTagName().equals(CHROMOSOME_TAG))) {
throw new ImproperXMLException(
"Unable to build Chromosome instance from XML Document: "
+ "'chromosome' element must be at root of Document.");
}
return getChromosomeFromElement(a_activeConfiguration, rootElement);
}
/**
* Unlike the loadXML() method in PApplet, this version works with files that are not in UTF-8
* format.
*
* @nowebref
*/
public XML(InputStream input, String options)
throws IOException, ParserConfigurationException, SAXException {
// this(PApplet.createReader(input), options); // won't handle non-UTF8
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
try {
// Prevent 503 errors from www.w3.org
factory.setAttribute("http://apache.org/xml/features/nonvalidating/load-external-dtd", false);
} catch (IllegalArgumentException e) {
// ignore this; Android doesn't like it
}
factory.setExpandEntityReferences(false);
DocumentBuilder builder = factory.newDocumentBuilder();
Document document = builder.parse(new InputSource(input));
node = document.getDocumentElement();
}
/**
* Reads an XML document from an input source and copies its values into the specified object
*
* @param ob The object to receive the values
* @param source The location of the XML document
* @throws IOException If there is an error reading the document
*/
public void readObject(Object ob, InputSource source) throws IOException {
try {
// Create a document builder to read the document
DocumentBuilder builder = factory.newDocumentBuilder();
// Read the document
Document doc = builder.parse(source);
// Get the root element
Element element = doc.getDocumentElement();
// Copy the root element into the bean
readObject(ob, element);
} catch (SAXException exc) {
throw new IOException("Error parsing XML document: " + exc.toString());
} catch (ParserConfigurationException exc) {
throw new IOException("Error parsing XML document: " + exc.toString());
}
}
/** used for cut and paste. */
public void addObjectFromClipboard(String a_value) throws CircularIncludeException {
Reader reader = new StringReader(a_value);
Document document = null;
try {
document = UJAXP.getDocument(reader);
} catch (Exception e) {
e.printStackTrace();
return;
} // try-catch
Element root = document.getDocumentElement();
if (!root.getNodeName().equals("clipboard")) {
return;
} // if
Node child;
for (child = root.getFirstChild(); child != null; child = child.getNextSibling()) {
if (!(child instanceof Element)) {
continue;
} // if
Element element = (Element) child;
IGlyphFactory factory = GlyphFactory.getFactory();
if (XModule.isMatch(element)) {
EModuleInvoke module = (EModuleInvoke) factory.createXModule(element);
addModule(module);
continue;
} // if
if (XContour.isMatch(element)) {
EContour contour = (EContour) factory.createXContour(element);
addContour(contour);
continue;
} // if
if (XInclude.isMatch(element)) {
EIncludeInvoke include = (EIncludeInvoke) factory.createXInclude(element);
addInclude(include);
continue;
} // if
} // while
}
private void call(String script)
throws ParserConfigurationException, TransformerConfigurationException {
File callerScript = this.currentScript;
Document doc = null;
try {
this.currentScript = new File(script);
DocumentBuilder db = DocumentBuilderFactory.newInstance().newDocumentBuilder();
doc = db.parse(this.currentScript);
} catch (Exception ex) {
this.currentScript = callerScript;
Utils.onError(new Error.FileParse(script));
return;
}
NodeList operations = doc.getDocumentElement().getChildNodes();
for (int i = 0; i < operations.getLength(); i++) {
Node operation = operations.item(i);
if (operation.getNodeType() != Node.ELEMENT_NODE) continue;
call(operation);
}
this.currentScript = callerScript;
}
public static List<Tombstone> loadTombstone(String chestsPath, DeathChests plugin) {
LinkedList<Tombstone> deathChests = new LinkedList<>();
try {
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = factory.newDocumentBuilder();
// Start the parser
Document doc = builder.parse(new File(chestsPath));
Element rootElement = doc.getDocumentElement();
String version = rootElement.getAttribute("version");
if (!Settings.getVersion().equals(version)) {
System.out.println(
"The version of the Deathchests-File changed. There are possible errors at loading them. (Probably not if your updated it)");
}
long timestamp = System.currentTimeMillis();
NodeList list = rootElement.getChildNodes();
int length = list.getLength();
for (int i = 0; i < length; i++) {
try {
Node node = list.item(i);
String name = node.getNodeName();
if (name.equalsIgnoreCase(Utils.DEATHCHEST_XML_TAG)) {
deathChests.add(new Tombstone((Element) node, timestamp, plugin));
}
} catch (XMLParseException ex) {
System.err.println("Corrupted deathchest! Skipping this one!");
ex.printStackTrace();
}
}
} catch (IOException | ParserConfigurationException | SAXException ex) {
System.err.println("Error while loading deathchest data:");
ex.printStackTrace();
}
return deathChests;
}
// http://www.java-tips.org/java-se-tips/javax.xml.parsers/how-to-read-xml-file-in-java.html
private double my_ListParser(int itIs) {
double[] my_list = new double[3];
try {
File fXmlFile =
new File("/Users/alexiaKourfali/NetBeansProjects/mav_project3_part2/web/my_list.xml");
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
DocumentBuilder db = dbf.newDocumentBuilder();
Document doc = db.parse(fXmlFile);
doc.getDocumentElement().normalize();
// System.out.println("Root element " + doc.getDocumentElement().getNodeName());
NodeList nodeLst = doc.getElementsByTagName("Entry");
for (int s = 0; s < nodeLst.getLength(); s++) {
Node fstNode = nodeLst.item(s);
if (fstNode.getNodeType() == Node.ELEMENT_NODE) {
Element fstElmnt = (Element) fstNode;
NodeList fstNmElmntLst = fstElmnt.getElementsByTagName("Price");
Element fstNmElmnt = (Element) fstNmElmntLst.item(0);
NodeList fstNm = fstNmElmnt.getChildNodes();
Node nV = (Node) fstNm.item(0);
/*not sureeeee*/
my_list[s] = Double.parseDouble(nV.getNodeValue());
}
}
} catch (Exception e) {
}
if (itIs == 0) return my_list[0];
if (itIs == 1) return my_list[1];
else return my_list[2];
}
/**
* Creates a <code>TextTransition</code> by the Document <code>doc</code>.
*
* @param doc
*/
public TextTransition(Document doc) {
setup(doc.getDocumentElement());
}