1 package de.keepondreaming.xml.util;
2
3 import java.lang.reflect.Constructor;
4 import java.util.Date;
5 import java.util.HashMap;
6 import java.util.Map;
7
8 /***
9 * Various helper methods
10 *
11 * $Author: wintermond $
12 * $Date: 2005/07/10 18:32:11 $
13 * $Log: Util.java,v $
14 * Revision 1.4 2005/07/10 18:32:11 wintermond
15 * Revamp to improve performance, most operations could benefit from the use of HashMaps
16 *
17 * Revision 1.3 2005/07/09 14:11:16 wintermond
18 * Changed method signatur of createObject - switched parameter ordering
19 *
20 * Revision 1.2 2005/07/09 10:02:19 wintermond
21 * Received some generic methods from the other classes, concerning reflection based topics
22 *
23 */
24 public class Util
25 {
26 private static final Class[] LONG_TYPE_PARAMETER = new Class[]{Long.TYPE};
27 private static final Class[] STRING_PARAMETER = new Class[]{String.class};
28
29 private static Map<Class, Object> primitiveDefaultValueCacheM = new HashMap<Class, Object>(17);
30 private static Map<Class, Class > primitiveObjectCacheM = new HashMap<Class, Class>(17);
31 private static Map<Class, Constructor > constructorCacheM = new HashMap<Class, Constructor>(47);
32 private static Map<Class, Class > object2PrimitiveClassCacheM = new HashMap<Class, Class>(47);
33
34 static
35 {
36 primitiveDefaultValueCacheM.put(Integer.TYPE, new Integer(0));
37 primitiveDefaultValueCacheM.put(Byte.TYPE, new Byte((byte)0));
38 primitiveDefaultValueCacheM.put(Short.TYPE, new Short((short)0));
39 primitiveDefaultValueCacheM.put(Float.TYPE, new Float(0));
40 primitiveDefaultValueCacheM.put(Double.TYPE, new Double(0));
41 primitiveDefaultValueCacheM.put(Boolean.TYPE, Boolean.TRUE);
42 primitiveDefaultValueCacheM.put(Character.TYPE, new Character(' '));
43
44 primitiveObjectCacheM.put(Integer.TYPE, Integer.class);
45 primitiveObjectCacheM.put(Byte.TYPE, Byte.class);
46 primitiveObjectCacheM.put(Short.TYPE, Short.class);
47 primitiveObjectCacheM.put(Float.TYPE, Float.class);
48 primitiveObjectCacheM.put(Double.TYPE, Double.class);
49 primitiveObjectCacheM.put(Boolean.TYPE, Boolean.class);
50 primitiveObjectCacheM.put(Character.TYPE, Character.class);
51
52 object2PrimitiveClassCacheM.put(Integer.class,Integer.TYPE);
53 object2PrimitiveClassCacheM.put(Short.class, Short.TYPE);
54 object2PrimitiveClassCacheM.put(Byte.class, Byte.TYPE);
55 object2PrimitiveClassCacheM.put(Float.class, Float.TYPE);
56 object2PrimitiveClassCacheM.put(Double.class, Double.TYPE);
57 object2PrimitiveClassCacheM.put(Boolean.class, Boolean.TYPE);
58 object2PrimitiveClassCacheM.put(Character.class, Character.TYPE);
59 }
60
61 /***
62 * Uppercases the first letter of a string if <code>in</code> is not null
63 *
64 * @param in
65 *
66 * @return The input string with the first letter as uppercase
67 */
68 public static String capitalize(String in)
69 {
70 String result = null;
71 if(in != null)
72 {
73 result = in.substring(0,1).toUpperCase() + in.substring(1);
74 }
75 return result;
76 }
77
78 /***
79 * Creates for a primitive class an object of the corresponding object type.
80 *
81 * @param primitiveClass
82 *
83 * @return A newly created Object of the requested type, initialized with default values
84 */
85 public static Object createPrimitiveDefaultValue(Class primitiveClass)
86 {
87 Object result = primitiveDefaultValueCacheM.get(primitiveClass);
88 return result;
89 }
90
91 /***
92 * Returns a new Object of the concurrent primitive type passed by
93 * <code>primitive</code> and initializes it with <code>value</code>
94 *
95 * @param primitive
96 * @param value
97 *
98 * @return A new Object of the concurrent primitive type, null if an error
99 * occurs
100 */
101 public static Object getPrimitiveObject(Class primitive, String value)
102 {
103 Object result = null;
104 Class transformer = null;
105 transformer = primitiveObjectCacheM.get(primitive);
106 result = createObject(transformer, value);
107
108 return result;
109 }
110
111 /***
112 * Creates a new instances of an object, if the object has a constructor with a single
113 * {@link String} parameter
114 * @param transformer
115 * @param value
116 *
117 * @return A new instance of the specified class or null if an error occurs
118 */
119 public static Object createObject(Class transformer, String value)
120 {
121 Object result = null;
122 try
123 {
124 Constructor constructor = constructorCacheM.get(transformer);
125
126 if(!Date.class.isAssignableFrom(transformer))
127 {
128 if(constructor == null)
129 {
130 constructor = transformer.getConstructor(STRING_PARAMETER);
131 constructorCacheM.put(transformer, constructor);
132 }
133
134 result = constructor.newInstance(new Object[]{value});
135 }
136 else
137 {
138 if(constructor == null)
139 {
140 constructor = transformer.getConstructor(LONG_TYPE_PARAMETER);
141 constructorCacheM.put(transformer, constructor);
142 }
143 Long date = new Long(value);
144 result = constructor.newInstance(new Object[]{date});
145 }
146 }
147 catch (Throwable e)
148 {
149 e.printStackTrace();
150 }
151 return result;
152 }
153
154 /***
155 * Retrieves for an object assignable to a primitive value
156 * the assigned primitive class type.
157 *
158 * @param primitive
159 *
160 * @return Primitive class type of the passed <code>primitive</code>
161 * object. Null if there is no primitive class for this type available
162 */
163 public static Class computePrimitiveClass(Object primitive)
164 {
165 Class result = object2PrimitiveClassCacheM.get(primitive.getClass());
166
167 return result;
168 }
169 }