mirror of
https://codeberg.org/qg-info-unterricht/zpg-graphentester.git
synced 2026-03-25 04:58:24 +01:00
639 lines
19 KiB
Java
639 lines
19 KiB
Java
package imp;
|
|
|
|
/**
|
|
* Klasse zum Vereinfachten Zugriff auf XML-Dokumente
|
|
* Diese Klasse ist für den Einsatz in der Schule gedacht und soll den Schülern
|
|
* einen einfachen Zugriff auf XML-Dokumente ermöglichen. Die zur Verfügung
|
|
* stehenden Befehle sind wie in Processing realisiert.
|
|
* Dabei ist jeder Teilbaum des Dokuments wieder als XML-Objekt zugreifbar, das
|
|
* intern auf die gleiche XML-Dokumentstruktur zugreift.
|
|
* Dies ermöglicht bei unsachgemäßem Gebrauch die XML-Struktur zu zerstören. Im
|
|
* normalen Gebrauch sollte dies aber nicht relevant sein.
|
|
*
|
|
* Benötigt: jdom-1.1.3.jar
|
|
|
|
* @author Thomas Schaller
|
|
* @version 1.0 vom 31.01.2019
|
|
*/
|
|
import java.io.File;
|
|
import java.io.IOException;
|
|
import java.util.List;
|
|
import java.util.ArrayList;
|
|
import java.io.*;
|
|
|
|
import org.jdom.Document;
|
|
import org.jdom.Element;
|
|
import org.jdom.Attribute;
|
|
import org.jdom.JDOMException;
|
|
import org.jdom.input.SAXBuilder;
|
|
import org.jdom.output.XMLOutputter;
|
|
import org.jdom.output.Format;
|
|
|
|
public class XML {
|
|
// Anfang Attribute
|
|
// XML-Dokumentstruktur
|
|
private Document doc;
|
|
// Zeiger auf das aktuelle Element
|
|
private Element current;
|
|
// Ende Attribute
|
|
|
|
/**
|
|
* Erzeugt ein leeres XMLDokument
|
|
*/
|
|
public XML() {
|
|
this.doc = new Document();
|
|
this.current = null;
|
|
}
|
|
|
|
/**
|
|
* Erzeugt ein XML-Dokument aus einer Datei
|
|
* @param filename Dateiname der XML-Datei
|
|
*/
|
|
public XML(String filename) {
|
|
loadXML(filename);
|
|
}
|
|
|
|
/**
|
|
* interner Konstruktor, um ein XML Objekt zu erzeugen, das auf einen bestimmten Knoten verweist
|
|
* @param doc die XML-Dokumentstruktur
|
|
* @param current Zeiger auf das aktuelle Element
|
|
*/
|
|
private XML(Document doc, Element current) {
|
|
this.doc = doc;
|
|
this.current = current;
|
|
}
|
|
|
|
// Anfang Methoden
|
|
/** Öffnet das durch den Dateinamen gegebene Dokument
|
|
* @param filename Dateiname des XML-Files
|
|
*/
|
|
public void loadXML(String filename) {
|
|
doc = null;
|
|
File f = new File(filename);
|
|
|
|
try {
|
|
// Das Dokument erstellen
|
|
SAXBuilder builder = new SAXBuilder();
|
|
doc = builder.build(f);
|
|
|
|
} catch (JDOMException e) {
|
|
e.printStackTrace();
|
|
|
|
} catch (IOException e) {
|
|
e.printStackTrace();
|
|
}
|
|
// Zeiger im Baum auf Root-Element
|
|
current = doc.getRootElement();
|
|
}
|
|
|
|
/** Speichert den XML-Baum im angegebenen Dateinamen
|
|
* @param filename Dateiname des XML-Files
|
|
*/
|
|
public void saveXML(String filename) {
|
|
try {
|
|
// new XMLOutputter().output(doc, System.out);
|
|
XMLOutputter xmlOutput = new XMLOutputter();
|
|
|
|
// display nice nice
|
|
xmlOutput.setFormat(Format.getPrettyFormat());
|
|
File f = new File(filename);
|
|
FileOutputStream outputFile = new FileOutputStream(f);
|
|
System.out.println("Speicher in : "+f.getAbsolutePath() );
|
|
xmlOutput.output(doc, outputFile);
|
|
outputFile.close();
|
|
System.out.println("File Saved!");
|
|
} catch (IOException io) {
|
|
System.out.println(io.getMessage());
|
|
}
|
|
|
|
}
|
|
|
|
//----------------------------------------------- Zeigerbewegungen --------------------------------------------------
|
|
/**
|
|
* liefert ein XML-Objekt, das auf den Vaterknoten des aktuellen Elements zeigt.
|
|
* @return Vater des aktuellen Objekts.
|
|
*/
|
|
public XML getParent() {
|
|
if(current != null) {
|
|
Element parent = current.getParentElement();
|
|
if (parent == null) {
|
|
return null;
|
|
} else {
|
|
return new XML(doc, parent);
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Überprüft, ob das Element irgendwelche Kinder hat oder nicht, und gibt das Ergebnis als boolean zurück.
|
|
* @return true, wenn Kinder vorhanden sind, sonst false
|
|
*/
|
|
public boolean hasChildren() {
|
|
if (current == null) {
|
|
return doc.hasRootElement();
|
|
} else {
|
|
return current.getChildren().size()>0;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Ermittelt die Namen aller Kinder des Elements und gibt die Namen als ein Array von Strings zurück.
|
|
* Dies ist dasselbe wie das Durchlaufen und Aufrufen von getName() auf jedem untergeordneten Element einzeln.
|
|
* @return Liste aller Namen der Kinder
|
|
*/
|
|
public String[] listChildren() {
|
|
if (current == null) {
|
|
if(doc.hasRootElement()) {
|
|
String[] names = new String[0];
|
|
names[0] = doc.getRootElement().getName();
|
|
return names;
|
|
} else {
|
|
return null;
|
|
}
|
|
} else {
|
|
List<Element> ch_element = current.getChildren();
|
|
String[] names = new String[ch_element.size()];
|
|
for(int i=0; i < ch_element.size() ; i++) {
|
|
names[i] = ch_element.get(i).getName();
|
|
}
|
|
return names;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Liefert alle Kinder des Elements als Array von XML-Objekten.
|
|
* @return Array der Kinder als XML-Objekte
|
|
*/
|
|
public XML[] getChildren() {
|
|
if (current == null) {
|
|
if(doc.hasRootElement()) {
|
|
XML[] ch_xml = new XML[1];
|
|
ch_xml[0] = new XML(doc, doc.getRootElement());
|
|
return ch_xml;
|
|
} else {
|
|
return null;
|
|
}
|
|
} else {
|
|
List<Element> ch_element = current.getChildren();
|
|
XML[] ch_xml = new XML[ch_element.size()];
|
|
for(int i=0; i < ch_element.size() ; i++) {
|
|
ch_xml[i] = new XML(doc, ch_element.get(i));
|
|
}
|
|
return ch_xml;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Liefert bestimmte Kinder des Elements als Array von XML-Objekten.
|
|
* Die Methode gibt dabei alle Kinder zurück, die dem angegebenen Namen entsprechen.
|
|
* @param name Name der gesuchten Kind-Objekte
|
|
* @return Array der Kinder als XML-Objekte
|
|
*/
|
|
public XML[] getChildren(String name) {
|
|
if (current == null) {
|
|
if(doc.hasRootElement()) {
|
|
XML[] ch_xml = new XML[1];
|
|
ch_xml[0] = new XML(doc, doc.getRootElement());
|
|
if(doc.getRootElement().getName().equals(name)){
|
|
return ch_xml;
|
|
} else {
|
|
return null;
|
|
}
|
|
} else {
|
|
return null;
|
|
}
|
|
} else {
|
|
List<Element> ch_element = current.getChildren(name);
|
|
XML[] ch_xml = new XML[ch_element.size()];
|
|
for(int i=0; i < ch_element.size() ; i++) {
|
|
ch_xml[i] = new XML(doc, ch_element.get(i));
|
|
}
|
|
return ch_xml;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Liefert das erste Kind des Elements mit einem bestimmten Namen.
|
|
* Die Methode gibt das erste Kind zurück, das dem angegebenen Namen entsprechen.
|
|
* @param name Name des gesuchten Kind-Objektes
|
|
* @return Kind als XML-Objekt
|
|
*/
|
|
|
|
public XML getChild(String name) {
|
|
if (current == null) {
|
|
Element e = doc.getRootElement();
|
|
if (e.getName().equals(name)) {
|
|
return new XML(doc, e);
|
|
} else {
|
|
return null;
|
|
}
|
|
} else {
|
|
String[] names = name.split("/");
|
|
Element e = current;
|
|
int i = 0;
|
|
while(i < names.length) {
|
|
e = e.getChild(names[i]);
|
|
if (e==null) return null;
|
|
i++;
|
|
}
|
|
return new XML(doc, e);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Liefert das i. Kind des Elements.
|
|
* Die Methode gibt das i. Kind des aktuellen Elements zurück.
|
|
* @param i Nummer des Kindes
|
|
* @return Kind als XML-Objekt
|
|
*/
|
|
public XML getChild(int i) {
|
|
if (current == null) {
|
|
return new XML(doc, doc.getRootElement());
|
|
} else {
|
|
List<Element> ch_element = current.getChildren();
|
|
if (i>=ch_element.size()) return null;
|
|
return new XML(doc, ch_element.get(i));
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------- Methoden für das aktuelle Element -------------------------------------------------
|
|
/**
|
|
* Frage den Namen des aktuellen Elements ab
|
|
* @return Namen des Elements
|
|
*/
|
|
public String getName() {
|
|
if (current==null) return "";
|
|
return current.getName();
|
|
}
|
|
|
|
/**
|
|
* Setze den Namen des aktuellen Elements.
|
|
* @param name Neuer Name des Elements
|
|
*/
|
|
public void setName(String name) {
|
|
if (current==null) return;
|
|
current.setName(name);
|
|
}
|
|
|
|
/**
|
|
* liefert die Anzahl der Attribute eines Elements.
|
|
* @return Anzahl des Attribute
|
|
*/
|
|
public int getAttributeCount() {
|
|
if (current == null) return 0;
|
|
return current.getAttributes().size();
|
|
}
|
|
|
|
/**
|
|
* liefert zurück, ob das aktuelle Element Attribute hat .
|
|
* @return true, wenn es Attribute gibt
|
|
*/
|
|
public boolean hasAttribute() {
|
|
if (current == null) return false;
|
|
return current.getAttributes().size()>0;
|
|
}
|
|
|
|
/**
|
|
* Ruft alle Attribute des angegebenen Elements ab und gibt sie als Array von Strings zurück.
|
|
* @return Liste der Attributnamen
|
|
*/
|
|
public String[] listAttributes() {
|
|
if (current == null) return null;
|
|
List<Attribute> attr = current.getAttributes();
|
|
String[] names = new String[attr.size()];
|
|
for(int i=0; i < attr.size() ; i++) {
|
|
names[i] = attr.get(i).getName();
|
|
}
|
|
return names;
|
|
}
|
|
|
|
/**
|
|
* Fragt einen Attributwert des aktuellen Elements ab
|
|
* @param attribute Name des Attributs
|
|
* @return Wert des Attributs
|
|
*/
|
|
public String getString(String attribute) {
|
|
if (current==null) return "";
|
|
return current.getAttributeValue(attribute);
|
|
}
|
|
|
|
/**
|
|
* Fragt einen Attributwert des aktuellen Elements ab
|
|
* Sollte es das Attribut nicht geben, wird ein default-Wert zurückgegeben
|
|
* @param attribute Name des Attributs
|
|
* @param defaultValue Standardwert, falls es das Attribut nicht gibt
|
|
* @return Wert des Attributs
|
|
*/
|
|
public String getString(String attribute, String defaultValue) {
|
|
if (current==null) return defaultValue;
|
|
return current.getAttributeValue(attribute,defaultValue);
|
|
}
|
|
|
|
/**
|
|
* Setzt einen Attributwert des aktuellen Elements
|
|
* @param attribute Name des Attributs
|
|
* @param text neuer Wert des Attributs
|
|
*/
|
|
public void setString(String attribute, String text) {
|
|
if (current==null) return;
|
|
current.setAttribute(attribute, text);
|
|
}
|
|
|
|
/**
|
|
* Fragt einen Attributwert des aktuellen Elements ab
|
|
* @param attribute Name des Attributs
|
|
* @return Wert des Attributs als Integer-Zahl
|
|
*/
|
|
public int getInt(String attribute) {
|
|
if (current==null) return 0;
|
|
try{
|
|
int i = Integer.parseInt(current.getAttributeValue(attribute));
|
|
return i;
|
|
} catch(Exception e) { return 0; }
|
|
|
|
}
|
|
|
|
/**
|
|
* Fragt einen Attributwert des aktuellen Elements ab
|
|
* Sollte es das Attribut nicht geben, wird ein default-Wert zurückgegeben
|
|
* @param attribute Name des Attributs
|
|
* @param defaultValue Standardwert, falls es das Attribut nicht gibt
|
|
* @return Wert des Attributs als Integer-Zahl
|
|
*/
|
|
public int getInt(String attribute, int defaultValue) {
|
|
if (current==null) return defaultValue;
|
|
try{
|
|
int i = Integer.parseInt(current.getAttributeValue(attribute));
|
|
return i;
|
|
} catch(Exception e) { return defaultValue; }
|
|
|
|
}
|
|
|
|
/**
|
|
* Setzt einen Attributwert des aktuellen Elements
|
|
* @param attribute Name des Attributs
|
|
* @param value neuer Wert des Attributs
|
|
*/
|
|
public void setInt(String attribute, int value) {
|
|
if (current==null) return;
|
|
current.setAttribute(attribute, ""+value);
|
|
}
|
|
|
|
/**
|
|
* Fragt einen Attributwert des aktuellen Elements ab
|
|
* @param attribute Name des Attributs
|
|
* @return Wert des Attributs als Float-Zahl
|
|
*/
|
|
public float getFloat(String attribute) {
|
|
if (current==null) return 0;
|
|
try{
|
|
float i = Float.parseFloat(current.getAttributeValue(attribute));
|
|
return i;
|
|
} catch(Exception e) { return 0; }
|
|
|
|
}
|
|
|
|
/**
|
|
* Fragt einen Attributwert des aktuellen Elements ab
|
|
* Sollte es das Attribut nicht geben, wird ein default-Wert zurückgegeben
|
|
* @param attribute Name des Attributs
|
|
* @param defaultValue Standardwert, falls es das Attribut nicht gibt
|
|
* @return Wert des Attributs als Float-Zahl
|
|
*/
|
|
public float getFloat(String attribute, float defaultValue) {
|
|
if (current==null) return defaultValue;
|
|
try{
|
|
float i = Float.parseFloat(current.getAttributeValue(attribute));
|
|
return i;
|
|
} catch(Exception e) { return defaultValue; }
|
|
|
|
}
|
|
|
|
/**
|
|
* Setzt einen Attributwert des aktuellen Elements
|
|
* @param attribute Name des Attributs
|
|
* @param value neuer Wert des Attributs
|
|
*/
|
|
public void setFloat(String attribute, float value) {
|
|
if (current==null) return;
|
|
current.setAttribute(attribute, ""+value);
|
|
}
|
|
|
|
/**
|
|
* Fragt einen Attributwert des aktuellen Elements ab
|
|
* @param attribute Name des Attributs
|
|
* @return Wert des Attributs als Double-Zahl
|
|
*/
|
|
public double getDouble(String attribute) {
|
|
if (current==null) return 0;
|
|
try{
|
|
double i = Double.parseDouble(current.getAttributeValue(attribute));
|
|
return i;
|
|
} catch(Exception e) { return 0; }
|
|
|
|
}
|
|
|
|
/**
|
|
* Fragt einen Attributwert des aktuellen Elements ab
|
|
* Sollte es das Attribut nicht geben, wird ein default-Wert zurückgegeben
|
|
* @param attribute Name des Attributs
|
|
* @param defaultValue Standardwert, falls es das Attribut nicht gibt
|
|
* @return Wert des Attributs als double-Zahl
|
|
*/
|
|
public double getDouble(String attribute, double defaultValue) {
|
|
if (current==null) return defaultValue;
|
|
try{
|
|
double i = Double.parseDouble(current.getAttributeValue(attribute));
|
|
return i;
|
|
} catch(Exception e) { return defaultValue; }
|
|
|
|
}
|
|
|
|
/**
|
|
* Setzt einen Attributwert des aktuellen Elements
|
|
* @param attribute Name des Attributs
|
|
* @param value neuer Wert des Attributs
|
|
*/
|
|
public void setDouble(String attribute, double value) {
|
|
if (current==null) return;
|
|
current.setAttribute(attribute, ""+value);
|
|
}
|
|
|
|
/**
|
|
* Fragt den Inhalt/Text des aktuellen Elements ab
|
|
* @return Inhalt des Elements
|
|
*/
|
|
public String getContent() {
|
|
if ( current==null) return "";
|
|
|
|
return current.getText();
|
|
}
|
|
|
|
/**
|
|
* Fragt den Inhalt/Text des aktuellen Elements ab
|
|
* Hat das Element keinen Inhalt wird der defaultValue zurückgegeben.
|
|
* @param defaultValue Standardtext
|
|
* @return Inhalt des Elements
|
|
*/
|
|
public String getContent(String defaultValue) {
|
|
if ( current==null) return defaultValue;
|
|
String t = current.getText();
|
|
if(t.equals("")) t = defaultValue;
|
|
return t;
|
|
}
|
|
|
|
/**
|
|
* Setzt den Inhalt/Text des aktuellen Elements
|
|
* @param text Neuer Inhalt des Elements
|
|
*/
|
|
public void setContent(String text) {
|
|
if ( current==null) return;
|
|
current.setText(text);
|
|
}
|
|
|
|
|
|
/**
|
|
* Fragt den Inhalt des aktuellen Elements als Integerzahl ab
|
|
* Hat das Element keinen Inhalt wird der defaultValue zurückgegeben.
|
|
* @param defaultValue Standardwert
|
|
* @return Inhalt des Elements
|
|
*/ public int getIntContent(int defaultValue) {
|
|
if ( current==null) return defaultValue;
|
|
try{
|
|
int i = Integer.parseInt(current.getText());
|
|
return i;
|
|
} catch(Exception e) { return defaultValue; }
|
|
}
|
|
|
|
/**
|
|
* Fragt den Inhalt des aktuellen Elements als Integerzahl ab
|
|
* @return Inhalt des Elements
|
|
*/
|
|
public int getIntContent() {
|
|
if ( current==null) return 0;
|
|
try{
|
|
int i = Integer.parseInt(current.getText());
|
|
return i;
|
|
} catch(Exception e) { return 0; }
|
|
}
|
|
|
|
/**
|
|
* Setzt den Inhalt des aktuellen Elements
|
|
* @param value Neuer Inhalt des Elements
|
|
*/
|
|
public void setIntContent(int value) {
|
|
if ( current==null) return;
|
|
current.setText(""+value);
|
|
}
|
|
|
|
|
|
/**
|
|
* Fragt den Inhalt des aktuellen Elements als Floatzahl ab
|
|
* Hat das Element keinen Inhalt wird der defaultValue zurückgegeben.
|
|
* @param defaultValue Standardwert
|
|
* @return Inhalt des Elements
|
|
*/
|
|
public float getFloatContent(float defaultValue) {
|
|
if ( current==null) return defaultValue;
|
|
try{
|
|
float i = Float.parseFloat(current.getText());
|
|
return i;
|
|
} catch(Exception e) { return defaultValue; }
|
|
}
|
|
|
|
/**
|
|
* Fragt den Inhalt des aktuellen Elements als Floatzahl ab
|
|
* @return Inhalt des Elements
|
|
*/
|
|
public float getFloatContent() {
|
|
if ( current==null) return 0;
|
|
try{
|
|
float i = Float.parseFloat(current.getText());
|
|
return i;
|
|
} catch(Exception e) { return 0; }
|
|
}
|
|
|
|
/**
|
|
* Setzt den Inhalt des aktuellen Elements
|
|
* @param value Neuer Inhalt des Elements
|
|
*/
|
|
public void setFloatContent(float value) {
|
|
if ( current==null) return;
|
|
current.setText(""+value);
|
|
}
|
|
|
|
/**
|
|
* Fragt den Inhalt des aktuellen Elements als Doublezahl ab
|
|
* Hat das Element keinen Inhalt wird der defaultValue zurückgegeben.
|
|
* @param defaultValue Standardwert
|
|
* @return Inhalt des Elements
|
|
*/
|
|
public double getDoubleContent(double defaultValue) {
|
|
if ( current==null) return defaultValue;
|
|
try{
|
|
double i = Double.parseDouble(current.getText());
|
|
return i;
|
|
} catch(Exception e) { return defaultValue; }
|
|
}
|
|
|
|
/**
|
|
* Fragt den Inhalt des aktuellen Elements als Doublezahl ab
|
|
* @return Inhalt des Elements
|
|
*/
|
|
public double getDoubleContent() {
|
|
if ( current==null) return 0;
|
|
try{
|
|
double i = Double.parseDouble(current.getText());
|
|
return i;
|
|
} catch(Exception e) { return 0; }
|
|
}
|
|
|
|
/**
|
|
* Setzt den Inhalt des aktuellen Elements
|
|
* @param value Neuer Inhalt des Elements
|
|
*/
|
|
public void setDoubleContent(double value) {
|
|
if ( current==null) return;
|
|
current.setText(""+value);
|
|
}
|
|
|
|
|
|
// ----------------------------------------------- XML-Struktur aufbauen ------------------------------------------------
|
|
/** Erzeuge neues Element nach der aktuellen Position und setze dieses als aktuelles Element
|
|
* @param name Name des neuen Elements
|
|
* @return neues Element als XML-Objekt
|
|
*/
|
|
public XML addChild(String name) {
|
|
Element e = new Element(name);
|
|
if(current == null){ // man ist auf Root-Ebene
|
|
doc.setRootElement(e);
|
|
|
|
}
|
|
else {
|
|
current.addContent(e);
|
|
} // end of if-else
|
|
return new XML(doc, e);
|
|
}
|
|
|
|
/**
|
|
* liefert das aktuelle Element als jdom-Element-Objekt
|
|
* @return aktuelles Element
|
|
*/
|
|
private Element getCurrent() {
|
|
return current;
|
|
}
|
|
|
|
/**
|
|
* löscht ein Kind des aktuellen Knotens.
|
|
* Ist kid kein Kind des aktuellen Elements passiert gar nichts.
|
|
* @param kid XML-Objekt des Kindes
|
|
*/
|
|
public void removeChild(XML kid) {
|
|
if (current == null) return;
|
|
Element e = kid.getCurrent();
|
|
int index = current.indexOf(e);
|
|
if(index >= 0) { current.removeContent(e);}
|
|
}
|
|
|
|
}
|