com.sta.cts.XMLGenerator Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of converter3 Show documentation
Show all versions of converter3 Show documentation
Tool to convert CSV and XLS to XML, to transform XML and to convert XML to CSV, HTML, other text files, PDF etc., useful as command line tool and integrated in other projects.
package com.sta.cts;
// import java.io.File;
// import java.io.FileWriter;
import java.io.IOException;
import java.io.OutputStream;
import java.io.BufferedWriter;
import java.io.FileOutputStream;
import java.io.OutputStreamWriter;
// import java.nio.charset.Charset;
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
* 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();
}
/**
* Tags werden vervollst?ndigt, XML-Datei wird ge-flush-t und geschlossen.
* @see #closeXML
* @throws IOException im Fehlerfall
*/
@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());
}
}
}
}