com.sta.cts.XMLGenerator Maven / Gradle / Ivy
package com.sta.cts;
import java.io.IOException;
import java.io.OutputStream;
import java.io.BufferedWriter;
import java.io.FileOutputStream;
import java.io.OutputStreamWriter;
import java.util.Date;
/**
* Name: XMLGenerator
* Description:
* Diese Klasse dient zum Erzeugen einer XML-Datei. Bei Bedarf kann sie als
* Interface zu JDOM dienen bzw. durch JDOM ersetzt werden.
*
* Die wesentlichen Features sind:
* * basiert auf einem BufferedWriter
* * erzeugt Einr?ckungen
* * erkennt leere Tags
*
* Copyright: Copyright (c) 2001-2004, 2011, 2016-2019, 2021
* Company: >StA-Soft<
* @author StA
* @version 1.0
*/
public class XMLGenerator implements AutoCloseable
{
/**
* Der BufferedWriter f?r die aktuelle Ziel-XML-Datei.
*/
private BufferedWriter bw;
/**
* Anzahl der Spalten = Breite der Einr?ckung.
*/
private int sp;
/**
* Aktuelle Spalte in der XML-Datei.
*/
private int col;
/**
* True, falls ein Tag ge?ffnet wurde.
* Bsp.: <TagName
*/
protected boolean isOpen;
//===========================================================================
/**
* Standard-Constructor: Zum Instantiieren eines XML-Generators.
*/
public XMLGenerator()
{
}
//===========================================================================
/**
* String pStrg schreiben, ohne CRLF. Dabei wird die Spalte col mitgez?hlt.
* @param pStrg der zu schreibende String
* @exception IOException falls ein Schreibfehler auftritt
*/
protected void write(String pStrg) throws IOException
{
bw.write(pStrg);
col += pStrg.length();
}
/**
* String Strg schreiben, mit CRLF. Dabei wird die Spalte col auf 0 gesetzt.
* @param pStrg der zu schreibende String
* @exception IOException falls ein Schreibfehler auftritt
*/
protected void writeln(String pStrg) throws IOException
{
bw.write(pStrg);
bw.newLine();
col = 0;
}
/**
* Leerzeile schreiben bzw. Zeilenwechsel veranlassen. Dabei wird die Spalte col auf 0 gesetzt.
* @exception IOException falls ein Schreibfehler auftritt
*/
protected void writeln() throws IOException
{
bw.newLine();
col = 0;
}
/**
* Spaces (Einr?ckung) entsprechend sp schreiben.
* @exception IOException falls ein Schreibfehler auftritt
*/
protected void writeSp() throws IOException
{
if (sp != 0)
{
StringBuilder sb = new StringBuilder(); // (sp)
for (int i = 1; i <= sp; i++)
{
sb.append(' ');
}
write(sb.toString());
}
}
/**
* Schreiben von (offenen) Tags beenden (Tags vervollst?ndigen).
*
* - Falls ein Tag ge?ffnet ist (isOpen), wird es geschlossen.
* - Falls dann ln = true, wird mit der n?chsten Zeile fortgesetzt.
*
* @param ln true, falls zus?tzlich ein Zeilenende geschrieben werden soll.
* @exception IOException falls ein Schreibfehler auftritt
*/
protected void flush(boolean ln) throws IOException
{
if (isOpen)
{
write(">");
if (ln)
{
writeln();
}
isOpen = false;
}
}
/**
* ... ruft flush(true) auf.
* @exception IOException falls ein Schreibfehler auftritt
*/
private void flush() throws IOException
{
flush(true);
}
/**
* Sorgt daf?r, da? folgende Schreiboperationen in einer neuen Zeile beginnen.
* Falls col nicht 0 ist, wird ein CRLF geschrieben und col = 0 gesetzt.
* @exception IOException falls ein Schreibfehler auftritt
*/
protected void newline() throws IOException
{
if (col != 0)
{
writeln();
col = 0;
}
}
/**
* Konvertiert einen String, der ggf. Sonderzeichen enth?lt in einen String,
* in dem diese durch "&#..." ersetzt sind.
* @param pStrg der zu konvertierende String
* @param hard = true, falls auch ?'? und ?"? konvertiert werden sollen
* @return der konvertierte String
*/
protected String convert(String pStrg, boolean hard)
{
StringBuilder sb = new StringBuilder();
int len = pStrg.length();
for (int i = 0; i < len; i++)
{
char ch = pStrg.charAt(i);
if ((ch == '<') || (ch == '>') || (ch == '&') ||
((ch < 32) && (ch != 9) && (ch != 10) && (ch != 13)) ||
(hard && ((ch == '"') || (ch == '\''))) // || (ch >= 0x80)
)
{
sb.append("&#");
sb.append((int) ch);
sb.append(';');
}
else
{
sb.append(ch);
}
}
return sb.toString();
}
/**
* Encoding pr?fen, Standard ist "ISO-8859-1" (falls pEnc == null).
* @param pEnc vorgegebenes Encoding
* @return zu verwendendes Encoding
*/
private String checkEnc(String pEnc)
{
return pEnc != null ? pEnc : "ISO-8859-1";
}
//---------------------------------------------------------------------------
/**
* Buffered Writer zur "Erstellung" einer XML-Datei verwenden.
* Die Felder sp und col werden auf 0 gesetzt. Es wird ein XML-Header
* geschrieben. Das ?bergebene Encoding wird lediglich f?r den XML-Header
* verwendet, um die korrekte Codierung muss sich der Verwender k?mmern.
* @param pBW BufferedWriter
* @param pEnc Encoding, Standard: "ISO-8859-1" (falls pEnc = null)
* @throws IOException im Fehlerfall
*/
public void createXML(BufferedWriter pBW, String pEnc) throws IOException
{
bw = pBW;
sp = 0;
col = 0;
isOpen = false;
// writeln("");
// writeln("");
writeln("");
}
/**
* Buffered Writer zur "Erstellung" einer XML-Datei verwenden. Es wird vom
* Standard-Encoding ausgegangen.
* @param pBW BufferedWriter
* @throws IOException im Fehlerfall
*/
public void createXML(BufferedWriter pBW) throws IOException
{
createXML(pBW, null);
}
/**
* Initialisierung des XML-Datei mit Encoding, das Encoding wird dabei zur
* Codierung verwendet.
* @param pOS OutputStream
* @param pEnc Encoding
* @throws IOException im Fehlerfall
*/
public void createXML(OutputStream pOS, String pEnc) throws IOException
{
pEnc = pEnc != null ? pEnc : "UTF-8"; // Charset.defaultCharset().name();
OutputStreamWriter osw = pEnc != null ? new OutputStreamWriter(pOS, pEnc) : new OutputStreamWriter(pOS);
createXML(new BufferedWriter(osw), pEnc);
}
/**
* Initialisierung der XML-Datei, es wird vom Standard-Encoding ausgegangen.
* @param pOS OutputStream
* @throws IOException im Fehlerfall
*/
public void createXML(OutputStream pOS) throws IOException
{
createXML(pOS, null);
}
/**
* Erzeugen einer neuen XML-Datei, mit Encoding, das Encoding wird dabei zur
* Codierung verwendet.
* @param pFileName Name der XML-Datei.
* @param pEnc Encoding, Standard: "ISO-8859-1" (falls pEnc = null)
* @exception IOException falls die Datei nicht erstellt werden konnte oder
* ein Schreibfehler auftritt
*/
public void createXML(String pFileName, String pEnc) throws IOException
{
// createXML(new BufferedWriter(new FileWriter(new File(pFileName))));
// FileOutputStream fos = new FileOutputStream(pFileName);
// OutputStreamWriter osw = pEnc != null ? new OutputStreamWriter(fos, pEnc) : new OutputStreamWriter(fos);
// createXML(new BufferedWriter(osw), pEnc);
createXML(new FileOutputStream(pFileName), pEnc);
}
/**
* Erzeugen einer neuen XML-Datei, es wird vom Standard-Encoding ausgegangen.
* @param pFileName Name der XML-Datei.
* @exception IOException falls die Datei nicht erstellt werden konnte oder
* ein Schreibfehler auftritt
*/
public void createXML(String pFileName) throws IOException
{
createXML(pFileName, null);
}
//---------------------------------------------------------------------------
/**
* Direkte Ausgabe: Text ohne Zeilenumbruch.
* @param pStrg auszugebender Text
* @throws IOException im Fehlerfall
*/
public void directWrite(String pStrg) throws IOException
{
flush(false);
write(pStrg);
}
/**
* Direkte Ausgabe: Text mit Zeilenumbruch.
* @param pStrg auszugebender Text
* @throws IOException im Fehlerfall
*/
public void directWriteLn(String pStrg) throws IOException
{
flush(false);
writeln(pStrg);
}
/**
* Direkte Ausgabe: Zeilenumbruch.
* @throws IOException im Fehlerfall
*/
public void directWriteLn() throws IOException
{
flush(false);
writeln();
}
/**
* Neues ?ffnendes Tag erzeugen. Dieses mu? nicht komplett geschrieben werden,
* z. B. um Attribute hinzuzuf?gen oder leere Tags zu erzeugen.
* @param pName ist der Name des Tags.
* @exception IOException falls ein Schreibfehler auftritt
*/
public void openTag(String pName) throws IOException
{
flush();
writeSp();
// writeln("<" + pName + ">");
write("<" + pName);
isOpen = true;
sp++;
}
/**
* Attribute zum unmittelbar vorher erzeugten Tag (openTag) hinzuf?gen.
* Nachdem Text geschrieben (putContent) oder das Tag geschlossen (closeTag)
* wurde, k?nnen keine Attribute mehr zum letzen Tag hinzugef?gt werden.
* @param pName ist der Name des Attributs.
* @param aValue ist der Wert des Attributs.
* @exception IOException falls ein Schreibfehler auftritt
*/
public void putAttr(String pName, String aValue) throws IOException
{
// if (!isOpen) => Exception
if (aValue != null)
{
write(" " + pName + "=\"" + convert(aValue, true) + "\"");
}
// write(" " + pName + "=\"" + aValue + "\"");
}
/**
* Inhalt (Text zwischen Tags) schreiben. Wurde ein ?ffnendes Tag angelegt
* und noch nicht fertig geschrieben, wird dies vor dem Schreiben des Inhalts
* erledigt.
* @param c Inhalt (Text), der geschrieben werden soll
* @exception IOException falls ein Schreibfehler auftritt
*/
public void putContent(String c) throws IOException
{
if (isOpen)
{
flush(false);
write(convert(c, false));
// write(c);
}
else
{
newline();
writeSp();
write(convert(c, false));
// write(c);
}
}
/**
* Tag schlie?en. Der Name mu? angegeben werden. Es mu? ferner dem Namen des
* korrespondierenden ?ffnenden Tags entsprechen. Wurde f?r das zu
* schlie?ende Tag noch kein Inhalt geschrieben, wird ein leeres Tag erzeugt.
* @param pName ist der Name des Tags
* @exception IOException falls ein Schreibfehler auftritt
*/
public void closeTag(String pName) throws IOException
{
sp--;
if (isOpen)
{
writeln("/>"); // leeres Tag
isOpen = false;
}
else
{
if (col == 0)
{
writeSp();
}
writeln("");
}
}
/**
* Tags werden vervollst?ndigt, XML-Datei wird ge-flush-t und geschlossen.
* Erst danach kann mit createXML eine neue XML-Datei erzeugt werden.
* @exception IOException falls ein Schreibfehler auftritt oder die Datei
* nicht geschlossen werden konnte.
*/
public void closeXML() throws IOException
{
flush();
bw.flush(); // wichtig!
bw.close();
}
@Override
public void close() throws IOException
{
closeXML();
}
//---------------------------------------------------------------------------
/**
* XML-Blatt schreiben. Das hei?t: openTag, putContent, closeTag.
* Hierbei handelt es sich um eine Basis-Routine f?r die folgenden
* Spezialf?lle. Das XML-Blatt wird nur dann erzeugt, wenn der zu schreibende
* Inhalt verschieden von null ist.
* @param pName der Name des XML-Blatt-Tags
* @param pContent der Inhalt, ggf. auch null oder ""
* @throws IOException falls ein Schreibfehler auftritt
*/
public void putLeaf(String pName, String pContent) throws IOException
{
// ?nderung am 11.03.2004 (f?r XML-Serialisierung):
// Es wird nicht mehr auf Leer-String gepr?ft. Das bedeutet, dass f?r einen leeren String ein leeres Tag
// (bzw. ein ?ffnendes und ein schlie?endes Tag ohne Text dazwischen) geschrieben wird.
// if ((pContent != null) && (pContent.length() != 0))
if (pContent != null)
{
openTag(pName);
putContent(pContent);
closeTag(pName);
}
}
/**
* String-XML-Blatt schreiben.
* @param pName der Name des XML-Blatt-Tags
* @param pContent der Inhalt als String
* @throws IOException falls ein Schreibfehler auftritt
*/
public void putLeafString(String pName, String pContent) throws IOException
{
putLeaf(pName, pContent);
}
/**
* Integer-XML-Blatt schreiben.
* @param pName der Name des XML-Blatt-Tags
* @param pContent der Inhalt als Integer
* @throws IOException falls ein Schreibfehler auftritt
*/
public void putLeafInt(String pName, Integer pContent) throws IOException
{
putLeaf(pName, UniTypeConv.convInt2String(pContent));
}
/**
* Long-XML-Blatt schreiben.
* @param pName der Name des XML-Blatt-Tags
* @param pContent der Inhalt als Integer
* @throws IOException falls ein Schreibfehler auftritt
*/
public void putLeafLong(String pName, Long pContent) throws IOException
{
putLeaf(pName, UniTypeConv.convLong2String(pContent));
}
/**
* Float-XML-Blatt schreiben.
* @param pName der Name des XML-Blatt-Tags
* @param pContent der Inhalt als Float
* @throws IOException falls ein Schreibfehler auftritt
*/
public void putLeafFloat(String pName, Float pContent) throws IOException
{
putLeaf(pName, UniTypeConv.convFloat2String(pContent));
}
/**
* Double-XML-Blatt schreiben.
* @param pName der Name des XML-Blatt-Tags
* @param pContent der Inhalt als Double
* @throws IOException falls ein Schreibfehler auftritt
*/
public void putLeafDouble(String pName, Double pContent) throws IOException
{
putLeaf(pName, UniTypeConv.convDouble2String(pContent));
}
/**
* Date-XML-Blatt schreiben.
* @param pName der Name des XML-Blatt-Tags
* @param pContent der Inhalt als Date (nur Datum)
* @param pMask optionale Maske
* @throws IOException falls ein Schreibfehler auftritt
*/
public void putLeafDate(String pName, Date pContent, String pMask) throws IOException
{
putLeaf(pName, UniTypeConv.convDate2String(pContent, pMask));
}
/**
* Date-XML-Blatt schreiben.
* @param pName der Name des XML-Blatt-Tags
* @param pContent der Inhalt als Date (nur Datum)
* @throws IOException falls ein Schreibfehler auftritt
*/
public void putLeafDate(String pName, Date pContent) throws IOException
{
putLeafDate(pName, pContent, null);
}
/**
* Time-XML-Blatt schreiben.
* @param pName der Name des XML-Blatt-Tags
* @param pContent der Inhalt als Date (nur Zeitangabe)
* @param pMask optionale Maske
* @throws IOException falls ein Schreibfehler auftritt
*/
public void putLeafTime(String pName, Date pContent, String pMask) throws IOException
{
putLeaf(pName, UniTypeConv.convTime2String(pContent, pMask));
}
/**
* Time-XML-Blatt schreiben.
* @param pName der Name des XML-Blatt-Tags
* @param pContent der Inhalt als Date (nur Zeitangabe)
* @throws IOException falls ein Schreibfehler auftritt
*/
public void putLeafTime(String pName, Date pContent) throws IOException
{
putLeafTime(pName, pContent, null);
}
/**
* DateTime-XML-Blatt schreiben.
* @param pName der Name des XML-Blatt-Tags
* @param pContent der Inhalt als Date (Datum und Zeitangabe)
* @param pMask optionale Maske
* @throws IOException falls ein Schreibfehler auftritt
*/
public void putLeafDateTime(String pName, Date pContent, String pMask) throws IOException
{
putLeaf(pName, UniTypeConv.convDateTime2String(pContent, pMask));
}
/**
* DateTime-XML-Blatt schreiben.
* @param pName der Name des XML-Blatt-Tags
* @param pContent der Inhalt als Date (Datum und Zeitangabe)
* @throws IOException falls ein Schreibfehler auftritt
*/
public void putLeafDateTime(String pName, Date pContent) throws IOException
{
putLeafDateTime(pName, pContent, null);
}
/**
* Boolean-XML-Blatt schreiben.
* @param pName der Name des XML-Blatt-Tags
* @param pContent der Inhalt als Boolean
* @throws IOException falls ein Schreibfehler auftritt
*/
public void putLeafBool(String pName, Boolean pContent) throws IOException
{
putLeaf(pName, UniTypeConv.convBool2String(pContent));
}
/**
* XML-Blatt schreiben. Das hei?t: openTag, putContent, closeTag.
* @param pName der Name des XML-Blatt-Tags
* @param pContent der Inhalt
* @throws IOException falls ein Schreibfehler auftritt
*/
public void putLeafObj(String pName, Object pContent) throws IOException
{
if (pContent != null)
{
if (pContent instanceof String)
{
putLeafString(pName, (String) pContent);
}
else if (pContent instanceof Boolean)
{
putLeaf(pName, ((Boolean) pContent).booleanValue() ? "1" : "0");
}
else if (pContent instanceof Date)
{
putLeafDateTime(pName, (Date) pContent);
}
else
{
putLeaf(pName, pContent.toString());
}
}
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy