[Schmitzm-commits] r1474 - in trunk/schmitzm-core/src: main/java/de/schmitzm/temp test/java/de/schmitzm/lang
scm-commit@wald.intevation.org
scm-commit at wald.intevation.org
Sun Jan 30 02:00:22 CET 2011
Author: alfonx
Date: 2011-01-30 02:00:22 +0100 (Sun, 30 Jan 2011)
New Revision: 1474
Modified:
trunk/schmitzm-core/src/main/java/de/schmitzm/temp/BaseTypeUtil.java
trunk/schmitzm-core/src/test/java/de/schmitzm/lang/ResourceProviderTest.java
Log:
Strg-F, JavaDoc
Modified: trunk/schmitzm-core/src/main/java/de/schmitzm/temp/BaseTypeUtil.java
===================================================================
--- trunk/schmitzm-core/src/main/java/de/schmitzm/temp/BaseTypeUtil.java 2011-01-29 23:55:28 UTC (rev 1473)
+++ trunk/schmitzm-core/src/main/java/de/schmitzm/temp/BaseTypeUtil.java 2011-01-30 01:00:22 UTC (rev 1474)
@@ -29,434 +29,500 @@
******************************************************************************/
package de.schmitzm.temp;
+import de.schmitzm.data.property.Properties;
+
// nur fuer Doku
/**
- * Diese Klasse stellt statische Methoden zur Arbeit mit BaseTypes bereit.
- * Mit BaseTypes sind folgende Klassen und Build-In-Types gemeint:
- * <table align=center border=2 cellpadding=5><code>
+ * Diese Klasse stellt statische Methoden zur Arbeit mit BaseTypes bereit. Mit
+ * BaseTypes sind folgende Klassen und Build-In-Types gemeint:
+ * <table align=center border=2 cellpadding=5>
+ * <code>
* <tr><th>Klasse</th><th>entsprechender Build-In-Type</th></tr>
- * <tr><td><code>java.lang.Byte</code></td><td><code>byte.class</code></td></tr>
- * <tr><td><code>java.lang.Short</code></td><td><code>short.class</code></td></tr>
- * <tr><td><code>java.lang.Integer</code></td><td><code>int.class</code></td></tr>
- * <tr><td><code>java.lang.Long</code></td><td><code>long.class</code></td></tr>
- * <tr><td><code>java.lang.Float</code></td><td><code>float.class</code></td></tr>
- * <tr><td><code>java.lang.Double</code></td><td><code>double.class</code></td></tr>
- * <tr><td><code>java.lang.Boolean</code></td><td><code>boolen.class</code></td></tr>
- * <tr><td><code>java.lang.Character</code></td><td><code>char.class</code></td></tr>
- * <tr><td><code>java.lang.String</code></td><td>---</td></tr>
+ * <tr><td><code>java.lang.Byte</code></td>
+ * <td><code>byte.class</code></td></tr>
+ * <tr>
+ * <td><code>java.lang.Short</code></td>
+ * <td><code>short.class</code></td>
+ * </tr>
+ * <tr>
+ * <td><code>java.lang.Integer</code></td>
+ * <td><code>int.class</code></td>
+ * </tr>
+ * <tr>
+ * <td><code>java.lang.Long</code></td>
+ * <td><code>long.class</code></td>
+ * </tr>
+ * <tr>
+ * <td><code>java.lang.Float</code></td>
+ * <td><code>float.class</code></td>
+ * </tr>
+ * <tr>
+ * <td><code>java.lang.Double</code></td>
+ * <td><code>double.class</code></td>
+ * </tr>
+ * <tr>
+ * <td><code>java.lang.Boolean</code></td>
+ * <td><code>boolen.class</code></td>
+ * </tr>
+ * <tr>
+ * <td><code>java.lang.Character</code></td>
+ * <td><code>char.class</code></td>
+ * </tr>
+ * <tr>
+ * <td><code>java.lang.String</code></td>
+ * <td>---</td>
+ * </tr>
* </table>
* <br>
- * Seit JDK 1.5 koennen Build-In-Types auch als Objekte behandelt werden.
- * Diese Klasse stellt Methoden zur Kompatibilitaet zur Verfuegung.<br>
+ * Seit JDK 1.5 koennen Build-In-Types auch als Objekte behandelt werden. Diese
+ * Klasse stellt Methoden zur Kompatibilitaet zur Verfuegung.<br>
* Die Methoden basieren jedoch sehr auf statischen Fallunterscheidungen!
- * Deshalb sollen sie nur als voruebergehende Notloesung dienen und zu
- * gegebener Zeit durch bessere (und u.U. effizientere Methoden) ersetzt werden.
- * <br><br>
+ * Deshalb sollen sie nur als voruebergehende Notloesung dienen und zu gegebener
+ * Zeit durch bessere (und u.U. effizientere Methoden) ersetzt werden. <br>
+ * <br>
* Zur Zeit basieren folgende Methoden auf dieser Klasse:
* <ul>
* <li>{@link schmitzm.data.property.PropertyType#isValid(Class)}<br>
- * Check: Eine BaseType-Objekt ist auch gueltig fuer eine Build-in-Property</li>
+ * Check: Eine BaseType-Objekt ist auch gueltig fuer eine Build-in-Property</li>
* <li>{@link schmitzm.data.property.ValuePropertyType#isValid(Class)}<br>
- * Check: Um welche Art von BaseType handelt es sich</li>
- * <li>{@link schmitzm.dipl.xulu.plugin.gui.DisplayContainer_Properties.PropertiesTableModel#isCellEditable(int,int)}<br>
- * Check auf BaseType (nur diese Zellen sind editierbar).</li>
- * <li>{@link schmitzm.dipl.xulu.plugin.gui.DisplayContainer_Properties.PropertiesTableModel#setValueAt(Object,int,int)}<br>
- * Umwandlung von String in Basistyp.</li>
- * <li>{@link schmitzm.dipl.xulu.plugin.io.misc.DynamicXuluObjectFactory_BasicStructure#createProperty()}<br>
- * Umwandlung von String in Basistyp.</li>
+ * Check: Um welche Art von BaseType handelt es sich</li>
+ * <li>
+ * {@link schmitzm.dipl.xulu.plugin.gui.DisplayContainer_Properties.PropertiesTableModel#isCellEditable(int,int)}
+ * <br>
+ * Check auf BaseType (nur diese Zellen sind editierbar).</li>
+ * <li>
+ * {@link schmitzm.dipl.xulu.plugin.gui.DisplayContainer_Properties.PropertiesTableModel#setValueAt(Object,int,int)}
+ * <br>
+ * Umwandlung von String in Basistyp.</li>
+ * <li>
+ * {@link schmitzm.dipl.xulu.plugin.io.misc.DynamicXuluObjectFactory_BasicStructure#createProperty()}
+ * <br>
+ * Umwandlung von String in Basistyp.</li>
* <li>{@link schmitzm.dipl.xulu.plugin.model.TestModel.ContentManager}<br>
- * Pruefen, ob Property einen numerischen Integer/Long beinhaltet.</li>
- * <li>{@link schmitzm.dipl.test.NumericMinMaxConstraint#isSatisfiedFor(Properties)}<br>
- * Pruefen, ob Property einen numerischen Wert beinhaltet.</li>
+ * Pruefen, ob Property einen numerischen Integer/Long beinhaltet.</li>
+ * <li>
+ * {@link schmitzm.dipl.test.NumericMinMaxConstraint#isSatisfiedFor(Properties)}
+ * <br>
+ * Pruefen, ob Property einen numerischen Wert beinhaltet.</li>
* </ul>
- * @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 BaseTypeUtil {
- /**
- * Prueft, ob die angegebene Klasse einen Build-In-Type darstellt. Dies sind
- * alle Typen, die oben in der rechten Spalte angegeben sind.
- */
- public static boolean isBuildInType(Class c) {
- return c.equals(short.class) ||
- c.equals(byte.class) ||
- c.equals(int.class) ||
- c.equals(long.class) ||
- c.equals(float.class) ||
- c.equals(double.class) ||
- c.equals(char.class) ||
- c.equals(boolean.class);
- }
+ /**
+ * Prueft, ob die angegebene Klasse einen Build-In-Type darstellt. Dies sind
+ * alle Typen, die oben in der rechten Spalte angegeben sind.
+ */
+ public static boolean isBuildInType(Class c) {
+ return c.equals(short.class) || c.equals(byte.class)
+ || c.equals(int.class) || c.equals(long.class)
+ || c.equals(float.class) || c.equals(double.class)
+ || c.equals(char.class) || c.equals(boolean.class);
+ }
- /**
- * Prueft, ob das angegebene Objekt einen Build-In-Type darstellt. Dies sind
- * alle Typen, die oben in der rechten Spalte angegeben sind.
- * @return <code>false</code>, wenn das angegebene Objekt <code>null</code> ist
- */
- public static boolean isBuildInType(Object o) {
- return o!=null && isBuildInType(o.getClass());
- }
+ /**
+ * Prueft, ob das angegebene Objekt einen Build-In-Type darstellt. Dies sind
+ * alle Typen, die oben in der rechten Spalte angegeben sind.
+ *
+ * @return <code>false</code>, wenn das angegebene Objekt <code>null</code>
+ * ist
+ */
+ public static boolean isBuildInType(Object o) {
+ return o != null && isBuildInType(o.getClass());
+ }
+ /**
+ * Prueft, ob die angegebene Klasse eine 8-bit-Ganzzahl darstellt. Also
+ * entweder <code>byte.class</code> oder <code>java.lang.Byte</code>.
+ */
+ public static boolean isByte(Class c) {
+ return c.equals(byte.class) || Byte.class.isAssignableFrom(c);
+ }
- /**
- * Prueft, ob die angegebene Klasse eine 8-bit-Ganzzahl darstellt.
- * Also entweder <code>byte.class</code> oder <code>java.lang.Byte</code>.
- */
- public static boolean isByte(Class c) {
- return c.equals(byte.class) || Byte.class.isAssignableFrom(c);
- }
+ /**
+ * Prueft, ob das angegebene Objekt eine 8-bit-Ganzzahl darstellt. Also
+ * entweder eine Instanz von <code>byte.class</code> oder
+ * <code>java.lang.Byte</code> ist.
+ *
+ * @return <code>false</code>, wenn das angegebene Objekt <code>null</code>
+ * ist
+ */
+ public static boolean isByte(Object o) {
+ return o != null && isByte(o.getClass());
+ }
- /**
- * Prueft, ob das angegebene Objekt eine 8-bit-Ganzzahl darstellt.
- * Also entweder eine Instanz von <code>byte.class</code> oder
- * <code>java.lang.Byte</code> ist.
- * @return <code>false</code>, wenn das angegebene Objekt <code>null</code> ist
- */
- public static boolean isByte(Object o) {
- return o!=null && isByte(o.getClass());
- }
+ /**
+ * Prueft, ob die angegebene Klasse eine 16-bit-Ganzzahl darstellt. Also
+ * entweder <code>short.class</code> oder <code>java.lang.Short</code>.
+ */
+ public static boolean isShort(Class c) {
+ return c.equals(short.class) || Short.class.isAssignableFrom(c);
+ }
- /**
- * Prueft, ob die angegebene Klasse eine 16-bit-Ganzzahl darstellt.
- * Also entweder <code>short.class</code> oder <code>java.lang.Short</code>.
- */
- public static boolean isShort(Class c) {
- return c.equals(short.class) || Short.class.isAssignableFrom(c);
- }
+ /**
+ * Prueft, ob das angegebene Objekt eine 16-bit-Ganzzahl darstellt. Also
+ * entweder eine Instanz von <code>short.class</code> oder
+ * <code>java.lang.Short</code> ist.
+ *
+ * @return <code>false</code>, wenn das angegebene Objekt <code>null</code>
+ * ist
+ */
+ public static boolean isShort(Object o) {
+ return o != null && isShort(o.getClass());
+ }
- /**
- * Prueft, ob das angegebene Objekt eine 16-bit-Ganzzahl darstellt.
- * Also entweder eine Instanz von <code>short.class</code> oder
- * <code>java.lang.Short</code> ist.
- * @return <code>false</code>, wenn das angegebene Objekt <code>null</code> ist
- */
- public static boolean isShort(Object o) {
- return o!=null && isShort(o.getClass());
- }
+ /**
+ * Prueft, ob die angegebene Klasse eine 32-bit-Ganzzahl darstellt. Also
+ * entweder <code>int.class</code> oder <code>java.lang.Integer</code>.
+ */
+ public static boolean isInteger(Class c) {
+ return c.equals(int.class) || Integer.class.isAssignableFrom(c);
+ }
- /**
- * Prueft, ob die angegebene Klasse eine 32-bit-Ganzzahl darstellt.
- * Also entweder <code>int.class</code> oder <code>java.lang.Integer</code>.
- */
- public static boolean isInteger(Class c) {
- return c.equals(int.class) || Integer.class.isAssignableFrom(c);
- }
+ /**
+ * Prueft, ob das angegebene Objekt eine 32-bit-Ganzzahl darstellt. Also
+ * entweder eine Instanz von <code>int.class</code> oder
+ * <code>java.lang.Integer</code> ist.
+ *
+ * @return <code>false</code>, wenn das angegebene Objekt <code>null</code>
+ * ist
+ */
+ public static boolean isInteger(Object o) {
+ return o != null && isInteger(o.getClass());
+ }
- /**
- * Prueft, ob das angegebene Objekt eine 32-bit-Ganzzahl darstellt.
- * Also entweder eine Instanz von <code>int.class</code> oder
- * <code>java.lang.Integer</code> ist.
- * @return <code>false</code>, wenn das angegebene Objekt <code>null</code> ist
- */
- public static boolean isInteger(Object o) {
- return o!=null && isInteger(o.getClass());
- }
+ /**
+ * Prueft, ob die angegebene Klasse eine 64-bit-Ganzzahl darstellt. Also
+ * entweder <code>long.class</code> oder <code>java.lang.Long</code>.
+ */
+ public static boolean isLong(Class c) {
+ return c.equals(long.class) || Long.class.isAssignableFrom(c);
+ }
- /**
- * Prueft, ob die angegebene Klasse eine 64-bit-Ganzzahl darstellt.
- * Also entweder <code>long.class</code> oder <code>java.lang.Long</code>.
- */
- public static boolean isLong(Class c) {
- return c.equals(long.class) || Long.class.isAssignableFrom(c);
- }
+ /**
+ * Prueft, ob das angegebene Objekt eine 64-bit-Ganzzahl darstellt. Also
+ * entweder eine Instanz von <code>long.class</code> oder
+ * <code>java.lang.Long</code> ist.
+ *
+ * @return <code>false</code>, wenn das angegebene Objekt <code>null</code>
+ * ist
+ */
+ public static boolean isLong(Object o) {
+ return o != null && isLong(o.getClass());
+ }
- /**
- * Prueft, ob das angegebene Objekt eine 64-bit-Ganzzahl darstellt.
- * Also entweder eine Instanz von <code>long.class</code> oder
- * <code>java.lang.Long</code> ist.
- * @return <code>false</code>, wenn das angegebene Objekt <code>null</code> ist
- */
- public static boolean isLong(Object o) {
- return o!=null && isLong(o.getClass());
- }
+ /**
+ * Prueft, ob die angegebene Klasse eine 32-bit-Gleitkommazahl darstellt.
+ * Also entweder <code>float.class</code> oder <code>java.lang.Float</code>.
+ */
+ public static boolean isFloat(Class c) {
+ return c.equals(float.class) || Float.class.isAssignableFrom(c);
+ }
- /**
- * Prueft, ob die angegebene Klasse eine 32-bit-Gleitkommazahl darstellt.
- * Also entweder <code>float.class</code> oder <code>java.lang.Float</code>.
- */
- public static boolean isFloat(Class c) {
- return c.equals(float.class) || Float.class.isAssignableFrom(c);
- }
+ /**
+ * Prueft, ob das angegebene Objekt eine 32-bit-Gleitkommazahl darstellt.
+ * Also entweder eine Instanz von <code>float.class</code> oder
+ * <code>java.lang.Float</code> ist.
+ *
+ * @return <code>false</code>, wenn das angegebene Objekt <code>null</code>
+ * ist
+ */
+ public static boolean isFloat(Object o) {
+ return o != null && isFloat(o.getClass());
+ }
- /**
- * Prueft, ob das angegebene Objekt eine 32-bit-Gleitkommazahl darstellt.
- * Also entweder eine Instanz von <code>float.class</code> oder
- * <code>java.lang.Float</code> ist.
- * @return <code>false</code>, wenn das angegebene Objekt <code>null</code> ist
- */
- public static boolean isFloat(Object o) {
- return o!=null && isFloat(o.getClass());
- }
+ /**
+ * Prueft, ob die angegebene Klasse eine 64-bit-Gleitkommazahl darstellt.
+ * Also entweder <code>double.class</code> oder
+ * <code>java.lang.Couble</code>.
+ */
+ public static boolean isDouble(Class c) {
+ return c.equals(double.class) || Double.class.isAssignableFrom(c);
+ }
- /**
- * Prueft, ob die angegebene Klasse eine 64-bit-Gleitkommazahl darstellt.
- * Also entweder <code>double.class</code> oder <code>java.lang.Couble</code>.
- */
- public static boolean isDouble(Class c) {
- return c.equals(double.class) || Double.class.isAssignableFrom(c);
- }
+ /**
+ * Prueft, ob das angegebene Objekt eine 64-bit-Gleitkommazahl darstellt.
+ * Also entweder eine Instanz von <code>double.class</code> oder
+ * <code>java.lang.Double</code> ist.
+ *
+ * @return <code>false</code>, wenn das angegebene Objekt <code>null</code>
+ * ist
+ */
+ public static boolean isDouble(Object o) {
+ return o != null && isDouble(o.getClass());
+ }
- /**
- * Prueft, ob das angegebene Objekt eine 64-bit-Gleitkommazahl darstellt.
- * Also entweder eine Instanz von <code>double.class</code> oder
- * <code>java.lang.Double</code> ist.
- * @return <code>false</code>, wenn das angegebene Objekt <code>null</code> ist
- */
- public static boolean isDouble(Object o) {
- return o!=null && isDouble(o.getClass());
- }
+ /**
+ * Prueft, ob die angegebene Klasse einen boolschen Wert darstellt. Also
+ * entweder <code>boolean.class</code> oder <code>java.lang.Boolean</code>.
+ */
+ public static boolean isBoolean(Class c) {
+ return c.equals(boolean.class) || Boolean.class.isAssignableFrom(c);
+ }
- /**
- * Prueft, ob die angegebene Klasse einen boolschen Wert darstellt.
- * Also entweder <code>boolean.class</code> oder <code>java.lang.Boolean</code>.
- */
- public static boolean isBoolean(Class c) {
- return c.equals(boolean.class) || Boolean.class.isAssignableFrom(c);
- }
+ /**
+ * Prueft, ob das angegebene Objekt einen boolschen Wert darstellt. Also
+ * entweder eine Instanz von <code>boolean.class</code> oder
+ * <code>java.lang.Boolean</code> ist.
+ *
+ * @return <code>false</code>, wenn das angegebene Objekt <code>null</code>
+ * ist
+ */
+ public static boolean isBoolean(Object o) {
+ return o != null && isBoolean(o.getClass());
+ }
- /**
- * Prueft, ob das angegebene Objekt einen boolschen Wert darstellt.
- * Also entweder eine Instanz von <code>boolean.class</code> oder
- * <code>java.lang.Boolean</code> ist.
- * @return <code>false</code>, wenn das angegebene Objekt <code>null</code> ist
- */
- public static boolean isBoolean(Object o) {
- return o!=null && isBoolean(o.getClass());
- }
+ /**
+ * Prueft, ob die angegebene Klasse ein Zeichen darstellt. Also entweder
+ * <code>char.class</code> oder <code>java.lang.Character</code>.
+ */
+ public static boolean isCharacter(Class c) {
+ return c.equals(char.class) || Character.class.isAssignableFrom(c);
+ }
- /**
- * Prueft, ob die angegebene Klasse ein Zeichen darstellt.
- * Also entweder <code>char.class</code> oder <code>java.lang.Character</code>.
- */
- public static boolean isCharacter(Class c) {
- return c.equals(char.class) || Character.class.isAssignableFrom(c);
- }
+ /**
+ * Prueft, ob das angegebene Objekt ein Zeichen darstellt. Also entweder
+ * eine Instanz von <code>char.class</code> oder
+ * <code>java.lang.Character</code> ist.
+ *
+ * @return <code>false</code>, wenn das angegebene Objekt <code>null</code>
+ * ist
+ */
+ public static boolean isCharacter(Object o) {
+ return o != null && isCharacter(o.getClass());
+ }
- /**
- * Prueft, ob das angegebene Objekt ein Zeichen darstellt.
- * Also entweder eine Instanz von <code>char.class</code> oder
- * <code>java.lang.Character</code> ist.
- * @return <code>false</code>, wenn das angegebene Objekt <code>null</code> ist
- */
- public static boolean isCharacter(Object o) {
- return o!=null && isCharacter(o.getClass());
- }
+ /**
+ * Prueft, ob die angegebene Klasse eine Zeichenkette darstellt. Also
+ * <code>java.lang.String</code>.
+ */
+ public static boolean isString(Class c) {
+ return String.class.isAssignableFrom(c);
+ }
- /**
- * Prueft, ob die angegebene Klasse eine Zeichenkette darstellt.
- * Also <code>java.lang.String</code>.
- */
- public static boolean isString(Class c) {
- return String.class.isAssignableFrom(c);
- }
+ /**
+ * Prueft, ob das angegebene Objekt eine Zeichenkette darstellt. Also eine
+ * Instanz von <code>java.lang.String</code> ist.
+ *
+ * @return <code>false</code>, wenn das angegebene Objekt <code>null</code>
+ * ist
+ */
+ public static boolean isString(Object o) {
+ return o != null && isString(o.getClass());
+ }
- /**
- * Prueft, ob das angegebene Objekt eine Zeichenkette darstellt.
- * Also eine Instanz von <code>java.lang.String</code> ist.
- * @return <code>false</code>, wenn das angegebene Objekt <code>null</code> ist
- */
- public static boolean isString(Object o) {
- return o!=null && isString(o.getClass());
- }
+ /**
+ * Prueft, ob die angegebene Klasse einen Basistyp (inkl. String) oder eine
+ * korrespondierende Klasse (z.B. <code>java.lang.Integer</code>) darstellt.
+ */
+ public static boolean isBaseType(Class c) {
+ return isByte(c) || isShort(c) || isInteger(c) || isLong(c)
+ || isFloat(c) || isDouble(c) || isCharacter(c) || isString(c)
+ || isBoolean(c);
+ }
- /**
- * Prueft, ob die angegebene Klasse einen Basistyp (inkl. String) oder
- * eine korrespondierende Klasse (z.B. <code>java.lang.Integer</code>) darstellt.
- */
- public static boolean isBaseType(Class c) {
- return isByte(c) || isShort(c) || isInteger(c) || isLong(c) || isFloat(c) ||
- isDouble(c) || isCharacter(c) || isString(c) || isBoolean(c);
- }
+ /**
+ * Prueft, ob das angegebene Objekt einen Basistyp (auch String) oder eine
+ * korrespondierende Klasse (z.B. <code>java.lang.Integer</code>) darstellt.
+ */
+ public static boolean isBaseType(Object o) {
+ return o != null && isBaseType(o.getClass());
+ }
- /**
- * Prueft, ob das angegebene Objekt einen Basistyp (auch String) oder
- * eine korrespondierende Klasse (z.B. <code>java.lang.Integer</code>) darstellt.
- */
- public static boolean isBaseType(Object o) {
- return o!=null && isBaseType(o.getClass());
- }
+ /**
+ * Prueft, ob die angegebene Klasse einen numerischen Basistyp oder eine
+ * korrespondierende Klasse (z.B. <code>java.lang.Integer</code>) darstellt.
+ */
+ public static boolean isNumeric(Class c) {
+ return isByte(c) || isShort(c) || isInteger(c) || isLong(c)
+ || isFloat(c) || isDouble(c);
+ }
- /**
- * Prueft, ob die angegebene Klasse einen numerischen Basistyp oder
- * eine korrespondierende Klasse (z.B. <code>java.lang.Integer</code>) darstellt.
- */
- public static boolean isNumeric(Class c) {
- return isByte(c) || isShort(c) || isInteger(c) || isLong(c) || isFloat(c) ||
- isDouble(c);
- }
+ /**
+ * Prueft, ob das angegebene Objekt einen numerischen Basistyp oder eine
+ * korrespondierende Klasse (z.B. <code>java.lang.Integer</code>) darstellt.
+ */
+ public static boolean isNumeric(Object o) {
+ return o != null && isNumeric(o.getClass());
+ }
- /**
- * Prueft, ob das angegebene Objekt einen numerischen Basistyp oder
- * eine korrespondierende Klasse (z.B. <code>java.lang.Integer</code>) darstellt.
- */
- public static boolean isNumeric(Object o) {
- return o!=null && isNumeric(o.getClass());
- }
+ /**
+ * Prueft, ob die angegebene Klasse eine Dezimalzahl oder eine
+ * korrespondierende Klasse (z.B. <code>java.lang.Double</code>) darstellt.
+ */
+ public static boolean isDecimal(Class c) {
+ return isFloat(c) || isDouble(c);
+ }
- /**
- * Prueft, ob die angegebene Klasse eine Dezimalzahl oder
- * eine korrespondierende Klasse (z.B. <code>java.lang.Double</code>) darstellt.
- */
- public static boolean isDecimal(Class c) {
- return isFloat(c) || isDouble(c);
- }
+ /**
+ * Prueft, ob das angegebene Objekt eine Dezimalzahl oder eine
+ * korrespondierende Klasse (z.B. <code>java.lang.Double</code>) darstellt.
+ */
+ public static boolean isDecimal(Object o) {
+ return o != null && isDecimal(o.getClass());
+ }
- /**
- * Prueft, ob das angegebene Objekt eine Dezimalzahl oder
- * eine korrespondierende Klasse (z.B. <code>java.lang.Double</code>) darstellt.
- */
- public static boolean isDecimal(Object o) {
- return o!=null && isDecimal(o.getClass());
- }
+ /**
+ * Prueft, ob zwei BaseType-Klassen zueinander kompatibel sind
+ *
+ * @return <code>false</code> wenn eine der Klassen <b>keinen</b> BaseType
+ * darstellt
+ */
+ public static boolean isEquivalent(Class c1, Class c2) {
+ return isByte(c1) && isByte(c2) || isShort(c1) && isShort(c2)
+ || isInteger(c1) && isInteger(c2) || isLong(c1) && isLong(c2)
+ || isFloat(c1) && isFloat(c2) || isDouble(c1) && isDouble(c2)
+ || isBoolean(c1) && isBoolean(c2) || isCharacter(c1)
+ && isCharacter(c2) || isString(c1) && isString(c2)
+ || isBoolean(c1) && isBoolean(c2);
+ }
- /**
- * Prueft, ob zwei BaseType-Klassen zueinander kompatibel sind
- * @return <code>false</code> wenn eine der Klassen <b>keinen</b> BaseType
- * darstellt
- */
- public static boolean isEquivalent(Class c1, Class c2) {
- return isByte(c1) && isByte(c2) ||
- isShort(c1) && isShort(c2) ||
- isInteger(c1) && isInteger(c2) ||
- isLong(c1) && isLong(c2) ||
- isFloat(c1) && isFloat(c2) ||
- isDouble(c1) && isDouble(c2) ||
- isBoolean(c1) && isBoolean(c2) ||
- isCharacter(c1) && isCharacter(c2) ||
- isString(c1) && isString(c2) ||
- isBoolean(c1) && isBoolean(c2);
- }
+ /**
+ * Prueft, ob zwei BaseType-Objekte zueinander kompatibel sind
+ *
+ * @return <code>false</code> wenn eines der Objekte <b>keinen</b> BaseType
+ * darstellt oder <code>null</code> ist
+ */
+ public static boolean isEquivalent(Object o1, Object o2) {
+ return o1 != null && o2 != null
+ && isEquivalent(o1.getClass(), o2.getClass());
+ }
- /**
- * Prueft, ob zwei BaseType-Objekte zueinander kompatibel sind
- * @return <code>false</code> wenn eines der Objekte <b>keinen</b> BaseType
- * darstellt oder <code>null</code> ist
- */
- public static boolean isEquivalent(Object o1, Object o2) {
- return o1!=null && o2!=null && isEquivalent(o1.getClass(),o2.getClass());
- }
+ /**
+ * Prueft, ob eine numerische Datentyp-Klasse in eine andere numerische
+ * Datentyp-Klasse (ohne Verlust) umgewandelt werden kann.
+ *
+ * @param fromClass
+ * Ausgangs-Datentyp
+ * @param to
+ * Class Ziel-Datentyp
+ */
+ public static boolean isConvertable(Class<Number> fromClass,
+ Class<Number> toClass) {
+ // gleiche Typen koennen immer ineinander umgewandelt werden
+ if (fromClass.equals(toClass))
+ return true;
- /**
- * Prueft, ob eine numerische Datentyp-Klasse in eine andere numerische
- * Datentyp-Klasse (ohne Verlust) umgewandelt werden kann.
- * @param fromClass Ausgangs-Datentyp
- * @param to Class Ziel-Datentyp
- */
- public static boolean isConvertable(Class<Number> fromClass, Class<Number> toClass) {
- // gleiche Typen koennen immer ineinander umgewandelt werden
- if ( fromClass.equals( toClass ) )
- return true;
+ // Float kann in Double umgewandelt werden
+ if (Float.class.equals(fromClass))
+ return Double.class.equals(toClass);
- // Float kann in Double umgewandelt werden
- if ( Float.class.equals(fromClass) )
- return Double.class.equals(toClass);
+ // Integer kann in Long umgewandelt werden
+ if (Integer.class.equals(fromClass))
+ return Long.class.equals(toClass);
- // Integer kann in Long umgewandelt werden
- if ( Integer.class.equals(fromClass) )
- return Long.class.equals(toClass);
+ // Byte kann in Long und Integer umgewandelt werden
+ if (Byte.class.equals(fromClass))
+ return Integer.class.equals(toClass) || Long.class.equals(toClass);
- // Byte kann in Long und Integer umgewandelt werden
- if ( Byte.class.equals(fromClass) )
- return Integer.class.equals(toClass)
- || Long.class.equals(toClass) ;
+ // Short kann in Long und Integer umgewandelt werden
+ if (Short.class.equals(fromClass))
+ return Integer.class.equals(toClass) || Long.class.equals(toClass);
- // Short kann in Long und Integer umgewandelt werden
- if ( Short.class.equals(fromClass) )
- return Integer.class.equals(toClass)
- || Long.class.equals(toClass) ;
+ return false;
+ }
- return false;
- }
+ /**
+ * Wandelt einen numerischen Wert in einen bestimmten Datentyp um. Dabei
+ * kann
+ *
+ * @param source
+ * numerisches Datenobjekt
+ * @param destType
+ * Typ, in den das Objekt umgewandelt wird
+ */
+ public static Object convertNumber(Number source, Class<Number> destType) {
+ if (Double.class.equals(destType))
+ return source.doubleValue();
+ if (Float.class.equals(destType))
+ return source.floatValue();
+ if (Long.class.equals(destType))
+ return source.longValue();
+ if (Integer.class.equals(destType))
+ return source.intValue();
+ if (Byte.class.equals(destType))
+ return source.byteValue();
+ if (Short.class.equals(destType))
+ return source.shortValue();
+ throw new UnsupportedClassVersionError("Unsupported numeric type: "
+ + (destType != null ? destType.getSimpleName() : "null"));
+ }
- /**
- * Wandelt einen numerischen Wert in einen bestimmten Datentyp um.
- * Dabei kann
- * @param source numerisches Datenobjekt
- * @param destType Typ, in den das Objekt umgewandelt wird
- */
- public static Object convertNumber(Number source, Class<Number> destType) {
- if ( Double.class.equals(destType) )
- return source.doubleValue();
- if ( Float.class.equals(destType) )
- return source.floatValue();
- if ( Long.class.equals(destType) )
- return source.longValue();
- if ( Integer.class.equals(destType) )
- return source.intValue();
- if ( Byte.class.equals(destType) )
- return source.byteValue();
- if ( Short.class.equals(destType) )
- return source.shortValue();
- throw new UnsupportedClassVersionError("Unsupported numeric type: "+(destType != null ? destType.getSimpleName() : "null"));
- }
+ /**
+ * Erzeugt eine BaseType-Instanz aus einem String.
+ *
+ * @param strValue
+ * Zeichenkette, die das Objekt darstellt
+ * @param destType
+ * BaseType in den konvertiert werden soll
+ */
+ public static <T> T convertFromString(String strValue,
+ Class<? extends T> destType) {
+ if (!isBaseType(destType))
+ return null;
- /**
- * Erzeugt eine BaseType-Instanz aus einem String.
- * @param strValue Zeichenkette, die das Objekt darstellt
- * @param destType BaseType in den konvertiert werden soll
- */
- public static <T> T convertFromString(String strValue, Class<? extends T> destType) {
- if (!isBaseType(destType))
- return null;
+ // Beim String ist nicht zu machen
+ if (isString(destType))
+ return (T) strValue;
- // Beim String ist nicht zu machen
- if ( isString(destType) )
- return (T)strValue;
+ // Bei allen anderen Typen wird ein Leerstring zu null
+ if (strValue == null || strValue.equals(""))
+ return null;
- // Bei allen anderen Typen wird ein Leerstring zu null
- if ( strValue == null || strValue.equals("") )
- return null;
+ // Bei Zeichen, wird das erste vom String genommen
+ if (isCharacter(destType))
+ return (T) new Character(strValue.charAt(0));
+ // Bei Zahlen oder Boolean wird versucht aus dem
+ // String zu parsen
+ if (isShort(destType))
+ return (T) new Short(strValue);
+ if (isByte(destType))
+ return (T) new Byte(strValue);
+ if (isInteger(destType))
+ return (T) new Integer(strValue);
+ if (isLong(destType))
+ return (T) new Long(strValue);
+ if (isFloat(destType))
+ return (T) new Float(strValue);
+ if (isDouble(destType))
+ return (T) new Double(strValue);
+ if (isBoolean(destType))
+ return (T) new Boolean(strValue);
- // Bei Zeichen, wird das erste vom String genommen
- if ( isCharacter(destType) )
- return (T)new Character(strValue.charAt(0));
- // Bei Zahlen oder Boolean wird versucht aus dem
- // String zu parsen
- if ( isShort(destType) )
- return (T)new Short(strValue);
- if ( isByte(destType) )
- return (T)new Byte(strValue);
- if ( isInteger(destType) )
- return (T)new Integer(strValue);
- if ( isLong(destType) )
- return (T)new Long(strValue);
- if ( isFloat(destType) )
- return (T)new Float(strValue);
- if ( isDouble(destType) )
- return (T)new Double(strValue);
- if ( isBoolean(destType) )
- return (T)new Boolean(strValue);
+ return null;
+ }
- return null;
- }
+ /**
+ * Erzeugt eine BaseType-Instanz aus einem String. Es wird versucht, einen
+ * der folgenden Datentypen zu erzeugen:
+ * <ol>
+ * <li><code>Integer</code></li>
+ * <li><code>Double</code></li>
+ * <li><code>String</code></li>
+ * </ol>
+ *
+ * @param strValue
+ * Zeichenkette, die das Objekt darstellt
+ */
+ public static Object convertFromString(String strValue) {
+ // erst versuchen einen Integer zu erzeugen
+ try {
+ return Integer.parseInt(strValue);
+ } catch (NumberFormatException err) {
+ }
- /**
- * Erzeugt eine BaseType-Instanz aus einem String. Es wird versucht, einen
- * der folgenden Datentypen zu erzeugen:
- * <ol>
- * <li><code>Integer</code></li>
- * <li><code>Double</code></li>
- * <li><code>String</code></li>
- * </ol>
- * @param strValue Zeichenkette, die das Objekt darstellt
- */
- public static Object convertFromString(String strValue) {
- // erst versuchen einen Integer zu erzeugen
- try {
- return Integer.parseInt(strValue);
- } catch (NumberFormatException err) {
- }
+ // dann versuchen einen Double zu erzeugen
+ try {
+ return Double.parseDouble(strValue);
+ } catch (NumberFormatException err) {
+ }
- // dann versuchen einen Double zu erzeugen
- try {
- return Double.parseDouble(strValue);
- } catch (NumberFormatException err) {
- }
+ // sonst beim String belassen
+ return strValue;
+ }
- // sonst beim String belassen
- return strValue;
- }
-
}
Modified: trunk/schmitzm-core/src/test/java/de/schmitzm/lang/ResourceProviderTest.java
===================================================================
--- trunk/schmitzm-core/src/test/java/de/schmitzm/lang/ResourceProviderTest.java 2011-01-29 23:55:28 UTC (rev 1473)
+++ trunk/schmitzm-core/src/test/java/de/schmitzm/lang/ResourceProviderTest.java 2011-01-30 01:00:22 UTC (rev 1474)
@@ -13,7 +13,6 @@
import org.apache.log4j.Logger;
import org.apache.log4j.SimpleLayout;
import org.apache.log4j.WriterAppender;
-import org.junit.Ignore;
import org.junit.Test;
import de.schmitzm.testing.TestingClass;
More information about the Schmitzm-commits
mailing list