StEdit.java
package sted;
/**
* Die Klasse <code><b>StEdit.java</b></code> enthaelt Hilfsmethoden fuer die
* Realisierung von typischen Texteditorfunktionen. Grundkonzept dieser Klasse
* ist die Speicherung eines kommpletten Textes mit mehreren Zeilen in einer
* Zeichenkette. Die Zeilenwechsel sind durch das Zeichen <code>'/n'</code>
* kodiert, so dass der Text mit <code>System.out.println(text)</code>
* ausgegeben werden kann.
*
* @author rla
* @version 1.19 Aufgabenstellung
*/
public class StEdit {
private StEdit() {
}
/* Es gibt keinen Konstruktor */
/**
* Konstanten fuer Unicodeumlaute bei Verwendung von unterschiedlichen
* Zeichenkodierungen
*/
public static final char _ae_ = '\u00E4';
public static final char _oe_ = '\u00F6';
public static final char _ue_ = '\u00FC';
public static final char _AE_ = '\u00C4';
public static final char _OE_ = '\u00D6';
public static final char _UE_ = '\u00DC';
public static final char _sz_ = '\u00DF';
public static final char _SZ_ = '\u1E9E';
/**
* Trennzeichen fuer Spalten. Muss sich von den anderen Separatorzeichen und
* dem '.' unterscheiden! Darf kein Steuerzeichen fuer regulaere Ausdruecke
* von split enthalten!
*/
public static char columnSeparator = ';';
/**
* Trennzeichen fuer Zeilen. Muss sich von den anderen Separatorzeichen und
* dem '.' unterscheiden! Darf kein Steuerzeichen fuer regulaere Ausdruecke
* von split enthalten!
*/
public static char rowSeparator = '\n';
/**
* Ersetzt in der Zeichenkette <b>s</b>, ab der Position <b>start</b> die
* erste Zeichenkette <b>su</b> durch <b>se</b>.<br>
* <br><b>Anwendungsbeispiel:</b><PRE>
* ...
* String s = "abcabcabc";
* int start = 1
* String su = "ab";
* String se = "AB";
* String sret = ersetzen( s, start, su, se);
* ...</PRE> liefert das Ergebnis <CODE>sret = "abcABcabc"</CODE>.<br><br>
* Wenn die gesuchte Zeichenkette nicht gefunden wird, den Wert null hat
* oder andere Parameter unsinnig sind wird s direkt zurueckgegeben.
*
* @param s Ausgangszeichenkette
* @param start Position ab der nach su in s gesucht wird
* @param su Zeichenkette nach der gesucht wird
* @param se Zeichenkette die su ersetzen soll
* @return Zeichenkette in der su durch se ersetzt ist
*/
public static String ersetzen(String s, int start, String su, String se) {
if (s == null || su == null || se == null || start < 0 || start > s.length() || su.isEmpty()) {
return s;
}
int foundpos = s.indexOf(su, start);
if (foundpos == -1) {
return s;
}
String anfang = s.substring(0, foundpos);
String ende = s.substring(foundpos + su.length());
return anfang + se + ende;
}
/**
* Ersetzt in der Zeichenkette <b>s</b>, ab der Position <b>start</b> alle
* Vorkommen der Zeichenkette <b>su</b> durch <b>se</b>.<br>
* <br><b>Anwendungsbeispiel:</b><PRE>
* ...
* String s = "abcabcabc";
* int start = 2
* String su = "ab";
* String se = "AB";
* String sret = ersetzen( s, start, su, se);
* ...</PRE> liefert das Ergebnis <CODE>sret = "abcABcABc"</CODE>.<br><br>
* Wenn die gesuchte Zeichenkette nicht gefunden wird, den Wert null hat
* oder andere Parameter unsinnig sind wird s direkt zurueckgegeben.
*
* @param s Ausgangszeichenkette
* @param start Position ab der nach su in s gesucht wird
* @param su Zeichenkette nach der gesucht wird
* @param se Zeichenkette die su ersetzen soll
* @return Zeichenkette in der su durch se ersetzt ist
*/
public static String allesErsetzen(String s, int start, String su, String se) {
if (s == null || su == null || se == null || start < 0 || start >= s.length() || su.isEmpty()) {
return s;
}
int foundpos = s.indexOf(su, start);
if (foundpos == -1) {
return s;
}
String ersetz = s.substring(foundpos, s.length());
String anfang = s.substring(0, foundpos);
while (ersetz.contains(su)) {
foundpos = ersetz.indexOf(su);
anfang = anfang + ersetz.substring(0, foundpos) + se;
ersetz = ersetz.substring(foundpos + su.length());
}
return anfang + ersetz;
}
/**
* Berechnet die Zeilennummer einer Zeichenposition <b>p</b> in der
* Zeichenkette <b>s</b>.<br> <br><b>Anwendungsbeispiel:</b><PRE>
* ...
* // Zeichenposition: 1 | 2 3
* // 0123456789 01234567890 1234567890123
* String s = "1. Zeile \n 2. Zeile \n letzte Zeile";
* int p = 17
* int zret = zeilenNummer( s, p);
* ...</PRE> liefert das Ergebnis <CODE>zret = 2</CODE>.<br><br> Wenn s
* nicht initialisiert oder p negativ ist, dann soll 0 zurueckgegeben
* werden.<br> Wenn p ausserhalb von s liegt, dann wird die Nummer der
* letzten Zeile von s zurueckgegeben.
*
* @param s Zeichenkette (Zeilenwechsel mit \n kodiert)
* @param p Position eines Zeichens in s, dessen Zeilennummer gesucht wird
* @return Zeilennummer des Zeichens auf Position p
*/
public static int zeilenNummer(String s, int p) {
if(s==null || p<= -1)
{
return 0;
}
if (p>s.length())
{
p= s.length();
}
int counter =1;
for (int i=0; i< p; i++)
{
if(s.charAt(i) =='\n')
{
counter++;
}
}
return counter;
}
/**
* Berechnet die Anfaenge der Zeilen in der Zeichenkette <b>s</b>.<br> <br><b>Anwendungsbeispiel:</b><PRE>
* ...
* // Zeichenposition: 1 2 3
* // 0123456789 01234567890 1234567890123
* String s = "1. Zeile \n 2. Zeile \n letzte Zeile";
* int [] zret = zeilen( s);
* ...</PRE> liefert das Ergebnis <CODE>zret = {0, 10, 21}</CODE>.<br><br>
* Wenn s nicht initialisiert ist, dann wird null bei einer leeren
* Zeichenkette {0} zurueckgegeben.
*
* @param s Zeichenkette (Zeilenwechsel mit \n kodiert)
* @return Positionen der Zeilenanfaenge
*/
public static int[] zeilen(String s) {
if(s == null){
return null;
}
if (s.isEmpty() ) {
return new int[1];
}
int[] zret = new int [zeilenNummer(s, s.length())];
int counter = 1;
for(int i=0; i < s.length(); i++){
if(s.charAt(i)=='\n'){
zret [counter] = i+1 ;
counter++;
}
}
for (int i = 0; i < zret.length; i++) {
System.out.println(zret[i] + " , ");
}
return zret;
}
/**
* Zaehlt die Anzahl der Zeichen in einer Zeichenkette <b>s</b>.<br> Mehrere
* aufeinanderfolgende nicht sichtbare Zeichen (z.B. Zeilenwechsel,
* Leerzeichen und Tabulator) zaehlen dabei nur als ein einziges Zeichen.
* Die Pruefung ob ein Zeichen nicht sichtbar ist, soll mit der Methode
* <code>Character.isJavaIdentifierPart(char ch) </code> erfolgen, die fuer
* nicht sichtbare Zeichen den Wert true liefert. <br><b>Anwendungsbeispiel:</b><PRE>
* ...
* String s = "Ein Text mit\n 8 Worten in 3\n Zeilen.";
* int zret = zeichen( s);
* ...</PRE> liefert das Ergebnis <CODE>zret = 34</CODE>.<br><br> Wenn s
* nicht initialisiert oder leer ist, wird 0 zurueckgegeben.
*
* @param s Zeichenkette
* @return Anzahl der Zeichen
*/
public static int zeichen(String s) {
return 123;
}
/**
* Zaehlt die Anzahl an Worten in einer Zeichenkette <b>s</b>.<br> Als Wort
* zaehlen dabei zusammenhaengende sichtbare Zeichen ch (Buchstaben,
* Ziffern, Sonderzeichen), bei denen die Methode <code>
* Character.isJavaIdentifierPart(char ch) </code> den Wert true liefert. <br><b>Anwendungsbeispiel:</b><PRE>
* ...
* String s = "Ein Text mit\n 8 Worten in 3\n Zeilen.";
* int zret = woerter( s);
* ...</PRE> liefert das Ergebnis <CODE>zret = 8</CODE>.<br><br> Wenn s
* nicht initialisiert oder leer ist, wird 0 zurueckgegeben.
*
* @param s Zeichenkette (Zeilenwechsel mit \n kodiert)
* @return Anzahl der Woerter
*/
public static int woerter(String s) {
return 123;
}
/**
* Ersetzt die deutschen Sonderzeichen durch die folgenden
* Zeichenkombinationen "ae, Ae, oe, Oe, ue, Ue und ss".
*
* <br><b>Anwendungsbeispiel:</b><PRE>
* ...
* String s = "Küster können Änderungen erleben.";
* String sret = ersetzeSonderzeichen( s);
* ...</PRE> liefert das Ergebnis
* <CODE>sret = "Kuester koennen Aenderungen erleben."</CODE>.<br><br> Wenn
* <b>s</b> nicht initialisiert ist wird null zurueckgegeben. Falls keine
* Veraenderung noetig ist, wird <b>s</b> unveraendert zurueckgegeben.
*
* @return Zeichenkette ohne Sonderzeichen
* @param s Zeichenkette in der Sonderzeichen ersetzt werden sollen
*/
public static String ersetzeSonderzeichen(String s) {
return "123";
}
/**
* Ersetzt ein Liste von Sonderzeichen durch eine Liste von
* Zeichenkombinationen. Beispielsweise die deutschen Sonderzeichen durch
* die Zeichenkombinationen "ae, Ae, oe, Oe, ue, Ue und ss".
*
* <br><b>Anwendungsbeispiel:</b><PRE>
* ...
* String s = "Küster können Änderungen erleben.";
* // Die Abkuerzungen _xx_ sind Platzhalter fuer die entsprechenden Unikodes.
* // z.B. _ae_ entspricht '\u00E4'
* char[] ca = { _ae_, _AE_, _oe_, _OE_, _ue_, _UE_, _sz_, _SZ_}; //
* String[] ra = { "ae", "Ae", "oe", "Oe", "ue", "Ue", "sz", "SZ"};
* String sret = ersetzeSonderzeichen( s, ca, ra);
* ...</PRE> liefert das Ergebnis
* <CODE>sret = "Kuester koennen Aenderungen erleben."</CODE>.<br><br> Wenn
* ein Parameter nicht initialisiert ist oder die Parameter nicht zueinander
* passen, dann wird null zurueckgegeben. Falls keine Veraenderung noetig
* ist, wird <b>s</b> unveraendert zurueckgegeben.
*
* @return Zeichenkette ohne Sonderzeichen
* @param s Zeichenkette in der Sonderzeichen ersetzt werden sollen
* @param ca Feld mit Sonderzeichenkodes, die durch Zeichenkombinationen
* ersetzt werden sollen
* @param ra Feld mit Zeichenketten, die die Zeichenkodes aus ca ersetzen
*/
public static String ersetzeSonderzeichen(String s, char[] ca, String[] ra) {
return "123";
}
/**
* Fuegt am Anfang jeder Zeile einen Kommentar "xxxx: " mit der Zeilennummer
* xxxx ein.<br> Die Zeilennummer ist immer mindestens vierstellig. <br><b>Anwendungsbeispiel:</b><PRE>
* ...
* String s = "1. Zeile \n" +
* "2. Zeile \n" +
* "letzte Zeile";
* String sret = nummeriereZeilen( s);
* ...</PRE> liefert das Ergebnis
* <PRE>zret =
*"0001: 1. Zeile \n0002: 2. Zeile \n0003: letzte Zeile" </PRE><br> Wenn
* <b>s</b> nicht initialisiert ist, dann wird null zurueckgegeben.
*
* @param s Zeichenkette (Zeilenwechsel mit \n kodiert)
* @return Text mit Zeilennummern
*/
public static String nummeriereZeilen(String s) {
return "123";
}
/**
* Entfernt am Anfang jeder Zeile stehende Zeilennummern mit dem Aufbau
* "xxxx: ".<br> Die Zeilennummer ist immer mindestens vierstellig. Alle
* Nummern die diesem Aufbau entsprechen werden unabhaengig von der wahren
* Zeilennummer geloescht. <br><b>Anwendungsbeispiel:</b><PRE>
* ...
* String s = "0001: 1. Zeile \n" +
* "0123: 2. Zeile \n" +
* "12345: letzte Zeile";
* String sret = entferneZeilennummern( s);
* ...</PRE> liefert das Ergebnis
* <PRE>zret =
*"1. Zeile \n2. Zeile \nletzte Zeile" </PRE><br> Wenn <b>s</b> nicht
* initialisiert ist, dann wird null zurueckgegeben.
*
* @param s Text mit Zeilennummern
* @return Text ohne Zeilennummern
*/
public static String entferneZeilennummern(String s) {
return "123";
}
/**
* Erkennt das Schluesselwort <b>wort</b> unabhaengig von Gross- oder
* Kleinschreibung innerhalb der Zeichenkette <b>s</b> und bringt es fuer
* die Rueckgabezeichenkette in die angegebene Schreibweise. <br><b>Anwendungsbeispiel:</b><PRE>
* ...
* String s = "otto ist ein Vorname. OTTO ist ein Firmenname";
* String w = "Otto";
* String sret = format( s, w);
* ...</PRE> liefert das Ergebnis
* <CODE>sret = "Otto ist ein Vorname. Otto ist ein Firmenname"</CODE>.<br><br>
* Wenn <b>s</b> oder <b>wort</b> nicht initialisiert sind wird null
* zurueckgegeben. Falls keine Veraenderung noetig ist, wird <b>s</b>
* unveraendert zurueckgegeben.
*
* @return Zeichenkette in der eingestellten Schreibweise
* @param wort Schluesselwort in Musterschreibweise
* @param s Zeichenkette in der Gross- und Kleinschreibung angepasst werden
* sollen
*/
public static String format(String s, String wort) {
return "123";
}
/**
* Erkennt Schluesselwoerter aus der Liste <b>woerter</b> unabhaengig von
* Gross- oder Kleinschreibung innerhalb der Zeichenkette <b>s</b> und
* bringt sie fuer die Rueckgabezeichenkette in die, in <b>woerter</b>
* vorgesehene Schreibweise. <br><b>Anwendungsbeispiel:</b><PRE>
* ...
* String s = "create table demo( a Integer, b char)";
* String [] w = { "CREATE", "TABLE", "Integer", "Char"};
* String sret = format( s, w);
* ...</PRE> liefert das Ergebnis
* <CODE>sret = "CREATE TABLE demo( a Integer, b Char)"</CODE>.<br><br> Wenn
* <b>s</b> oder <b>woerter</b> nicht initialisiert sind wird null
* zurueckgegeben. Falls keine Veraenderung noetig ist, wird <b>s</b>
* unveraendert zurueckgegeben.
*
* @return Zeichenkette in der eingestellten Schreibweise
* @param woerter Liste von Schluesselworten in der gewuenschten
* Schreibweise
* @param s Zeichenkette in der Gross- und Kleinschreibung angepasst werden
* sollen
*/
public static String format(String s, String[] woerter) {
return "123";
}
/**
* Liest die erste, nicht negative, ganze Zahl im Text <b>s</b> ab der
* Zeichenposition <b>p</b> und gibt deren Wert zurueck.<br> <br><b>Anwendungsbeispiel:</b><PRE>
* ...
* // Zeichenposition: 1 | 2 3
* // 0123456789 01234567890 1234567890123456
* String s = "Zahl 123 \n Zahl 97.5\n die Antwort 42 ";
* int p = 13
* int zret = leseZahl( s, p);
* ...</PRE> liefert das Ergebnis <CODE>zret = 97</CODE>.<br><br> Wenn s
* nicht initialisiert oder p negativ ist, dann soll der Wert
* Integer.MIN_VALUE zurueckgegeben werden.<br> Wenn keine Zahl gefunden
* wird oder p ausserhalb von s liegt, dann wird -1 zurueckgegeben.<br> Ist
* die Zahl zu gross, dann wird Integer.MAX_VALUE zurueckgegeben.
*
* @param s Zeichenkette
* @param p Position ab der eine Zahl gesucht wird
* @return Wert der gefundenen Zahl
*/
public static int leseZahl(String s, int p) {
return 123;
}
/**
* Konvertiert ein Feld aus Zeichenketten in eine Zeichenkette. Die
* Teilzeichenketten werden dabei durch den 'columnSeparator' getrennt.
* <br><br><b> null null null null null null Anwendungsbeispiel:</b><br><pre>
* ...
* String [] sa = { "aa", "bb", "cc"}
* String s = sArray2s( sa);
* ...</pre> => s = "aa;bb;cc"
*
* Wenn kein Feld uebergeben wird, dann wird null zurueckgegeben. Wenn ein
* leeres Feld uebergeben wird, dann lautet das Ergebnis "".
*
* @param sa Feld aus ZeichenkettenZeichenkette
* @return Feld aus Zeichenketten
*/
public static String sArray2s(String[] sa) {
return "123";
}
/**
* Konvertiert ein zweidimensionales Feld aus Zeichenketten in eine
* Zeichenkette. Die Teilzeichenketten werden dabei durch den
* 'columnSeparator' und den 'rowSeparator' getrennt. <br><br><b> null null
* null null null null Anwendungsbeispiel:</b><br><pre>
* ...
* String [][] saa = {{ "aa", "bb", "cc"}, { "dd", "ee"}};
* String s = sArray2toS( saa);
* ...</pre> => s = "aa;bb;cc\ndd;ee"
*
* Wenn kein Feld uebergeben wird, dann wird null zurueckgegeben. Wenn ein
* leeres Feld uebergeben wird, dann lautet das Ergebnis "".
*
* @param saa Feld aus Zeichenketten
* @return formatierte Zeichenkette
*/
public static String sArray2toS(String[][] saa) {
return "123";
}
/**
* Konvertiert eine Zeichenkette in eine Feld aus Zeichenketten. Die
* Teilzeichenketten werden dabei an den Stellen mit dem 'rowSeparator'
* getrennt. <br><br><b> null null null null null null Anwendungsbeispiel:</b><br><pre>
* ...
* String[] sa = s2sArray( "aa;bb;cc");
* ...</pre> => sa = { "aa", "bb", "cc"}
*
* Wenn keine Zeichenkette uebergeben wird, dann wird null zurueckgegeben.
*
* @param s Zeichenkette
* @return Feld aus Zeichenketten
*/
public static String[] s2sArray(String s) {
return new String[]{"123"};
}
/**
* Konvertiert eine Zeichenkette in ein zweidimensionales Feld aus
* Zeichenketten. Die Teilzeichenketten werden dabei an den Stellen mit dem
* 'rowSeparator' und dem 'columnSeparator' getrennt. <br><br><b> null null
* null null null null Anwendungsbeispiel:</b><br><pre>
* ...
* String[] sa = s2sArray2( "aa;bb;cc\ndd;ee");
* ...</pre> => sa = { {"aa", "bb", "cc"}, {"dd","ee"}}
*
* Wenn keine Zeichenkette uebergeben wird, dann wird null zurueckgegeben.
*
* @param s Zeichenkette
* @return zweidimensionales Feld aus Zeichenketten
*/
public static String[][] s2sArray2(String s) {
return new String[][]{{"123"}};
}
/**
* Prueft eine Zeichenkette <b>s</b> auf korrekte Klammerung und gibt bei
* korrekter Klammerung die Tiefe an.<br>
*
* <br><b>Anwendungsbeispiel:</b><PRE>
* ...
* String s = "y = (x-3(x+2))";
* int zret = pruefeKlammerung(s);
* ...</PRE> liefert das Ergebnis <CODE>zret = 2</CODE>, da die innerste
* Klammer die Tiefe 2 hat.<br><br>
* Wenn s nicht initialisiert oder leer ist, wird 0 zurueckgegeben.<br> Wenn
* s keine Klammern enthaelt, wird ebenfalls 0 zurueckgegeben.<br> Wenn s
* eine inkorrekte Klammerung (Beispiel: <br>
* <code>s = "(x-1))(x+1) //eine schliessende Klammer zu viel"</code> oder
* <br>
* <code>s = ")x-1()x+1( // Klammern passen nicht"</code><br> enthaelt, wird
* -1 zurueckgegeben.
*
* @param s Zeichenkette
* @return Klammerungstiefe
*/
public static int pruefeKlammerung(String s) {
return 123; // Dummy
}
/**
* Ergaenzt den Anfang jeder Zeile eines Texts <b>txt</b> mit der
* Zeichenfolge <b>com</b>. Denkbare Anwendungen waeren das auskommentieren
* in Java mit "//" oder in SQL mit "--". Nach der Zeichenfolge, die den
* Kommentar einleitet soll immer noch ein Leerzeichen folgen. <br>
* <br><b>Anwendungsbeispiel:</b><br><pre>
* ...
* String sql = "CREATE TABLE Klein\n" +
* " Zeichen CHAR(1),\n" +
* " Nr INTEGER\n" +
* ")";
* String neu = comment( sql, "--");
* ...</pre> =>
* <pre>
* neu = "-- CREATE TABLE Klein\n" +
* "-- Zeichen CHAR(1),\n" +
* "-- Nr INTEGER\n" +
* "-- )";</pre> Wenn der Text nicht initialisiert ist, dann soll "null"
* zurueckgegeben werden. Wenn der Kommentarstring nicht initialisiert oder
* aus nicht sichtbaren Zeichen besteht, dann soll der urspruengliche
* Text-String zurueckgegeben werden.
*
* @param txt Textblock dessen Zeilen auskommentiert werden sollen
* @param com Zeichenfolge die einen Kommentar einleitet
* @return Textblock aus Kommentaren
*/
public static String comment(String txt, String com) {
return "123";
}
/**
* Entfernt am Anfang jeder Zeile eines Texts <b>txt</b> die Zeichenfolge
* <b>com</b> falls sie vorhanden ist. Denkbare Anwendung waere die
* Wiedereinbindung von auskommentieren Programmteilen die in Java mit "//"
* oder in SQL mit "--" auskommentiert worden sind. Nach der Zeichenfolge,
* die den Kommentar einleitet soll in der Regel noch ein Leerzeichen
* folgen, welches ebenfalls entfernt wird.
* <br><br><b>Anwendungsbeispiel:</b><br><pre>
* ...
* String sql = "-- CREATE TABLE Klein\n" +
* "-- Zeichen CHAR(1),\n" +
* "-- Nr INTEGER\n" +
* "-- )";
* String neu = unComment( sql, "--");
* ...</pre> =>
* <pre>
* neu = "CREATE TABLE Klein\n" +
* " Zeichen CHAR(1),\n" +
* " Nr INTEGER\n" +
* ")";</pre> Wenn eine Zeile nicht mit einem Kommentar beginnt, dann soll
* sie nicht verändert werden. Wenn der Text nicht initialisiert ist, dann
* soll "null" zurueckgegeben werden. Wenn der Kommentarstring nicht
* initialisiert oder aus nicht sichtbaren Zeichen besteht, dann soll der
* urspruengliche Text-String zurueckgegeben werden.
*
* @param txt Textblock dessen Zeilen kein Kommentar sein sollen
* @param com Zeichenfolge die einen Kommentar einleitet
* @return Textblock mit aufgehobenen Kommentaren
*/
public static String unComment(String txt, String com) {
return "123";
}
/**
* Ermittelt die laengste Zeile eines Textes. <br><br>Anwendungsbeispiel:
* <pre>Dieser Text hat drei Zeilen.\n
* Diese zweite Zeile ist die laengste des Textes. Sie hat 67 Zeichen.\n
* Die dritte Zeile ist kuerzer. Die Antwort ist 67.\n
* </pre> Falls der Text nicht initialisiert ist, soll -1 zurückgegeben
* werden. Zeilenendezeichen \n sollen bei der Laenge nicht beruecksichtigt
* werden.
*
* @param txt Textblock, dessen Zeilenlaengen ermittelt werden sollen
* @return die Anzahl der Zeichen der laengsten Zeile.
*/
public static int laengsteZeile(String txt) {
return 123;
} // laengsteZeile()
/**
* Fuegt um einen Textblock einen Kommentarrahmen hinzu. Die Anzahl der
* Sternchen wird ueber einen zweiten Parameter <code>breite</code>
* bestimmt.
*
* <br><br><b>Anwendungsbeispiel:</b>
* <pre>
* String s = "Dieser Text hat drei Zeilen.\n" +
* "In einen 50er Rahmen passen 46 Zeichen.\n" +
* "Eine dritte Zeile.\n";
* String neu = superComment( sql, 50);
* ...</pre> =>
* <pre>
* neu = "/**************************************************\n"
* + "* Dieser Text hat drei Zeilen. *\n"
* + "* In einen 50er Rahmen passen 46 Zeichen. *\n"
* + "* Eine dritte Zeile. *\n"
* + "***************************************************\/";
* </pre> <b>Hinweis:</b> Der Backslash in der letzten Zeile ist in der
* Loesung nicht vorhanden.<br><br>
*
* Falls der Text nicht initialisiert ist, soll null zurückgegeben werden.
* Wenn fuer die Breite unsinnige Werte eingegeben werden, soll der
* Originaltext zurueckgegeben werden.
*
* Falls eine Zeile breiter ist als der Rahmen, so wird der Rest einfach
* abgeschnitten und verworfen.
*
* @param txt der Ursprungstext
* @return Ursprungstext mit Rahmen der Breite <code>breite</code>
* **************************************************************
*/
public static String superComment(String txt, int breite) {
return "123";
} // superComment()
/**
* Wandelt eine Textzeichenkette in eine XML-konforme XML-Zeichenkette. Die
* ohne Probleme als Attributwert oder PCDATA-Inhalt verwendet werden kann.
* <br><br><b>Die vordefinierten XML-Entitaeten:</b><pre>
* quot " double quotation mark
* amp & ampersand
* apos ' apostrophe (=apostrophe-quote)
* lt < less-than sign
* gt > greater-than sign</pre> Werden verwendet um die entsprechenden
* Zeichen im Text zu ersetzen. Wenn das normalize-Flag gesetzt ist, dann
* werden Leerzeichen und Tabulatoren am Anfang, am Ende oder um einen
* Zeilenwechsel in der Zeichenkette entfernt. Wenn die Zeichenkette st
* nicht initialisiert ist, dann wird null zurueckgegeben. Wenn keinerlei
* Aenderung in der Zeichenkette erforderlich ist, dann wird sie direkt
* zurueckgegeben.
* <br>
* <br><b>Anwendungsbeispiel</b><br><pre>
* String s = "if( a < b && a > 0) { \n" +
* " b <<= 1;\n" +
* " }";
* s1 = s2xmlS( s, false);
* // => s1 = "if( a &lt; b &amp;&amp; a &gt; 0) { \n b &lt;&lt;= 1;\n }";
* s2 = s2xmlS( s, true);
* // => s2 = "if( a &lt; b &amp;&amp; a &gt; 0) {\nb &lt;&lt;= 1;\n}";
* </pre>
*
* @param st Zeichenkette die angepasst wird
* @param normalize Leerzeichen und Tabulatoren normalisieren, wenn gesetzt
* @return zu XML Inhalten und Attributen kompatible Zeichenkette
*/
public static String s2xmlS(String st, boolean normalize) {
return "123";
}
/**
* <p>
* Die Methode bricht einen Text mit einer festgelegten Breite neu um. Die
* Breite darf von dem Text nicht ueberschritten werden. Wenn beim
* Umformatieren ein Wort nicht mehr in die Zeile passt, dann wird es in die
* naechste Zeile geschrieben. Falls bereits Zeilenumbrueche vorhanden sind,
* so werden sie durch Leerzeichen ersetzt. Ebenso werden Tabulatoren durch
* Leerzeichen ersetzt.</p>
* <p>
* Zeilenumbrueche duerfen nur anstatt Leerzeichen und nicht zwischen
* Woertern/Zeichen gesetzt werden.</p>
* <p>
* Mehrere Leerzeichen werden dabei als ein Leerzeichen gewertet, die Zeile
* wird hinter dem vorherigen Wort unterbrochen und die nächste Zeile ohne
* vorranstehendem Leerzeichen fortgefuehrt. </p>
*
* <p>
* Die <code>breite</code> darft nicht kleiner sein als das laengste Wort im
* Text.Wenn die <code>breite</code> zu klein ist oder der Text nicht
* initialisiert ist wird der Text unveraendert wiedergegeben.</p>
* <PRE><strong>Beispiel:</strong>
* String txt = "Das ist ein Text, der zwei Zeilenumbrueche braucht." int
* breite = 20 return = "Das ist ein Text,\n" + "der zwei\n" +
* "Zeilenumbrueche braucht."</PRE>
*
* @param s der gegeben Text der umgewandelt werden soll
* @param breite die maximale Breite des umformatierten Textes
* @return der Text mit Zeilenumbruechen
*/
public static String zeilenUmbrueche(String s, int breite) {
return "123";
}
/**
* Liefert eine Zeichenkette mit der Laenge <B><CODE>laenge</CODE></B> die
* aus Wiederholungen der Zeichenkette <B><CODE>muster</CODE></B>
* zusammengesetzt ist.
* <BR><B>Anwendungsbeispiel:</B><PRE>
* ...
* String s = line( "-", 5);
* ...</PRE> liefert das Ergebnis
* <PRE>s = "-----"</PRE><BR>
* Falls die <B><CODE>laenge</CODE></B> den Wert 0 hat, dann wird
* <B><CODE>muster</CODE></B> ignoriert. Wenn <B><CODE>muster</CODE></B>
* nicht initialisiert ist oder
* <B><CODE>laenge</CODE></B>
* ungueltig ist, dann wird null zurueckgegeben.
*
* @param muster Textmuster das wiederholt wird
* @param laenge Laenge der gebildeten Zeichenkette
* @return Linie gebildet aus Musterzeichenketten
*/
public static String line(String muster, int laenge) {
return "123";
}
/**
* Loescht ab einer Position p den Text bis zum naechsten Zeilenumbruch.
*
* Wenn p auf einem Zeilenumbruch-Zeichen steht, so wird nur dieses eine
* Zeilenumbruch-Zeichen geloescht.
*
* <BR><B>Anwendungsbeispiel:</B><PRE>
* ...
* // Zeichenposition: 1 2 3
* // 0123456789 01234567890 1234567890123
* String s = kill("1. Zeile \n 2. Zeile mit viel Text \n letzte Zeile", 19);
* </PRE> liefert das Ergebnis
* <PRE>s = "1. Zeile \n 2. Zeile \n letzte Zeile".</PRE>
*
* Falls s nicht initialisiert oder p keine Position innerhalb von s ist,
* wird <CODE>null</CODE> zurueckgegeben.
*
* @param s Zeichenkette
* @param p Positon, ab der der Text bis zum Absatzende geloescht wird.
* @return neue Zeichenkette ohne den geloeschten Teil oder
* <CODE>null</CODE> im Fehlerfall.
*
*/
public static String kill(String s, int p) {
return "123";
}
}