1 package org.djutils.primitives;
2
3
4
5
6
7
8
9
10
11
12
13
14 public final class Primitive
15 {
16
17
18
19 private Primitive()
20 {
21 super();
22
23 }
24
25
26
27
28
29
30
31 public static Object[] cast(final Class<?>[] classes, final Object[] values)
32 {
33 for (int i = 0; i < classes.length; i++)
34 {
35 values[i] = Primitive.cast(classes[i], values[i]);
36 }
37 return values;
38 }
39
40
41
42
43
44
45
46 public static Object cast(final Class<?> clazz, final Object object)
47 {
48 if (clazz.isInstance(object) || !clazz.isPrimitive()
49 || (clazz.equals(Primitive.getPrimitive(object.getClass()))))
50 {
51 return object;
52 }
53
54
55 if (clazz.equals(boolean.class))
56 {
57 return Primitive.toBoolean(object);
58 }
59
60
61 if (clazz.equals(char.class))
62 {
63 return Primitive.toCharacter(object);
64 }
65
66
67 if (clazz.equals(byte.class))
68 {
69 return Primitive.toByte(object);
70 }
71
72
73 if (clazz.equals(double.class))
74 {
75 return Primitive.toDouble(object);
76 }
77
78
79 if (clazz.equals(float.class))
80 {
81 return Primitive.toFloat(object);
82 }
83
84
85 if (clazz.equals(long.class))
86 {
87 return Primitive.toLong(object);
88 }
89
90
91 if (clazz.equals(int.class))
92 {
93 return Primitive.toInteger(object);
94 }
95
96
97 if (clazz.equals(short.class))
98 {
99 return Primitive.toShort(object);
100 }
101 return object;
102 }
103
104
105
106
107
108
109
110 public static Class<?> forName(final String className)
111 {
112 if (className.equals("int") || className.equals("I"))
113 {
114 return int.class;
115 }
116 if (className.equals("double") || className.equals("D"))
117 {
118 return double.class;
119 }
120 if (className.equals("byte") || className.equals("B"))
121 {
122 return byte.class;
123 }
124 if (className.equals("float") || className.equals("F"))
125 {
126 return float.class;
127 }
128 if (className.equals("long") || className.equals("J"))
129 {
130 return long.class;
131 }
132 if (className.equals("boolean") || className.equals("Z"))
133 {
134 return boolean.class;
135 }
136 if (className.equals("char") || className.equals("C"))
137 {
138 return char.class;
139 }
140 if (className.equals("short") || className.equals("S"))
141 {
142 return short.class;
143 }
144 if (className.equals("void") || className.equals("V"))
145 {
146 return void.class;
147 }
148 return null;
149 }
150
151
152
153
154
155
156 public static Class<?> getPrimitive(final Class<?> wrapperClass)
157 {
158 if (wrapperClass.equals(Integer.class))
159 {
160 return int.class;
161 }
162 if (wrapperClass.equals(Double.class))
163 {
164 return double.class;
165 }
166 if (wrapperClass.equals(Byte.class))
167 {
168 return byte.class;
169 }
170 if (wrapperClass.equals(Float.class))
171 {
172 return float.class;
173 }
174 if (wrapperClass.equals(Long.class))
175 {
176 return long.class;
177 }
178 if (wrapperClass.equals(Boolean.class))
179 {
180 return boolean.class;
181 }
182 if (wrapperClass.equals(Character.class))
183 {
184 return char.class;
185 }
186 if (wrapperClass.equals(Short.class))
187 {
188 return short.class;
189 }
190 return null;
191 }
192
193
194
195
196
197
198 public static Class<?> getWrapper(final Class<?> primitiveClass)
199 {
200 if (primitiveClass.equals(int.class))
201 {
202 return Integer.class;
203 }
204 if (primitiveClass.equals(double.class))
205 {
206 return Double.class;
207 }
208 if (primitiveClass.equals(byte.class))
209 {
210 return Byte.class;
211 }
212 if (primitiveClass.equals(float.class))
213 {
214 return Float.class;
215 }
216 if (primitiveClass.equals(long.class))
217 {
218 return Long.class;
219 }
220 if (primitiveClass.equals(boolean.class))
221 {
222 return Boolean.class;
223 }
224 if (primitiveClass.equals(char.class))
225 {
226 return Character.class;
227 }
228 if (primitiveClass.equals(short.class))
229 {
230 return Short.class;
231 }
232 throw new IllegalArgumentException(primitiveClass + " != primitive");
233 }
234
235
236
237
238
239
240 public static Boolean toBoolean(final Object object)
241 {
242 if (object instanceof Number)
243 {
244 int value = ((Number) object).intValue();
245 if (value == 1)
246 {
247 return Boolean.TRUE;
248 }
249 if (value == 0)
250 {
251 return Boolean.FALSE;
252 }
253 throw new IllegalArgumentException("object.intValue !=0 && !=1");
254 }
255 return (Boolean) object;
256 }
257
258
259
260
261
262
263 public static Byte toByte(final Object object)
264 {
265 if (object instanceof Number)
266 {
267 return new Byte(((Number) object).byteValue());
268 }
269 return (Byte) object;
270 }
271
272
273
274
275
276
277 public static Character toCharacter(final Object object)
278 {
279 if (object instanceof Number)
280 {
281 return new Character((char) ((Number) object).byteValue());
282 }
283 return (Character) object;
284 }
285
286
287
288
289
290
291 public static Double toDouble(final Object object)
292 {
293 return new Double(((Number) object).doubleValue());
294 }
295
296
297
298
299
300
301 public static Float toFloat(final Object object)
302 {
303 return new Float(((Number) object).floatValue());
304 }
305
306
307
308
309
310
311 public static Long toLong(final Object object)
312 {
313 return new Long(((Number) object).longValue());
314 }
315
316
317
318
319
320
321 public static Short toShort(final Object object)
322 {
323 return new Short(((Number) object).shortValue());
324 }
325
326
327
328
329
330
331 public static Integer toInteger(final Object object)
332 {
333 if (object instanceof Character)
334 {
335 return new Integer(((Character) object).charValue());
336 }
337 if (object instanceof Boolean)
338 {
339 if (((Boolean) object).booleanValue())
340 {
341 return new Integer(1);
342 }
343 return new Integer(0);
344 }
345 return new Integer(((Number) object).intValue());
346 }
347 }