[Schmitzm-commits] r1580 - in trunk/schmitzm-core/src: main/java/de/schmitzm/lang main/java/de/schmitzm/versionnumber test/java/de/schmitzm/lang
scm-commit@wald.intevation.org
scm-commit at wald.intevation.org
Sun May 15 18:46:21 CEST 2011
Author: alfonx
Date: 2011-05-15 18:46:20 +0200 (Sun, 15 May 2011)
New Revision: 1580
Modified:
trunk/schmitzm-core/src/main/java/de/schmitzm/lang/LangUtil.java
trunk/schmitzm-core/src/main/java/de/schmitzm/versionnumber/ReleaseUtil.java
trunk/schmitzm-core/src/test/java/de/schmitzm/lang/LangUtilTest.java
Log:
neue regex funktion
Modified: trunk/schmitzm-core/src/main/java/de/schmitzm/lang/LangUtil.java
===================================================================
--- trunk/schmitzm-core/src/main/java/de/schmitzm/lang/LangUtil.java 2011-05-12 15:20:20 UTC (rev 1579)
+++ trunk/schmitzm-core/src/main/java/de/schmitzm/lang/LangUtil.java 2011-05-15 16:46:20 UTC (rev 1580)
@@ -48,6 +48,7 @@
import java.util.Locale;
import java.util.TreeSet;
import java.util.Vector;
+import java.util.regex.Matcher;
import java.util.regex.Pattern;
import net.jini.loader.pref.PreferredClassLoader;
@@ -66,8 +67,7 @@
/**
* Diese Klasse stellt Hilfsfunktionen fuer Basisoperationen bereit.
*
- * @author <a href="mailto:martin.schmitz at koeln.de">Martin Schmitz</a>
- * (University of Bonn/Germany)
+ * @author <a href="mailto:martin.schmitz at koeln.de">Martin Schmitz</a> (University of Bonn/Germany)
* @version 1.0
*/
public class LangUtil {
@@ -87,30 +87,24 @@
/**
* Date formatter for "dd.MM.yyyy [HH:mm:ss]".
*/
- public static final DateFormat DEFAULT_DATE_TIME_FORMATTER = new SimpleDateFormat(
- "dd.MM.yyyy [HH:mm:ss]");
+ public static final DateFormat DEFAULT_DATE_TIME_FORMATTER = new SimpleDateFormat("dd.MM.yyyy [HH:mm:ss]");
/**
- * Liefert <code>true</code> wenn der String nur Nullen, Leerzeichen,
- * Kommata und/oder Punkte enthält.
+ * Liefert <code>true</code> wenn der String nur Nullen, Leerzeichen, Kommata und/oder Punkte enthält.
*/
public static boolean onlyZero(String numerString) {
return onlyZerosRegEx.matcher(numerString).find();
}
/**
- * {@link ResourceProvider}, der die Lokalisation fuer Komponenten des
- * Package {@code schmitzm.lang} zur Verfuegung stellt. Diese sind in
- * properties-Dateien unter {@code schmitzm.lang.resource.locales}
- * hinterlegt.
+ * {@link ResourceProvider}, der die Lokalisation fuer Komponenten des Package {@code schmitzm.lang} zur Verfuegung
+ * stellt. Diese sind in properties-Dateien unter {@code schmitzm.lang.resource.locales} hinterlegt.
*/
public static ResourceProvider RESOURCE = ResourceProvider.newInstance(
- extendPackagePath(LangUtil.class,
- "resource.locales.LangResourceBundle"), Locale.ENGLISH);
+ extendPackagePath(LangUtil.class, "resource.locales.LangResourceBundle"), Locale.ENGLISH);
/**
- * Liefert den einfachen Namen einer Klasse (ohne Package) oder den String
- * "null", falls das Objekt {@code null} ist
+ * Liefert den einfachen Namen einer Klasse (ohne Package) oder den String "null", falls das Objekt {@code null} ist
*
* @param object
* ein Objekt
@@ -133,10 +127,9 @@
}
/**
- * Completes an incomplete date definition (in european dotted-format
- * {@code dd.MM.yyyy}). Missing dots are also added. In this case the method
- * expects that day is given with 2 digits. If month and/or year is not
- * given, these information is completed with the current month/year.<br>
+ * Completes an incomplete date definition (in european dotted-format {@code dd.MM.yyyy}). Missing dots are also
+ * added. In this case the method expects that day is given with 2 digits. If month and/or year is not given, these
+ * information is completed with the current month/year.<br>
* Examples: Expect that current date is 29.03.2011, then
* <ul>
* <li>"12102009" is completed to "12.10.2009"</li>
@@ -149,8 +142,7 @@
*
* @param dateStr
* a european date definition as string
- * @return the source string if the given string contains other signs than
- * digits and dots
+ * @return the source string if the given string contains other signs than digits and dots
*/
public static String completeEuropeanDateString(String dateStr) {
if (dateStr == null || !dateStr.matches("[\\d\\.]+"))
@@ -190,8 +182,7 @@
// "19" erweitern
String yearStr = dateStr.substring(dateStr.lastIndexOf(".") + 1);
if (Integer.parseInt(yearStr) < 100)
- dateStr = dateStr.substring(0, dateStr.lastIndexOf("."))
- + ".19" + yearStr;
+ dateStr = dateStr.substring(0, dateStr.lastIndexOf(".")) + ".19" + yearStr;
}
return dateStr;
@@ -201,8 +192,7 @@
* Returns the current time as formatted string.
*
* @param format
- * date format as defined in {@link SimpleDateFormat} (if
- * {@code null}, the default format is used)
+ * date format as defined in {@link SimpleDateFormat} (if {@code null}, the default format is used)
* @see #DEFAULT_DATE_TIME_FORMATTER
*/
public static String getCurrentTimeFormatted(String formatPattern) {
@@ -232,18 +222,16 @@
* Checks whether both objects are {@code null} or equal.
*/
public static boolean checkEqual(Object o1, Object o2) {
- return o1 == null && o2 == null ||
- o1 != null && o2 != null && o1.equals(o2);
+ return o1 == null && o2 == null || o1 != null && o2 != null && o1.equals(o2);
}
-
+
/**
* Haengt Strings aneinander, getrennt durch Trennzeichen.
*
* @param delim
* Trennzeichen (kann {@code null} sein)
* @param strList
- * Liste von Strings ({@code null}-Elemente und leere Strings
- * werden ignoriert
+ * Liste von Strings ({@code null}-Elemente und leere Strings werden ignoriert
* @return
*/
public static String listString(String delim, String... strList) {
@@ -268,20 +256,17 @@
* @param delim
* Trennzeichen (kann {@code null} sein)
* @param ignoreNulls
- * bestimmt, ob {@code null}-Elemente (und leere Strings)
- * ignoriert werden
+ * bestimmt, ob {@code null}-Elemente (und leere Strings) ignoriert werden
* @param objList
* Liste von Objekten
* @return
*/
- public static String listObjects(String delim, boolean ignoreNulls,
- Object... objList) {
+ public static String listObjects(String delim, boolean ignoreNulls, Object... objList) {
StringBuffer resultStr = new StringBuffer();
for (int i = 0; i < objList.length; i++) {
// ignore item if it is null or empty
if (ignoreNulls
- && (objList[i] == null || objList[i] instanceof String
- && "".equals(((String) objList[i]).trim())))
+ && (objList[i] == null || objList[i] instanceof String && "".equals(((String) objList[i]).trim())))
continue;
// append delimiter (if necessary)
if (resultStr.length() > 0 && delim != null)
@@ -299,14 +284,12 @@
* @param delim
* Trennzeichen (kann {@code null} sein)
* @param ignoreNulls
- * bestimmt, ob {@code null}-Elemente (und leere Strings)
- * ignoriert werden
+ * bestimmt, ob {@code null}-Elemente (und leere Strings) ignoriert werden
* @param objList
* Liste von Objekten
* @return
*/
- public static String listObjects(String delim, boolean ignoreNulls,
- Collection<?> values) {
+ public static String listObjects(String delim, boolean ignoreNulls, Collection<?> values) {
Object[] objArray = values.toArray();
return listObjects(delim, ignoreNulls, objArray);
}
@@ -319,8 +302,7 @@
* @param fieldName
* feld name
*/
- public static boolean checkEnumValue(Class<? extends Enum> enumClass,
- String fieldName) {
+ public static boolean checkEnumValue(Class<? extends Enum> enumClass, String fieldName) {
try {
Enum.valueOf(enumClass, fieldName);
return true;
@@ -330,14 +312,13 @@
}
/**
- * Fuegt alle Elemente eines Arrays in einen {@link Vector} ein. Wird als
- * Vector <code>null</code> angegeben, wird ein neuer Vector erzeugt.
+ * Fuegt alle Elemente eines Arrays in einen {@link Vector} ein. Wird als Vector <code>null</code> angegeben, wird
+ * ein neuer Vector erzeugt.
*
* @param obj
* einzufuegende Objekte
* @param vec
- * Vector in den die Elemente eingefuegt werden (kann
- * <code>null</code> sein)
+ * Vector in den die Elemente eingefuegt werden (kann <code>null</code> sein)
* @return den Vector <code>vec</code> oder eine neue {@link Vector}-Instanz
*/
public static Vector addObjectsToVector(Object[] obj, Vector vec) {
@@ -362,15 +343,13 @@
Arrays.fill(maxSpacePattern, ' ');
for (int pos; (pos = outString.indexOf('\t')) >= 0;) {
- outString = outString.replaceFirst("\t",
- String.valueOf(maxSpacePattern, 0, tabLen - pos % tabLen));
+ outString = outString.replaceFirst("\t", String.valueOf(maxSpacePattern, 0, tabLen - pos % tabLen));
}
return outString;
}
/**
- * Haengt eine beliebige Anzahl von Objekte als Strings (toString())
- * hintereinander.
+ * Haengt eine beliebige Anzahl von Objekte als Strings (toString()) hintereinander.
*
* @param str
* aneinanderzuhaengende Objekte
@@ -384,8 +363,7 @@
}
/**
- * Haengt eine beliebige Anzahl von Strings hintereinander und fuegt
- * zwischen den Strings einen Trenner ein.
+ * Haengt eine beliebige Anzahl von Strings hintereinander und fuegt zwischen den Strings einen Trenner ein.
*
* @param sep
* Trenner
@@ -397,8 +375,7 @@
}
/**
- * Haengt eine beliebige Anzahl von Strings hintereinander und fuegt
- * zwischen den Strings einen Trenner ein.
+ * Haengt eine beliebige Anzahl von Strings hintereinander und fuegt zwischen den Strings einen Trenner ein.
*
* @param sep
* Trenner
@@ -410,22 +387,19 @@
}
/**
- * Haengt eine beliebige Anzahl von Strings hintereinander und fuegt
- * zwischen den Strings einen Trenner ein. Optional werden die einzelnen
- * Strings mit einem speziellen Zeichen (z.B. Apostroph oder
- * Anfuehrungszeichen) maskiert.
+ * Haengt eine beliebige Anzahl von Strings hintereinander und fuegt zwischen den Strings einen Trenner ein.
+ * Optional werden die einzelnen Strings mit einem speziellen Zeichen (z.B. Apostroph oder Anfuehrungszeichen)
+ * maskiert.
*
* @param sep
* Trenner
* @param maskChar
- * Zeichen, mit dem die aneinandergehaengten Strings gekapselt
- * werden (z.B. Apostroph oder Anfuehrungszeichen). Wenn
- * {@code null} oder leer, werden die Strings nicht gekapselt.
+ * Zeichen, mit dem die aneinandergehaengten Strings gekapselt werden (z.B. Apostroph oder
+ * Anfuehrungszeichen). Wenn {@code null} oder leer, werden die Strings nicht gekapselt.
* @param str
* aneinanderzuhaengende Stings
*/
- public static String stringConcatWithSep(String sep, String maskChar,
- Object... str) {
+ public static String stringConcatWithSep(String sep, String maskChar, Object... str) {
StringBuffer sb = new StringBuffer();
for (int i = 0; str != null && i < str.length; i++) {
if (i > 0)
@@ -569,20 +543,17 @@
case 20:
return new Object[size[0]][size[1]][size[2]][size[3]][size[4]][size[5]][size[6]][size[7]][size[8]][size[9]][size[10]][size[11]][size[12]][size[13]][size[14]][size[15]][size[16]][size[17]][size[18]][size[19]];
}
- throw new IllegalArgumentException("Dimension not supported: "
- + size.length);
+ throw new IllegalArgumentException("Dimension not supported: " + size.length);
}
/**
* Liefert die Dimension eines multi-dimensionalen {@link Object}-Array.<br>
- * <b>Diese Methode funktioniert nur, wenn das Element 0 in jeder Dimension
- * belegt ist!</b>
+ * <b>Diese Methode funktioniert nur, wenn das Element 0 in jeder Dimension belegt ist!</b>
*
* @param array
* multi-dim. Array (Instanz von {@code Object[]..[]})
* @exception ArrayIndexOutOfBoundsException
- * wenn das 0te Element in einer Dimension mit {@code null}
- * belegt ist
+ * wenn das 0te Element in einer Dimension mit {@code null} belegt ist
*/
public static int getArrayDimension(Object array) {
int dim = 0;
@@ -596,16 +567,13 @@
}
/**
- * Liefert die Groessen der einzelnen Dimensionen eines multi-dimensionalen
- * {@link Object}-Array.<br>
- * <b>Diese Methode funktioniert nur, wenn das Element 0 in jeder Dimension
- * belegt ist!</b>
+ * Liefert die Groessen der einzelnen Dimensionen eines multi-dimensionalen {@link Object}-Array.<br>
+ * <b>Diese Methode funktioniert nur, wenn das Element 0 in jeder Dimension belegt ist!</b>
*
* @param array
* multi-dim. Array (Instanz von {@code Object[]..[]})
* @exception ArrayIndexOutOfBoundsException
- * wenn das 0te Element in einer Dimension mit {@code null}
- * belegt ist
+ * wenn das 0te Element in einer Dimension mit {@code null} belegt ist
*/
public static int[] getArrayLength(Object array) {
int[] dimSize = new int[getArrayDimension(array)];
@@ -651,30 +619,25 @@
}
/**
- * Kopiert einen Array (aber nicht dessen Elemente). Darueberhinaus koennen
- * (einige) Elemente direkt neu belegt werden. Ist das Flag {@code replNull}
- * auf {@code false} gesetzt, werden {@code null}-Werte in {@code replElem}
- * ignoriert. So ist es z.B. moeglich, nur das 4. und 5. Element im neuen
- * Array neu zu belegen und die davor liegenden Elemente unangetastet zu
- * lassen.
+ * Kopiert einen Array (aber nicht dessen Elemente). Darueberhinaus koennen (einige) Elemente direkt neu belegt
+ * werden. Ist das Flag {@code replNull} auf {@code false} gesetzt, werden {@code null}-Werte in {@code replElem}
+ * ignoriert. So ist es z.B. moeglich, nur das 4. und 5. Element im neuen Array neu zu belegen und die davor
+ * liegenden Elemente unangetastet zu lassen.
*
* @param source
* zu kopierender Array
* @param replNull
- * Bestimmt, ob {@code null}-Elemente von {@code replElem} im
- * neuen Array gesetzt werden ({@code true}) oder nicht
+ * Bestimmt, ob {@code null}-Elemente von {@code replElem} im neuen Array gesetzt werden ({@code true})
+ * oder nicht
* @param replElem
- * Elemente (beginnend bei Index 0), die nach dem Kopieren im
- * Array neu gesetzt werden
+ * Elemente (beginnend bei Index 0), die nach dem Kopieren im Array neu gesetzt werden
* @return Array von der Groesse {@code max(source.length, replElem.length)}
*/
- public static <T> T[] cloneArray(T[] source, boolean replNull,
- T... replElem) {
+ public static <T> T[] cloneArray(T[] source, boolean replNull, T... replElem) {
if (source == null)
return null;
- T[] newArray = java.util.Arrays.copyOf(source,
- Math.max(source.length, replElem.length));
+ T[] newArray = java.util.Arrays.copyOf(source, Math.max(source.length, replElem.length));
for (int i = 0; i < replElem.length; i++)
if (replNull || replElem[i] != null)
newArray[i] = replElem[i];
@@ -682,14 +645,13 @@
}
/**
- * Kopiert einen Array (aber nicht dessen Elemente). Darueberhinaus koennen
- * (einige) Elemente direkt neu belegt werden.
+ * Kopiert einen Array (aber nicht dessen Elemente). Darueberhinaus koennen (einige) Elemente direkt neu belegt
+ * werden.
*
* @param source
* zu kopierender Array
* @param replElem
- * Elemente (beginnend bei Index 0), die nach dem Kopieren im
- * Array neu gesetzt werden
+ * Elemente (beginnend bei Index 0), die nach dem Kopieren im Array neu gesetzt werden
* @return Array von der Groesse {@code max(source.length, replElem.length)}
*/
public static <T> T[] cloneArray(T[] source, T... replElem) {
@@ -702,16 +664,14 @@
* @param source
* zu kopierender Array
* @param replElem
- * Elemente (beginnend bei Index 0), die nach dem Kopieren im
- * Array neu gesetzt werden
+ * Elemente (beginnend bei Index 0), die nach dem Kopieren im Array neu gesetzt werden
* @return Array von der Groesse {@code max(source.length, replElem.length)}
*/
public static long[] cloneArray(long[] source, long... replElem) {
if (source == null)
return null;
- long[] newArray = java.util.Arrays.copyOf(source,
- Math.max(source.length, replElem.length));
+ long[] newArray = java.util.Arrays.copyOf(source, Math.max(source.length, replElem.length));
for (int i = 0; i < replElem.length; i++)
newArray[i] = replElem[i];
return newArray;
@@ -723,16 +683,14 @@
* @param source
* zu kopierender Array
* @param replElem
- * Elemente (beginnend bei Index 0), die nach dem Kopieren im
- * Array neu gesetzt werden
+ * Elemente (beginnend bei Index 0), die nach dem Kopieren im Array neu gesetzt werden
* @return Array von der Groesse {@code max(source.length, replElem.length)}
*/
public static int[] cloneArray(int[] source, int... replElem) {
if (source == null)
return null;
- int[] newArray = java.util.Arrays.copyOf(source,
- Math.max(source.length, replElem.length));
+ int[] newArray = java.util.Arrays.copyOf(source, Math.max(source.length, replElem.length));
for (int i = 0; i < replElem.length; i++)
newArray[i] = replElem[i];
return newArray;
@@ -744,16 +702,14 @@
* @param source
* zu kopierender Array
* @param replElem
- * Elemente (beginnend bei Index 0), die nach dem Kopieren im
- * Array neu gesetzt werden
+ * Elemente (beginnend bei Index 0), die nach dem Kopieren im Array neu gesetzt werden
* @return Array von der Groesse {@code max(source.length, replElem.length)}
*/
public static short[] cloneArray(short[] source, short... replElem) {
if (source == null)
return null;
- short[] newArray = java.util.Arrays.copyOf(source,
- Math.max(source.length, replElem.length));
+ short[] newArray = java.util.Arrays.copyOf(source, Math.max(source.length, replElem.length));
for (int i = 0; i < replElem.length; i++)
newArray[i] = replElem[i];
return newArray;
@@ -765,15 +721,13 @@
* @param source
* zu kopierender Array
* @param replElem
- * Elemente (beginnend bei Index 0), die nach dem Kopieren im
- * Array neu gesetzt werden
+ * Elemente (beginnend bei Index 0), die nach dem Kopieren im Array neu gesetzt werden
* @return Array von der Groesse {@code max(source.length, replElem.length)}
*/
public static byte[] cloneArray(byte[] source, byte... replElem) {
if (source == null)
return null;
- byte[] newArray = java.util.Arrays.copyOf(source,
- Math.max(source.length, replElem.length));
+ byte[] newArray = java.util.Arrays.copyOf(source, Math.max(source.length, replElem.length));
for (int i = 0; i < replElem.length; i++)
newArray[i] = replElem[i];
return newArray;
@@ -785,16 +739,14 @@
* @param source
* zu kopierender Array
* @param replElem
- * Elemente (beginnend bei Index 0), die nach dem Kopieren im
- * Array neu gesetzt werden
+ * Elemente (beginnend bei Index 0), die nach dem Kopieren im Array neu gesetzt werden
* @return Array von der Groesse {@code max(source.length, replElem.length)}
*/
public static double[] cloneArray(double[] source, double... replElem) {
if (source == null)
return null;
- double[] newArray = java.util.Arrays.copyOf(source,
- Math.max(source.length, replElem.length));
+ double[] newArray = java.util.Arrays.copyOf(source, Math.max(source.length, replElem.length));
for (int i = 0; i < replElem.length; i++)
newArray[i] = replElem[i];
return newArray;
@@ -806,16 +758,14 @@
* @param source
* zu kopierender Array
* @param replElem
- * Elemente (beginnend bei Index 0), die nach dem Kopieren im
- * Array neu gesetzt werden
+ * Elemente (beginnend bei Index 0), die nach dem Kopieren im Array neu gesetzt werden
* @return Array von der Groesse {@code max(source.length, replElem.length)}
*/
public static float[] cloneArray(float[] source, float... replElem) {
if (source == null)
return null;
- float[] newArray = java.util.Arrays.copyOf(source,
- Math.max(source.length, replElem.length));
+ float[] newArray = java.util.Arrays.copyOf(source, Math.max(source.length, replElem.length));
for (int i = 0; i < replElem.length; i++)
newArray[i] = replElem[i];
return newArray;
@@ -827,15 +777,13 @@
* @param source
* zu kopierender Array
* @param replElem
- * Elemente (beginnend bei Index 0), die nach dem Kopieren im
- * Array neu gesetzt werden
+ * Elemente (beginnend bei Index 0), die nach dem Kopieren im Array neu gesetzt werden
* @return Array von der Groesse {@code max(source.length, replElem.length)}
*/
public static boolean[] cloneArray(boolean[] source, boolean... replElem) {
if (source == null)
return null;
- boolean[] newArray = java.util.Arrays.copyOf(source,
- Math.max(source.length, replElem.length));
+ boolean[] newArray = java.util.Arrays.copyOf(source, Math.max(source.length, replElem.length));
for (int i = 0; i < replElem.length; i++)
newArray[i] = replElem[i];
return newArray;
@@ -847,15 +795,13 @@
* @param source
* zu kopierender Array
* @param replElem
- * Elemente (beginnend bei Index 0), die nach dem Kopieren im
- * Array neu gesetzt werden
+ * Elemente (beginnend bei Index 0), die nach dem Kopieren im Array neu gesetzt werden
* @return Array von der Groesse {@code max(source.length, replElem.length)}
*/
public static char[] cloneArray(char[] source, char... replElem) {
if (source == null)
return null;
- char[] newArray = java.util.Arrays.copyOf(source,
- Math.max(source.length, replElem.length));
+ char[] newArray = java.util.Arrays.copyOf(source, Math.max(source.length, replElem.length));
for (int i = 0; i < replElem.length; i++)
newArray[i] = replElem[i];
return newArray;
@@ -871,8 +817,7 @@
* @return Array von der Groesse {@code source.length + newElem.length}
*/
public static <T> T[] extendArray(T[] source, T... newElem) {
- T[] newArray = java.util.Arrays.copyOf(source, source.length
- + newElem.length);
+ T[] newArray = java.util.Arrays.copyOf(source, source.length + newElem.length);
for (int i = 0; i < newElem.length; i++)
newArray[source.length + i] = newElem[i];
return newArray;
@@ -888,8 +833,7 @@
* @return Array von der Groesse {@code source.length + newElem.length}
*/
public static long[] extendArray(long[] source, long... newElem) {
- long[] newArray = java.util.Arrays.copyOf(source, source.length
- + newElem.length);
+ long[] newArray = java.util.Arrays.copyOf(source, source.length + newElem.length);
for (int i = 0; i < newElem.length; i++)
newArray[source.length + i] = newElem[i];
return newArray;
@@ -905,8 +849,7 @@
* @return Array von der Groesse {@code source.length + newElem.length}
*/
public static int[] extendArray(int[] source, int... newElem) {
- int[] newArray = java.util.Arrays.copyOf(source, source.length
- + newElem.length);
+ int[] newArray = java.util.Arrays.copyOf(source, source.length + newElem.length);
for (int i = 0; i < newElem.length; i++)
newArray[source.length + i] = newElem[i];
return newArray;
@@ -922,8 +865,7 @@
* @return Array von der Groesse {@code source.length + newElem.length}
*/
public static short[] extendArray(short[] source, short... newElem) {
- short[] newArray = java.util.Arrays.copyOf(source, source.length
- + newElem.length);
+ short[] newArray = java.util.Arrays.copyOf(source, source.length + newElem.length);
for (int i = 0; i < newElem.length; i++)
newArray[source.length + i] = newElem[i];
return newArray;
@@ -939,8 +881,7 @@
* @return Array von der Groesse {@code source.length + newElem.length}
*/
public static byte[] extendArray(byte[] source, byte... newElem) {
- byte[] newArray = java.util.Arrays.copyOf(source, source.length
- + newElem.length);
+ byte[] newArray = java.util.Arrays.copyOf(source, source.length + newElem.length);
for (int i = 0; i < newElem.length; i++)
newArray[source.length + i] = newElem[i];
return newArray;
@@ -956,8 +897,7 @@
* @return Array von der Groesse {@code source.length + newElem.length}
*/
public static double[] extendArray(double[] source, double... newElem) {
- double[] newArray = java.util.Arrays.copyOf(source, source.length
- + newElem.length);
+ double[] newArray = java.util.Arrays.copyOf(source, source.length + newElem.length);
for (int i = 0; i < newElem.length; i++)
newArray[source.length + i] = newElem[i];
return newArray;
@@ -973,8 +913,7 @@
* @return Array von der Groesse {@code source.length + newElem.length}
*/
public static float[] extendArray(float[] source, float... newElem) {
- float[] newArray = java.util.Arrays.copyOf(source, source.length
- + newElem.length);
+ float[] newArray = java.util.Arrays.copyOf(source, source.length + newElem.length);
for (int i = 0; i < newElem.length; i++)
newArray[source.length + i] = newElem[i];
return newArray;
@@ -990,8 +929,7 @@
* @return Array von der Groesse {@code source.length + newElem.length}
*/
public static boolean[] extendArray(boolean[] source, boolean... newElem) {
- boolean[] newArray = java.util.Arrays.copyOf(source, source.length
- + newElem.length);
+ boolean[] newArray = java.util.Arrays.copyOf(source, source.length + newElem.length);
for (int i = 0; i < newElem.length; i++)
newArray[source.length + i] = newElem[i];
return newArray;
@@ -1007,8 +945,7 @@
* @return Array von der Groesse {@code source.length + newElem.length}
*/
public static char[] extendArray(char[] source, char... newElem) {
- char[] newArray = java.util.Arrays.copyOf(source, source.length
- + newElem.length);
+ char[] newArray = java.util.Arrays.copyOf(source, source.length + newElem.length);
for (int i = 0; i < newElem.length; i++)
newArray[source.length + i] = newElem[i];
return newArray;
@@ -1020,39 +957,32 @@
* @param clazz
* Klassen
* @param simple
- * gibt an, ob der einfache Klassenname ({@code true}) oder der
- * komplette Klassenname inkl. Paketname ({@code false})
- * zurueckgegeben wird.
+ * gibt an, ob der einfache Klassenname ({@code true}) oder der komplette Klassenname inkl. Paketname (
+ * {@code false}) zurueckgegeben wird.
*/
public static String[] getClassNames(Class[] clazz, boolean simple) {
String[] className = new String[clazz.length];
for (int i = 0; i < className.length; i++)
- className[i] = simple ? clazz[i].getSimpleName() : clazz[i]
- .getName();
+ className[i] = simple ? clazz[i].getSimpleName() : clazz[i].getName();
return className;
}
/**
- * Instantiates an object by {@link Class#forName(String)}. The class must
- * be present in runtime classpath.
+ * Instantiates an object by {@link Class#forName(String)}. The class must be present in runtime classpath.
*
* @param className
* full name of class (incl. package)
* @param fallback
- * if <code>true</code> this method returns <code>null</code> if
- * {@link Class#forName(String)} fails
+ * if <code>true</code> this method returns <code>null</code> if {@link Class#forName(String)} fails
* @param constrArg
* arguments for the constructor
* @exception UnsupportedOperationException
- * if class could be loaded, but no matching constructor can
- * be found
+ * if class could be loaded, but no matching constructor can be found
* @exception RuntimeException
- * if class can not be loaded and fallback is disabled or
- * another error occurs during
+ * if class can not be loaded and fallback is disabled or another error occurs during
* {@link Constructor#newInstance(Object...)}
*/
- public static Object instantiateObject(String className, boolean fallback,
- Object... constrArg) {
+ public static Object instantiateObject(String className, boolean fallback, Object... constrArg) {
try {
Class<?> clazz = Class.forName(className);
for (Constructor constructor : clazz.getConstructors())
@@ -1060,8 +990,7 @@
return constructor.newInstance(constrArg);
} catch (IllegalArgumentException err) {
}
- throw new UnsupportedOperationException(
- "No matching constructor found...");
+ throw new UnsupportedOperationException("No matching constructor found...");
} catch (ClassNotFoundException err) {
// if we want to fall back, we do nothing but
// return NULL
@@ -1079,8 +1008,7 @@
/**
* Ruft die Java Garbage Collection auf.
*
- * @return Anzahl an Bytes, die durch den Aufruf der Garbage Collection
- * freigegeben wurden
+ * @return Anzahl an Bytes, die durch den Aufruf der Garbage Collection freigegeben wurden
* @see Runtime#gc()
* @see Runtime#freeMemory()
*/
@@ -1092,11 +1020,9 @@
}
/**
- * Ruft die Java Garbage Collection solange auf, bis kein Speicher mehr
- * freigegeben werden kann.
+ * Ruft die Java Garbage Collection solange auf, bis kein Speicher mehr freigegeben werden kann.
*
- * @return Gesamt-Anzahl an Bytes, die durch die Aufrufe der Garbage
- * Collection freigegeben wurden
+ * @return Gesamt-Anzahl an Bytes, die durch die Aufrufe der Garbage Collection freigegeben wurden
* @see #gc()
*/
public static long gcTotal() {
@@ -1107,22 +1033,19 @@
}
/**
- * Erzeugt einen neuen {@link URLClassLoader}, der vom
- * {@linkplain ClassLoader#getSystemClassLoader() System-ClassLoaders}
- * abgeleitet ist.
+ * Erzeugt einen neuen {@link URLClassLoader}, der vom {@linkplain ClassLoader#getSystemClassLoader()
+ * System-ClassLoaders} abgeleitet ist.
*
* @param searchPath
* Pfade, in denen der ClassLoader nach Klassen sucht
*/
public static ClassLoader createClassLoader(URL[] searchPath) {
- return URLClassLoader.newInstance(searchPath,
- ClassLoader.getSystemClassLoader());
+ return URLClassLoader.newInstance(searchPath, ClassLoader.getSystemClassLoader());
}
/**
- * Erzeugt einen neuen {@link URLClassLoader}, der vom
- * {@linkplain ClassLoader#getSystemClassLoader() System-ClassLoaders}
- * abgeleitet ist.
+ * Erzeugt einen neuen {@link URLClassLoader}, der vom {@linkplain ClassLoader#getSystemClassLoader()
+ * System-ClassLoaders} abgeleitet ist.
*
* @param searchPath
* Pfad, in denm der ClassLoader nach Klassen sucht
@@ -1132,38 +1055,30 @@
}
/**
- * Laed eine Klasse. Ggf. wird hierfuer ein neuer {@link ClassLoader}
- * erzeugt.
+ * Laed eine Klasse. Ggf. wird hierfuer ein neuer {@link ClassLoader} erzeugt.
*
* @param clazz
* Klassenname (inkl. Paket)
* @param searchPath
- * Pfade, in denen der ClassLoader nach Klassen sucht (wenn
- * <code>null</code>, wird der
- * {@linkplain ClassLoader#getSystemClassLoader()
- * System-ClassLoader} zum Laden der Klasse verwendet)
+ * Pfade, in denen der ClassLoader nach Klassen sucht (wenn <code>null</code>, wird der
+ * {@linkplain ClassLoader#getSystemClassLoader() System-ClassLoader} zum Laden der Klasse verwendet)
*/
- public static Class loadClass(String clazz, URL[] searchPath)
- throws ClassNotFoundException {
+ public static Class loadClass(String clazz, URL[] searchPath) throws ClassNotFoundException {
if (searchPath == null)
return Class.forName(clazz);
return createClassLoader(searchPath).loadClass(clazz);
}
/**
- * Laed eine Klasse. Ggf. wird hierfuer ein neuer {@link ClassLoader}
- * erzeugt.
+ * Laed eine Klasse. Ggf. wird hierfuer ein neuer {@link ClassLoader} erzeugt.
*
* @param clazz
* Klassenname (inkl. Paket)
* @param searchPath
- * Pfad, in dem der ClassLoader nach Klassen sucht (wenn
- * <code>null</code>, wird der
- * {@linkplain ClassLoader#getSystemClassLoader()
- * System-ClassLoader} zum Laden der Klasse verwendet)
+ * Pfad, in dem der ClassLoader nach Klassen sucht (wenn <code>null</code>, wird der
+ * {@linkplain ClassLoader#getSystemClassLoader() System-ClassLoader} zum Laden der Klasse verwendet)
*/
- public static Class loadClass(String clazz, URL searchPath)
- throws ClassNotFoundException {
+ public static Class loadClass(String clazz, URL searchPath) throws ClassNotFoundException {
if (searchPath == null)
return Class.forName(clazz);
return createClassLoader(searchPath).loadClass(clazz);
@@ -1171,34 +1086,28 @@
/**
*
- * Laed eine Klasse derart das Klassen im Cache ignoriert werden. Dazu ist
- * es erforderlich das unter dem Parameter <code>searchPath</code> eine
- * Verzeichnis "META-INF" vorhanden ist. Darin muss eine Datei
- * "PREFERRED.LIST" sein. Wie genau diese Datei aufgebaut sein muss, lässt
- * sich in der Dokumentation des {@link PreferredClassLoader
+ * Laed eine Klasse derart das Klassen im Cache ignoriert werden. Dazu ist es erforderlich das unter dem Parameter
+ * <code>searchPath</code> eine Verzeichnis "META-INF" vorhanden ist. Darin muss eine Datei "PREFERRED.LIST" sein.
+ * Wie genau diese Datei aufgebaut sein muss, lässt sich in der Dokumentation des {@link PreferredClassLoader
* PreferredClassLoaders} nachlesen.
*
* @param classname
* Klassenname (inkl. Paket)
* @param searchPath
- * Pfad, in dem der ClassLoader nach Klassen sucht (wenn
- * <code>null</code>, wird der System-Klassenpfad
- * {@linkplain ClassLoader#getSystemResource(String)
- * ClassLoader.getSystemResource("")} zum Laden der Klasse
- * verwendet)
+ * Pfad, in dem der ClassLoader nach Klassen sucht (wenn <code>null</code>, wird der System-Klassenpfad
+ * {@linkplain ClassLoader#getSystemResource(String) ClassLoader.getSystemResource("")} zum Laden der
+ * Klasse verwendet)
* @throws ClassNotFoundException
* @see PreferredClassLoader
*
* @author Dominik Appl
*/
- public static Class loadPreferredClass(String classname, URL searchPath)
- throws ClassNotFoundException {
+ public static Class loadPreferredClass(String classname, URL searchPath) throws ClassNotFoundException {
if (searchPath == null)
// System-Klassenpfad verwenden
searchPath = ClassLoader.getSystemResource("");
- PreferredClassLoader classLoader = new PreferredClassLoader(
- new URL[] { searchPath }, Thread.currentThread()
- .getContextClassLoader(), null, false);
+ PreferredClassLoader classLoader = new PreferredClassLoader(new URL[] { searchPath }, Thread.currentThread()
+ .getContextClassLoader(), null, false);
Class loadedClass = classLoader.loadClass(classname);
if (loadedClass == null)
return Class.forName(classname);
@@ -1207,10 +1116,8 @@
}
/**
- * Laed eine Klasse neu und erzeugt eine Objekt-Instanz. Als Suchpfad fuer
- * die Klasse der System-Klassenpfad
- * {@linkplain ClassLoader#getSystemResource(String)
- * ClassLoader.getSystemResource("")} verwendet.
+ * Laed eine Klasse neu und erzeugt eine Objekt-Instanz. Als Suchpfad fuer die Klasse der System-Klassenpfad
+ * {@linkplain ClassLoader#getSystemResource(String) ClassLoader.getSystemResource("")} verwendet.
*
* @param classname
* Klassenname (inkl. Paket)
@@ -1229,18 +1136,15 @@
* @param classname
* Klassenname (inkl. Paket)
* @param searchPath
- * Pfad, in dem der ClassLoader nach Klassen sucht (wenn
- * <code>null</code>, wird der System-Klassenpfad
- * {@linkplain ClassLoader#getSystemResource(String)
- * ClassLoader.getSystemResource("")} zum Laden der Klasse
- * verwendet)
+ * Pfad, in dem der ClassLoader nach Klassen sucht (wenn <code>null</code>, wird der System-Klassenpfad
+ * {@linkplain ClassLoader#getSystemResource(String) ClassLoader.getSystemResource("")} zum Laden der
+ * Klasse verwendet)
* @param param
* Parameter fuer den Konstruktor-Aufruf
* @exception RuntimeException
* falls irgendein Fehler auftritt
*/
- public static Object loadPreferredObject(String classname, URL searchPath,
- Object... param) {
+ public static Object loadPreferredObject(String classname, URL searchPath, Object... param) {
try {
// Klasse laden
Class clazz = loadPreferredClass(classname, searchPath);
@@ -1261,16 +1165,14 @@
} catch (IllegalArgumentException err) {
}
// kein passender Konstruktor gefunden
- throw new UnsupportedOperationException(
- "No matching constructor found...");
+ throw new UnsupportedOperationException("No matching constructor found...");
} catch (Exception err) {
throw new RuntimeException(err);
}
}
/**
- * Liefert das Package einer Klasse erweitert um einen relativen Pfad in
- * Punkt-Notation.
+ * Liefert das Package einer Klasse erweitert um einen relativen Pfad in Punkt-Notation.
*
* @param clazz
* eine Klasse
@@ -1296,13 +1198,11 @@
*/
public static void checkIdentifierAndError(String identifier) {
if (!Character.isJavaIdentifierStart(identifier.charAt(0)))
- throw new IllegalArgumentException("Illegal first character '"
- + identifier.charAt(0) + "'");
+ throw new IllegalArgumentException("Illegal first character '" + identifier.charAt(0) + "'");
for (int i = 1; i < identifier.length(); i++) {
char c = identifier.charAt(i);
if (!Character.isJavaIdentifierPart(c))
- throw new IllegalArgumentException("Illegal inner character '"
- + c + "'");
+ throw new IllegalArgumentException("Illegal inner character '" + c + "'");
}
}
@@ -1323,8 +1223,7 @@
}
/**
- * Sortiert einen Array aus beliebigen Objekten nach der natuerlichen
- * Sortierung ihrer {@code toString()}-Werte.
+ * Sortiert einen Array aus beliebigen Objekten nach der natuerlichen Sortierung ihrer {@code toString()}-Werte.
*
* @param objects
* Objekte
@@ -1357,8 +1256,7 @@
}
/**
- * Returns the maximum value of some integer collections. If a collection is
- * empty, 0 is taken as its maximum value.
+ * Returns the maximum value of some integer collections. If a collection is empty, 0 is taken as its maximum value.
*
* @param collections
* some collections
@@ -1387,8 +1285,7 @@
}
/**
- * Returns the minimum value of some integer collections. If a collection is
- * empty, 0 is taken as its minimum value.
+ * Returns the minimum value of some integer collections. If a collection is empty, 0 is taken as its minimum value.
*
* @param collections
* some collections
@@ -1403,11 +1300,11 @@
* @param value
* Wert
* @param digits
- * Anzahl an Nachkommastellen (negative Werte runden auf
- * Vorkommastellen, also 10er-, 100er-, usw. Stelle)
+ * Anzahl an Nachkommastellen (negative Werte runden auf Vorkommastellen, also 10er-, 100er-, usw.
+ * Stelle)
* @param mode
- * Modus für das Runden (0 = normal Runden, 1 = Aufrunden, -1 =
- * Abrunden; wenn nicht angegeben, wird normal gerundet)
+ * Modus für das Runden (0 = normal Runden, 1 = Aufrunden, -1 = Abrunden; wenn nicht angegeben, wird
+ * normal gerundet)
*/
public static double round(double value, int digits, int... mode) {
int roundMode = 0; // Default: Normal-Runden
@@ -1431,27 +1328,23 @@
}
/**
- * Rundet alle Werte einer {@link Collection} auf Nach- oder
- * Vorkommastellen.<br>
+ * Rundet alle Werte einer {@link Collection} auf Nach- oder Vorkommastellen.<br>
* <b>Achtung:</b><br>
- * Es wird eine neue {@link Collection} des gleichen Typs erzeugt und die
- * gerundeten Werte darin in der Reihenfolge eingefuegt, wie sie von
- * {@link Collection#iterator()} geliefert werden! Unter umstaenden kann die
- * urspruengliche Sortierung verloren gehen! Diese Methode sollte also im
- * Zweifelsfall nur auf automatisch sortierte {@link Collection Collections}
- * angewandt werden (z.B. {@link TreeSet}).
+ * Es wird eine neue {@link Collection} des gleichen Typs erzeugt und die gerundeten Werte darin in der Reihenfolge
+ * eingefuegt, wie sie von {@link Collection#iterator()} geliefert werden! Unter umstaenden kann die urspruengliche
+ * Sortierung verloren gehen! Diese Methode sollte also im Zweifelsfall nur auf automatisch sortierte
+ * {@link Collection Collections} angewandt werden (z.B. {@link TreeSet}).
*
* @param values
* Werte
* @param digits
- * Anzahl an Nachkommastellen (negative Werte runden auf
- * Vorkommastellen, also 10er-, 100er-, usw. Stelle)
+ * Anzahl an Nachkommastellen (negative Werte runden auf Vorkommastellen, also 10er-, 100er-, usw.
+ * Stelle)
* @param mode
- * Modus für das Runden (0 = normal Runden, 1 = Aufrunden, -1 =
- * Abrunden; wenn nicht angegeben, wird normal gerundet)
+ * Modus für das Runden (0 = normal Runden, 1 = Aufrunden, -1 = Abrunden; wenn nicht angegeben, wird
+ * normal gerundet)
*/
- public static Collection<Number> round(Collection<Number> values,
- int digits, int... mode) {
+ public static Collection<Number> round(Collection<Number> values, int digits, int... mode) {
try {
Collection<Number> newCollection = values.getClass().newInstance();
for (Number value : values) {
@@ -1459,8 +1352,7 @@
}
return newCollection;
} catch (Exception err) {
- throw new IllegalArgumentException("Can not handle collection: "
- + getSimpleClassName(values), err);
+ throw new IllegalArgumentException("Can not handle collection: " + getSimpleClassName(values), err);
}
}
@@ -1478,17 +1370,14 @@
}
/**
- * Returns the class names of the top of a stack trace. Duplicate class
- * names are eliminated.
+ * Returns the class names of the top of a stack trace. Duplicate class names are eliminated.
*
* @param stackTrace
* stack trace to explore
* @param depth
- * maximum count of classes, which are explored in the stack
- * trace
+ * maximum count of classes, which are explored in the stack trace
*/
- public static String[] getLastStackTraceClasses(
- StackTraceElement[] stackTrace, int depth) {
+ public static String[] getLastStackTraceClasses(StackTraceElement[] stackTrace, int depth) {
Vector<String> lastClasses = new Vector<String>();
for (StackTraceElement st : stackTrace) {
String className = st.getClassName();
@@ -1506,13 +1395,11 @@
* @param stackTrace
* stack trace to explore
* @param depth
- * maximum count of classes, which are explored in the stack
- * trace
+ * maximum count of classes, which are explored in the stack trace
* @param out
* output stream to write to
*/
- public static void printLastStackTraceClasses(
- StackTraceElement[] stackTrace, int depth, PrintStream out) {
+ public static void printLastStackTraceClasses(StackTraceElement[] stackTrace, int depth, PrintStream out) {
String[] lastClasses = getLastStackTraceClasses(stackTrace, depth);
for (int i = 0; i < lastClasses.length; i++) {
if (i > 0)
@@ -1527,27 +1414,22 @@
* @param stackTrace
* stack trace to explore
* @param depth
- * maximum count of classes, which are explored in the stack
- * trace
+ * maximum count of classes, which are explored in the stack trace
* @see System#out
*/
- public static void printLastStackTraceClasses(
- StackTraceElement[] stackTrace, int depth) {
+ public static void printLastStackTraceClasses(StackTraceElement[] stackTrace, int depth) {
printLastStackTraceClasses(stackTrace, depth, System.out);
}
/**
- * Initializes the {@link Logger} (root logger) with a default
- * {@link ConsoleAppender}. This method does nothing when the root logger
- * already contains an appender, so it does not matter when this method is
- * called twice or more.
+ * Initializes the {@link Logger} (root logger) with a default {@link ConsoleAppender}. This method does nothing
+ * when the root logger already contains an appender, so it does not matter when this method is called twice or
+ * more.
*
* @param logLevel
- * log level (if {@code null} the level {@link Level#DEBUG} is
- * used)
+ * log level (if {@code null} the level {@link Level#DEBUG} is used)
* @param logPattern
- * pattern for the console output (if {@code null} a default
- * pattern "%r\t%p\t%c\t%m%n" is used)
+ * pattern for the console output (if {@code null} a default pattern "%r\t%p\t%c\t%m%n" is used)
*/
public static void initializeDefaultLogger(Level logLevel, String logPattern) {
// Diry-code by Steve:
@@ -1581,13 +1463,12 @@
}
/**
- * Erzeugt einen Log4j-Logger fuer ein Objekt. Als Identifier fuer den
- * Logger wird der Klassenname des Objekts verwendet.
+ * Erzeugt einen Log4j-Logger fuer ein Objekt. Als Identifier fuer den Logger wird der Klassenname des Objekts
+ * verwendet.
*
* @param object
* ein Objekt
- * @return Logger mit dem Namen "NULL", falls das uebergebene Objekt
- * {@code null} ist
+ * @return Logger mit dem Namen "NULL", falls das uebergebene Objekt {@code null} ist
*/
public static Logger createLogger(Object object) {
if (object == null)
@@ -1598,15 +1479,13 @@
}
/**
- * Erzeugt einen Error- und einen Debug-Eintrag in einem Logger. Der
- * Error-Eintrag erhaelt nur die Meldung, der Debug-Eintrag auch die
- * detaillierten Informationen des Fehlers.
+ * Erzeugt einen Error- und einen Debug-Eintrag in einem Logger. Der Error-Eintrag erhaelt nur die Meldung, der
+ * Debug-Eintrag auch die detaillierten Informationen des Fehlers.
*
* @param logger
* ein Logger
* @param mess
- * Fehlermeldung (wenn {@code null} wird die Message des Fehlers
- * ausgegeben)
+ * Fehlermeldung (wenn {@code null} wird die Message des Fehlers ausgegeben)
* @param err
* ein Fehler
*/
@@ -1618,9 +1497,8 @@
}
/**
- * Erzeugt einen Error- und einen Debug-Eintrag in einem Logger. Der
- * Error-Eintrag erhaelt nur die Meldung, der Debug-Eintrag auch die
- * detaillierten Informationen des Fehlers.
+ * Erzeugt einen Error- und einen Debug-Eintrag in einem Logger. Der Error-Eintrag erhaelt nur die Meldung, der
+ * Debug-Eintrag auch die detaillierten Informationen des Fehlers.
*
* @param logger
* ein Logger
@@ -1632,15 +1510,13 @@
}
/**
- * Erzeugt einen Warn- und einen Debug-Eintrag in einem Logger. Der
- * Warn-Eintrag erhaelt nur die Meldung, der Debug-Eintrag auch die
- * detaillierten Informationen des Fehlers.
+ * Erzeugt einen Warn- und einen Debug-Eintrag in einem Logger. Der Warn-Eintrag erhaelt nur die Meldung, der
+ * Debug-Eintrag auch die detaillierten Informationen des Fehlers.
*
* @param logger
* ein Logger
* @param mess
- * Fehlermeldung (wenn {@code null} wird die Message des Fehlers
- * ausgegeben)
+ * Fehlermeldung (wenn {@code null} wird die Message des Fehlers ausgegeben)
* @param err
* ein Fehler
*/
@@ -1652,9 +1528,8 @@
}
/**
- * Erzeugt einen Warn- und einen Debug-Eintrag in einem Logger. Der
- * Warn-Eintrag erhaelt nur die Meldung, der Debug-Eintrag auch die
- * detaillierten Informationen des Fehlers.
+ * Erzeugt einen Warn- und einen Debug-Eintrag in einem Logger. Der Warn-Eintrag erhaelt nur die Meldung, der
+ * Debug-Eintrag auch die detaillierten Informationen des Fehlers.
*
* @param logger
* ein Logger
@@ -1673,11 +1548,9 @@
* @param stackTrace
* stack trace to explore
* @param depth
- * maximum count of classes, which are explored in the stack
- * trace
+ * maximum count of classes, which are explored in the stack trace
*/
- public static void logDebugLastStackTraceClasses(Category logger,
- StackTraceElement[] stackTrace, int depth) {
+ public static void logDebugLastStackTraceClasses(Category logger, StackTraceElement[] stackTrace, int depth) {
String[] lastClasses = getLastStackTraceClasses(stackTrace, depth);
for (int i = 0; i < lastClasses.length; i++) {
String message = "";
@@ -1694,8 +1567,7 @@
* @param numClass
* TODO Martin, geht das nicht schöner? Ich bin zu doof
*/
- public static Number parseNumberAs(final String valueString,
- final Class<?> numClass) {
+ public static Number parseNumberAs(final String valueString, final Class<?> numClass) {
if (StringUtils.trimToNull(valueString) == null)
return null;
@@ -1716,9 +1588,8 @@
} else if (numClass == Float.class) {
return doubleValue.floatValue();
} else {
- throw new RuntimeException(
- "Please report that parseNumberAs has to support variables of type "
- + numClass.getCanonicalName());
+ throw new RuntimeException("Please report that parseNumberAs has to support variables of type "
+ + numClass.getCanonicalName());
}
}
@@ -1736,8 +1607,7 @@
}
/**
- * Interpretiert einen {@link String} zu einem {@link boolean} mit default
- * <code>true</code>.
+ * Interpretiert einen {@link String} zu einem {@link boolean} mit default <code>true</code>.
*/
public static boolean parseStringDefaultTrue(String str) {
if (str == null)
@@ -1751,8 +1621,7 @@
}
/**
- * Interpretiert einen {@link String} zu einem {@link boolean} mit default
- * <code>null</code>.
+ * Interpretiert einen {@link String} zu einem {@link boolean} mit default <code>null</code>.
*/
public static Boolean parseStringDefaultNull(String str) {
if (str == null)
@@ -1772,8 +1641,7 @@
}
/**
- * Interpretiert einen {@link String} zu einem {@link boolean} mit default
- * <code>false</code>.
+ * Interpretiert einen {@link String} zu einem {@link boolean} mit default <code>false</code>.
*/
public static boolean parseStringDefaultFalse(String str) {
if (str == null)
@@ -1789,8 +1657,7 @@
}
/**
- * Removes leading and tailing "\n" newline commands. Very similar:
- * StringUtils.trimToEmpty(string);
+ * Removes leading and tailing "\n" newline commands. Very similar: StringUtils.trimToEmpty(string);
*
* @param string
* return <code>null</code> if <code>null</code> is passed.
@@ -1824,12 +1691,10 @@
}
/**
- * Kann verwendet werden, um einen String von XML/HTML Tags zu säubern.
- * Rückgabe ist ein ein String ohne Tags. Mehr als 2 Leerzeichen werden zu
- * einem Leerzeichen. Am Ende und Anfang nie Leerzeichen. Ein <li>wird zu
- * einem * um die Lesbarkeit als Rein-Text zu verbessern.<br/>
- * Die Methode basiert auf RegEx. Es wird also kein valides oder
- * wellformed-XML erwartet.
+ * Kann verwendet werden, um einen String von XML/HTML Tags zu säubern. Rückgabe ist ein ein String ohne Tags. Mehr
+ * als 2 Leerzeichen werden zu einem Leerzeichen. Am Ende und Anfang nie Leerzeichen. Ein <li>wird zu einem * um die
+ * Lesbarkeit als Rein-Text zu verbessern.<br/>
+ * Die Methode basiert auf RegEx. Es wird also kein valides oder wellformed-XML erwartet.
*/
public static String removeTags(String withTags) {
String withoutTags = withTags;
@@ -1842,4 +1707,37 @@
return withoutTags.trim();
}
+
+ /**
+ * Liefert einen String zurück, der zeigt, wo die RegEx im String getroffen hat. Der getroffene Bereich wird
+ * +-$border Zeichen ausgeschnitten und GROSS geschrieben. <br/>
+ * Beispiele:
+ * <ul>
+ * <li>assertEquals("abcBAUMdef", LangUtil.regExBereich("abcBaumdef", "Baum", 115)); <br/>
+ * <li>assertEquals("5BAUM6", LangUtil.regExBereich("12345Baum67890", "Baum", 1));
+ */
+ static public String regExBereich(String value, String regex, int border) {
+
+ if (border < 0)
+ throw new IllegalStateException("border may not be smaller 0!");
+
+ if (regex.startsWith("^"))
+ regex = regex.substring(1);
+
+ String r2 = ".*(" + regex + ").*";
+ Pattern compile = Pattern.compile(r2);
+ Matcher matcher = compile.matcher(value);
+ if (!matcher.find())
+ return "";
+
+ int start = matcher.start(1);
+ final String treffer = matcher.group(1);
+
+ int s2 = Math.min(start, border);
+ String vorher = value.substring(start - s2, start);
+
+ String nachher = value.substring(matcher.end(1), Math.min(matcher.end(1) + border, value.length()));
+
+ return vorher.toLowerCase() + treffer.toUpperCase() + nachher.toLowerCase();
+ }
}
Modified: trunk/schmitzm-core/src/main/java/de/schmitzm/versionnumber/ReleaseUtil.java
===================================================================
--- trunk/schmitzm-core/src/main/java/de/schmitzm/versionnumber/ReleaseUtil.java 2011-05-12 15:20:20 UTC (rev 1579)
+++ trunk/schmitzm-core/src/main/java/de/schmitzm/versionnumber/ReleaseUtil.java 2011-05-15 16:46:20 UTC (rev 1580)
@@ -54,7 +54,7 @@
build=${buildNumber}
activeProfile1Id=${project.activeProfiles[0].id}
activeProfile2Id=${project.activeProfiles[1].id}
- activeProfile3Id=${project.activeProfiles[3].id}
+ activeProfile3Id=${project.activeProfiles[2].id}
</code><br/>
* 3. Filtering für die src/main/resources.properties - Datei
* einschalten:<code>
Modified: trunk/schmitzm-core/src/test/java/de/schmitzm/lang/LangUtilTest.java
===================================================================
--- trunk/schmitzm-core/src/test/java/de/schmitzm/lang/LangUtilTest.java 2011-05-12 15:20:20 UTC (rev 1579)
+++ trunk/schmitzm-core/src/test/java/de/schmitzm/lang/LangUtilTest.java 2011-05-15 16:46:20 UTC (rev 1580)
@@ -93,8 +93,7 @@
}
@Test
- public void testRemoveNulls_Integer()
- {
+ public void testRemoveNulls_Integer() {
Integer[] withNuller = new Integer[] { 3, null, 5, null };
Integer[] withOutNulls = LangUtil.removeNulls(withNuller);
assertEquals(2, withOutNulls.length);
@@ -112,14 +111,28 @@
}
@Test
- public void testRemoveTags()
- {
- assertEquals("hallo welt",LangUtil.removeTags("<h1>hallo<br/>welt</h1>"));
- assertEquals("hallo welt",LangUtil.removeTags("<h1>hallo<td/><td>welt</h1>"));
- assertEquals("hallo welt",LangUtil.removeTags("<h1>hallo<td/> <td>welt</h1>"));
- assertEquals("hallo welt",LangUtil.removeTags("<h1>hallo<td/> \n <td image='asdasdasa'>welt</h1>"));
- assertEquals("hallo *asd welt",LangUtil.removeTags("<h1>hallo<td/><li>asd</li><td image='asdasdasa'>welt</h1>"));
- assertEquals("hallo welt",LangUtil.removeTags("<h1 time='as'>hallo<td/> \n <td image='asdasdasa'>welt</h1>"));
+ public void testRemoveTags() {
+ assertEquals("hallo welt", LangUtil.removeTags("<h1>hallo<br/>welt</h1>"));
+ assertEquals("hallo welt", LangUtil.removeTags("<h1>hallo<td/><td>welt</h1>"));
+ assertEquals("hallo welt", LangUtil.removeTags("<h1>hallo<td/> <td>welt</h1>"));
+ assertEquals("hallo welt", LangUtil.removeTags("<h1>hallo<td/> \n <td image='asdasdasa'>welt</h1>"));
+ assertEquals("hallo *asd welt",
+ LangUtil.removeTags("<h1>hallo<td/><li>asd</li><td image='asdasdasa'>welt</h1>"));
+ assertEquals("hallo welt", LangUtil.removeTags("<h1 time='as'>hallo<td/> \n <td image='asdasdasa'>welt</h1>"));
}
+ @Test
+ public void testRegExBereich() {
+ assertEquals("BAUM", LangUtil.regExBereich("Baum", "Baum", 5));
+ assertEquals("BAUM", LangUtil.regExBereich("Baum", "^Baum", 5));
+ assertEquals("23BAUM", LangUtil.regExBereich("123Baum", "Baum$", 2));
+ assertEquals("12345BAUM67890", LangUtil.regExBereich("12345Baum67890", "Baum", 5));
+ assertEquals("12345BAUM67890", LangUtil.regExBereich("12345Baum67890", "Baum", 115));
+ assertEquals("abcBAUMdef", LangUtil.regExBereich("abcBaumdef", "Baum", 115));
+ assertEquals("5BAUM6", LangUtil.regExBereich("12345Baum67890", "Baum", 1));
+
+ assertEquals("er BAUM zu",
+ LangUtil.regExBereich("Am Ender der Absperrung war ein großer Baum zu sehen", "Baum", 3));
+
+ }
}
\ No newline at end of file
More information about the Schmitzm-commits
mailing list