Mercurial Hosting > luan

comparison src/org/eclipse/jetty/util/TypeUtil.java @ 830:7c737c376bc3

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
remove Loader
author Franklin Schmidt <fschmidt@gmail.com>
date Thu, 15 Sep 2016 18:30:38 -0600
parents 8e9db0bbf4f9
children
comparison
equal deleted inserted replaced
829:dfa742c663f9 830:7c737c376bc3
42 * 42 *
43 * @since Jetty 4.1 43 * @since Jetty 4.1
44 */ 44 */
45 public class TypeUtil 45 public class TypeUtil
46 { 46 {
47 private static final Logger LOG = LoggerFactory.getLogger(TypeUtil.class); 47 private static final Logger LOG = LoggerFactory.getLogger(TypeUtil.class);
48 public static int CR = '\015'; 48 public static int CR = '\015';
49 public static int LF = '\012'; 49 public static int LF = '\012';
50 50
51 /* ------------------------------------------------------------ */ 51 /* ------------------------------------------------------------ */
52 private static final HashMap<String, Class<?>> name2Class=new HashMap<String, Class<?>>(); 52 private static final HashMap<String, Class<?>> name2Class=new HashMap<String, Class<?>>();
53 static 53 static
54 { 54 {
55 name2Class.put("boolean",java.lang.Boolean.TYPE); 55 name2Class.put("boolean",java.lang.Boolean.TYPE);
56 name2Class.put("byte",java.lang.Byte.TYPE); 56 name2Class.put("byte",java.lang.Byte.TYPE);
57 name2Class.put("char",java.lang.Character.TYPE); 57 name2Class.put("char",java.lang.Character.TYPE);
58 name2Class.put("double",java.lang.Double.TYPE); 58 name2Class.put("double",java.lang.Double.TYPE);
59 name2Class.put("float",java.lang.Float.TYPE); 59 name2Class.put("float",java.lang.Float.TYPE);
60 name2Class.put("int",java.lang.Integer.TYPE); 60 name2Class.put("int",java.lang.Integer.TYPE);
61 name2Class.put("long",java.lang.Long.TYPE); 61 name2Class.put("long",java.lang.Long.TYPE);
62 name2Class.put("short",java.lang.Short.TYPE); 62 name2Class.put("short",java.lang.Short.TYPE);
63 name2Class.put("void",java.lang.Void.TYPE); 63 name2Class.put("void",java.lang.Void.TYPE);
64 64
65 name2Class.put("java.lang.Boolean.TYPE",java.lang.Boolean.TYPE); 65 name2Class.put("java.lang.Boolean.TYPE",java.lang.Boolean.TYPE);
66 name2Class.put("java.lang.Byte.TYPE",java.lang.Byte.TYPE); 66 name2Class.put("java.lang.Byte.TYPE",java.lang.Byte.TYPE);
67 name2Class.put("java.lang.Character.TYPE",java.lang.Character.TYPE); 67 name2Class.put("java.lang.Character.TYPE",java.lang.Character.TYPE);
68 name2Class.put("java.lang.Double.TYPE",java.lang.Double.TYPE); 68 name2Class.put("java.lang.Double.TYPE",java.lang.Double.TYPE);
69 name2Class.put("java.lang.Float.TYPE",java.lang.Float.TYPE); 69 name2Class.put("java.lang.Float.TYPE",java.lang.Float.TYPE);
70 name2Class.put("java.lang.Integer.TYPE",java.lang.Integer.TYPE); 70 name2Class.put("java.lang.Integer.TYPE",java.lang.Integer.TYPE);
71 name2Class.put("java.lang.Long.TYPE",java.lang.Long.TYPE); 71 name2Class.put("java.lang.Long.TYPE",java.lang.Long.TYPE);
72 name2Class.put("java.lang.Short.TYPE",java.lang.Short.TYPE); 72 name2Class.put("java.lang.Short.TYPE",java.lang.Short.TYPE);
73 name2Class.put("java.lang.Void.TYPE",java.lang.Void.TYPE); 73 name2Class.put("java.lang.Void.TYPE",java.lang.Void.TYPE);
74 74
75 name2Class.put("java.lang.Boolean",java.lang.Boolean.class); 75 name2Class.put("java.lang.Boolean",java.lang.Boolean.class);
76 name2Class.put("java.lang.Byte",java.lang.Byte.class); 76 name2Class.put("java.lang.Byte",java.lang.Byte.class);
77 name2Class.put("java.lang.Character",java.lang.Character.class); 77 name2Class.put("java.lang.Character",java.lang.Character.class);
78 name2Class.put("java.lang.Double",java.lang.Double.class); 78 name2Class.put("java.lang.Double",java.lang.Double.class);
79 name2Class.put("java.lang.Float",java.lang.Float.class); 79 name2Class.put("java.lang.Float",java.lang.Float.class);
80 name2Class.put("java.lang.Integer",java.lang.Integer.class); 80 name2Class.put("java.lang.Integer",java.lang.Integer.class);
81 name2Class.put("java.lang.Long",java.lang.Long.class); 81 name2Class.put("java.lang.Long",java.lang.Long.class);
82 name2Class.put("java.lang.Short",java.lang.Short.class); 82 name2Class.put("java.lang.Short",java.lang.Short.class);
83 83
84 name2Class.put("Boolean",java.lang.Boolean.class); 84 name2Class.put("Boolean",java.lang.Boolean.class);
85 name2Class.put("Byte",java.lang.Byte.class); 85 name2Class.put("Byte",java.lang.Byte.class);
86 name2Class.put("Character",java.lang.Character.class); 86 name2Class.put("Character",java.lang.Character.class);
87 name2Class.put("Double",java.lang.Double.class); 87 name2Class.put("Double",java.lang.Double.class);
88 name2Class.put("Float",java.lang.Float.class); 88 name2Class.put("Float",java.lang.Float.class);
89 name2Class.put("Integer",java.lang.Integer.class); 89 name2Class.put("Integer",java.lang.Integer.class);
90 name2Class.put("Long",java.lang.Long.class); 90 name2Class.put("Long",java.lang.Long.class);
91 name2Class.put("Short",java.lang.Short.class); 91 name2Class.put("Short",java.lang.Short.class);
92 92
93 name2Class.put(null,java.lang.Void.TYPE); 93 name2Class.put(null,java.lang.Void.TYPE);
94 name2Class.put("string",java.lang.String.class); 94 name2Class.put("string",java.lang.String.class);
95 name2Class.put("String",java.lang.String.class); 95 name2Class.put("String",java.lang.String.class);
96 name2Class.put("java.lang.String",java.lang.String.class); 96 name2Class.put("java.lang.String",java.lang.String.class);
97 } 97 }
98 98
99 /* ------------------------------------------------------------ */ 99 /* ------------------------------------------------------------ */
100 private static final HashMap<Class<?>, String> class2Name=new HashMap<Class<?>, String>(); 100 private static final HashMap<Class<?>, String> class2Name=new HashMap<Class<?>, String>();
101 static 101 static
102 { 102 {
103 class2Name.put(java.lang.Boolean.TYPE,"boolean"); 103 class2Name.put(java.lang.Boolean.TYPE,"boolean");
104 class2Name.put(java.lang.Byte.TYPE,"byte"); 104 class2Name.put(java.lang.Byte.TYPE,"byte");
105 class2Name.put(java.lang.Character.TYPE,"char"); 105 class2Name.put(java.lang.Character.TYPE,"char");
106 class2Name.put(java.lang.Double.TYPE,"double"); 106 class2Name.put(java.lang.Double.TYPE,"double");
107 class2Name.put(java.lang.Float.TYPE,"float"); 107 class2Name.put(java.lang.Float.TYPE,"float");
108 class2Name.put(java.lang.Integer.TYPE,"int"); 108 class2Name.put(java.lang.Integer.TYPE,"int");
109 class2Name.put(java.lang.Long.TYPE,"long"); 109 class2Name.put(java.lang.Long.TYPE,"long");
110 class2Name.put(java.lang.Short.TYPE,"short"); 110 class2Name.put(java.lang.Short.TYPE,"short");
111 class2Name.put(java.lang.Void.TYPE,"void"); 111 class2Name.put(java.lang.Void.TYPE,"void");
112 112
113 class2Name.put(java.lang.Boolean.class,"java.lang.Boolean"); 113 class2Name.put(java.lang.Boolean.class,"java.lang.Boolean");
114 class2Name.put(java.lang.Byte.class,"java.lang.Byte"); 114 class2Name.put(java.lang.Byte.class,"java.lang.Byte");
115 class2Name.put(java.lang.Character.class,"java.lang.Character"); 115 class2Name.put(java.lang.Character.class,"java.lang.Character");
116 class2Name.put(java.lang.Double.class,"java.lang.Double"); 116 class2Name.put(java.lang.Double.class,"java.lang.Double");
117 class2Name.put(java.lang.Float.class,"java.lang.Float"); 117 class2Name.put(java.lang.Float.class,"java.lang.Float");
118 class2Name.put(java.lang.Integer.class,"java.lang.Integer"); 118 class2Name.put(java.lang.Integer.class,"java.lang.Integer");
119 class2Name.put(java.lang.Long.class,"java.lang.Long"); 119 class2Name.put(java.lang.Long.class,"java.lang.Long");
120 class2Name.put(java.lang.Short.class,"java.lang.Short"); 120 class2Name.put(java.lang.Short.class,"java.lang.Short");
121 121
122 class2Name.put(null,"void"); 122 class2Name.put(null,"void");
123 class2Name.put(java.lang.String.class,"java.lang.String"); 123 class2Name.put(java.lang.String.class,"java.lang.String");
124 } 124 }
125 125
126 /* ------------------------------------------------------------ */ 126 /* ------------------------------------------------------------ */
127 private static final HashMap<Class<?>, Method> class2Value=new HashMap<Class<?>, Method>(); 127 private static final HashMap<Class<?>, Method> class2Value=new HashMap<Class<?>, Method>();
128 static 128 static
129 { 129 {
130 try 130 try
131 { 131 {
132 Class<?>[] s ={java.lang.String.class}; 132 Class<?>[] s ={java.lang.String.class};
133 133
134 class2Value.put(java.lang.Boolean.TYPE, 134 class2Value.put(java.lang.Boolean.TYPE,
135 java.lang.Boolean.class.getMethod("valueOf",s)); 135 java.lang.Boolean.class.getMethod("valueOf",s));
136 class2Value.put(java.lang.Byte.TYPE, 136 class2Value.put(java.lang.Byte.TYPE,
137 java.lang.Byte.class.getMethod("valueOf",s)); 137 java.lang.Byte.class.getMethod("valueOf",s));
138 class2Value.put(java.lang.Double.TYPE, 138 class2Value.put(java.lang.Double.TYPE,
139 java.lang.Double.class.getMethod("valueOf",s)); 139 java.lang.Double.class.getMethod("valueOf",s));
140 class2Value.put(java.lang.Float.TYPE, 140 class2Value.put(java.lang.Float.TYPE,
141 java.lang.Float.class.getMethod("valueOf",s)); 141 java.lang.Float.class.getMethod("valueOf",s));
142 class2Value.put(java.lang.Integer.TYPE, 142 class2Value.put(java.lang.Integer.TYPE,
143 java.lang.Integer.class.getMethod("valueOf",s)); 143 java.lang.Integer.class.getMethod("valueOf",s));
144 class2Value.put(java.lang.Long.TYPE, 144 class2Value.put(java.lang.Long.TYPE,
145 java.lang.Long.class.getMethod("valueOf",s)); 145 java.lang.Long.class.getMethod("valueOf",s));
146 class2Value.put(java.lang.Short.TYPE, 146 class2Value.put(java.lang.Short.TYPE,
147 java.lang.Short.class.getMethod("valueOf",s)); 147 java.lang.Short.class.getMethod("valueOf",s));
148 148
149 class2Value.put(java.lang.Boolean.class, 149 class2Value.put(java.lang.Boolean.class,
150 java.lang.Boolean.class.getMethod("valueOf",s)); 150 java.lang.Boolean.class.getMethod("valueOf",s));
151 class2Value.put(java.lang.Byte.class, 151 class2Value.put(java.lang.Byte.class,
152 java.lang.Byte.class.getMethod("valueOf",s)); 152 java.lang.Byte.class.getMethod("valueOf",s));
153 class2Value.put(java.lang.Double.class, 153 class2Value.put(java.lang.Double.class,
154 java.lang.Double.class.getMethod("valueOf",s)); 154 java.lang.Double.class.getMethod("valueOf",s));
155 class2Value.put(java.lang.Float.class, 155 class2Value.put(java.lang.Float.class,
156 java.lang.Float.class.getMethod("valueOf",s)); 156 java.lang.Float.class.getMethod("valueOf",s));
157 class2Value.put(java.lang.Integer.class, 157 class2Value.put(java.lang.Integer.class,
158 java.lang.Integer.class.getMethod("valueOf",s)); 158 java.lang.Integer.class.getMethod("valueOf",s));
159 class2Value.put(java.lang.Long.class, 159 class2Value.put(java.lang.Long.class,
160 java.lang.Long.class.getMethod("valueOf",s)); 160 java.lang.Long.class.getMethod("valueOf",s));
161 class2Value.put(java.lang.Short.class, 161 class2Value.put(java.lang.Short.class,
162 java.lang.Short.class.getMethod("valueOf",s)); 162 java.lang.Short.class.getMethod("valueOf",s));
163 } 163 }
164 catch(Exception e) 164 catch(Exception e)
165 { 165 {
166 throw new Error(e); 166 throw new Error(e);
167 } 167 }
168 } 168 }
169 169
170 /* ------------------------------------------------------------ */ 170 /* ------------------------------------------------------------ */
171 /** Array to List. 171 /** Array to List.
172 * <p> 172 * <p>
173 * Works like {@link Arrays#asList(Object...)}, but handles null arrays. 173 * Works like {@link Arrays#asList(Object...)}, but handles null arrays.
174 * @return a list backed by the array. 174 * @return a list backed by the array.
175 */ 175 */
176 public static <T> List<T> asList(T[] a) 176 public static <T> List<T> asList(T[] a)
177 { 177 {
178 if (a==null) 178 if (a==null)
179 return Collections.emptyList(); 179 return Collections.emptyList();
180 return Arrays.asList(a); 180 return Arrays.asList(a);
181 } 181 }
182 182
183 /* ------------------------------------------------------------ */ 183 /* ------------------------------------------------------------ */
184 /** Class from a canonical name for a type. 184 /** Class from a canonical name for a type.
185 * @param name A class or type name. 185 * @param name A class or type name.
186 * @return A class , which may be a primitive TYPE field.. 186 * @return A class , which may be a primitive TYPE field..
187 */ 187 */
188 public static Class<?> fromName(String name) 188 public static Class<?> fromName(String name)
189 { 189 {
190 return name2Class.get(name); 190 return name2Class.get(name);
191 } 191 }
192 192
193 /* ------------------------------------------------------------ */ 193 /* ------------------------------------------------------------ */
194 /** Canonical name for a type. 194 /** Canonical name for a type.
195 * @param type A class , which may be a primitive TYPE field. 195 * @param type A class , which may be a primitive TYPE field.
196 * @return Canonical name. 196 * @return Canonical name.
197 */ 197 */
198 public static String toName(Class<?> type) 198 public static String toName(Class<?> type)
199 { 199 {
200 return class2Name.get(type); 200 return class2Name.get(type);
201 } 201 }
202 202
203 /* ------------------------------------------------------------ */ 203 /* ------------------------------------------------------------ */
204 /** Convert String value to instance. 204 /** Convert String value to instance.
205 * @param type The class of the instance, which may be a primitive TYPE field. 205 * @param type The class of the instance, which may be a primitive TYPE field.
206 * @param value The value as a string. 206 * @param value The value as a string.
207 * @return The value as an Object. 207 * @return The value as an Object.
208 */ 208 */
209 public static Object valueOf(Class<?> type, String value) 209 public static Object valueOf(Class<?> type, String value)
210 { 210 {
211 try 211 try
212 { 212 {
213 if (type.equals(java.lang.String.class)) 213 if (type.equals(java.lang.String.class))
214 return value; 214 return value;
215 215
216 Method m = class2Value.get(type); 216 Method m = class2Value.get(type);
217 if (m!=null) 217 if (m!=null)
218 return m.invoke(null, value); 218 return m.invoke(null, value);
219 219
220 if (type.equals(java.lang.Character.TYPE) || 220 if (type.equals(java.lang.Character.TYPE) ||
221 type.equals(java.lang.Character.class)) 221 type.equals(java.lang.Character.class))
222 return new Character(value.charAt(0)); 222 return new Character(value.charAt(0));
223 223
224 Constructor<?> c = type.getConstructor(java.lang.String.class); 224 Constructor<?> c = type.getConstructor(java.lang.String.class);
225 return c.newInstance(value); 225 return c.newInstance(value);
226 } 226 }
227 catch(NoSuchMethodException e) 227 catch(NoSuchMethodException e)
228 { 228 {
229 // LogSupport.ignore(log,e); 229 // LogSupport.ignore(log,e);
230 } 230 }
231 catch(IllegalAccessException e) 231 catch(IllegalAccessException e)
232 { 232 {
233 // LogSupport.ignore(log,e); 233 // LogSupport.ignore(log,e);
234 } 234 }
235 catch(InstantiationException e) 235 catch(InstantiationException e)
236 { 236 {
237 // LogSupport.ignore(log,e); 237 // LogSupport.ignore(log,e);
238 } 238 }
239 catch(InvocationTargetException e) 239 catch(InvocationTargetException e)
240 { 240 {
241 if (e.getTargetException() instanceof Error) 241 if (e.getTargetException() instanceof Error)
242 throw (Error)(e.getTargetException()); 242 throw (Error)(e.getTargetException());
243 // LogSupport.ignore(log,e); 243 // LogSupport.ignore(log,e);
244 } 244 }
245 return null; 245 return null;
246 } 246 }
247 247
248 /* ------------------------------------------------------------ */ 248 /* ------------------------------------------------------------ */
249 /** Convert String value to instance. 249 /** Convert String value to instance.
250 * @param type classname or type (eg int) 250 * @param type classname or type (eg int)
251 * @param value The value as a string. 251 * @param value The value as a string.
252 * @return The value as an Object. 252 * @return The value as an Object.
253 */ 253 */
254 public static Object valueOf(String type, String value) 254 public static Object valueOf(String type, String value)
255 { 255 {
256 return valueOf(fromName(type),value); 256 return valueOf(fromName(type),value);
257 } 257 }
258 258
259 /* ------------------------------------------------------------ */ 259 /* ------------------------------------------------------------ */
260 /** Parse an int from a substring. 260 /** Parse an int from a substring.
261 * Negative numbers are not handled. 261 * Negative numbers are not handled.
262 * @param s String 262 * @param s String
263 * @param offset Offset within string 263 * @param offset Offset within string
264 * @param length Length of integer or -1 for remainder of string 264 * @param length Length of integer or -1 for remainder of string
265 * @param base base of the integer 265 * @param base base of the integer
266 * @return the parsed integer 266 * @return the parsed integer
267 * @throws NumberFormatException if the string cannot be parsed 267 * @throws NumberFormatException if the string cannot be parsed
268 */ 268 */
269 public static int parseInt(String s, int offset, int length, int base) 269 public static int parseInt(String s, int offset, int length, int base)
270 throws NumberFormatException 270 throws NumberFormatException
271 { 271 {
272 int value=0; 272 int value=0;
273 273
274 if (length<0) 274 if (length<0)
275 length=s.length()-offset; 275 length=s.length()-offset;
276 276
277 for (int i=0;i<length;i++) 277 for (int i=0;i<length;i++)
278 { 278 {
279 char c=s.charAt(offset+i); 279 char c=s.charAt(offset+i);
280 280
281 int digit=convertHexDigit((int)c); 281 int digit=convertHexDigit((int)c);
282 if (digit<0 || digit>=base) 282 if (digit<0 || digit>=base)
283 throw new NumberFormatException(s.substring(offset,offset+length)); 283 throw new NumberFormatException(s.substring(offset,offset+length));
284 value=value*base+digit; 284 value=value*base+digit;
285 } 285 }
286 return value; 286 return value;
287 } 287 }
288 288
289 /* ------------------------------------------------------------ */ 289 /* ------------------------------------------------------------ */
290 /** Parse an int from a byte array of ascii characters. 290 /** Parse an int from a byte array of ascii characters.
291 * Negative numbers are not handled. 291 * Negative numbers are not handled.
292 * @param b byte array 292 * @param b byte array
293 * @param offset Offset within string 293 * @param offset Offset within string
294 * @param length Length of integer or -1 for remainder of string 294 * @param length Length of integer or -1 for remainder of string
295 * @param base base of the integer 295 * @param base base of the integer
296 * @return the parsed integer 296 * @return the parsed integer
297 * @throws NumberFormatException if the array cannot be parsed into an integer 297 * @throws NumberFormatException if the array cannot be parsed into an integer
298 */ 298 */
299 public static int parseInt(byte[] b, int offset, int length, int base) 299 public static int parseInt(byte[] b, int offset, int length, int base)
300 throws NumberFormatException 300 throws NumberFormatException
301 { 301 {
302 int value=0; 302 int value=0;
303 303
304 if (length<0) 304 if (length<0)
305 length=b.length-offset; 305 length=b.length-offset;
306 306
307 for (int i=0;i<length;i++) 307 for (int i=0;i<length;i++)
308 { 308 {
309 char c=(char)(0xff&b[offset+i]); 309 char c=(char)(0xff&b[offset+i]);
310 310
311 int digit=c-'0'; 311 int digit=c-'0';
312 if (digit<0 || digit>=base || digit>=10) 312 if (digit<0 || digit>=base || digit>=10)
313 { 313 {
314 digit=10+c-'A'; 314 digit=10+c-'A';
315 if (digit<10 || digit>=base) 315 if (digit<10 || digit>=base)
316 digit=10+c-'a'; 316 digit=10+c-'a';
317 } 317 }
318 if (digit<0 || digit>=base) 318 if (digit<0 || digit>=base)
319 throw new NumberFormatException(new String(b,offset,length)); 319 throw new NumberFormatException(new String(b,offset,length));
320 value=value*base+digit; 320 value=value*base+digit;
321 } 321 }
322 return value; 322 return value;
323 } 323 }
324 324
325 /* ------------------------------------------------------------ */ 325 /* ------------------------------------------------------------ */
326 public static byte[] parseBytes(String s, int base) 326 public static byte[] parseBytes(String s, int base)
327 { 327 {
328 byte[] bytes=new byte[s.length()/2]; 328 byte[] bytes=new byte[s.length()/2];
329 for (int i=0;i<s.length();i+=2) 329 for (int i=0;i<s.length();i+=2)
330 bytes[i/2]=(byte)TypeUtil.parseInt(s,i,2,base); 330 bytes[i/2]=(byte)TypeUtil.parseInt(s,i,2,base);
331 return bytes; 331 return bytes;
332 } 332 }
333 333
334 /* ------------------------------------------------------------ */ 334 /* ------------------------------------------------------------ */
335 public static String toString(byte[] bytes, int base) 335 public static String toString(byte[] bytes, int base)
336 { 336 {
337 StringBuilder buf = new StringBuilder(); 337 StringBuilder buf = new StringBuilder();
338 for (byte b : bytes) 338 for (byte b : bytes)
339 { 339 {
340 int bi=0xff&b; 340 int bi=0xff&b;
341 int c='0'+(bi/base)%base; 341 int c='0'+(bi/base)%base;
342 if (c>'9') 342 if (c>'9')
343 c= 'a'+(c-'0'-10); 343 c= 'a'+(c-'0'-10);
344 buf.append((char)c); 344 buf.append((char)c);
345 c='0'+bi%base; 345 c='0'+bi%base;
346 if (c>'9') 346 if (c>'9')
347 c= 'a'+(c-'0'-10); 347 c= 'a'+(c-'0'-10);
348 buf.append((char)c); 348 buf.append((char)c);
349 } 349 }
350 return buf.toString(); 350 return buf.toString();
351 } 351 }
352 352
353 /* ------------------------------------------------------------ */ 353 /* ------------------------------------------------------------ */
354 /** 354 /**
355 * @param c An ASCII encoded character 0-9 a-f A-F 355 * @param c An ASCII encoded character 0-9 a-f A-F
356 * @return The byte value of the character 0-16. 356 * @return The byte value of the character 0-16.
357 */ 357 */
358 public static byte convertHexDigit( byte c ) 358 public static byte convertHexDigit( byte c )
359 { 359 {
360 byte b = (byte)((c & 0x1f) + ((c >> 6) * 0x19) - 0x10); 360 byte b = (byte)((c & 0x1f) + ((c >> 6) * 0x19) - 0x10);
361 if (b<0 || b>15) 361 if (b<0 || b>15)
362 throw new IllegalArgumentException("!hex "+c); 362 throw new IllegalArgumentException("!hex "+c);
363 return b; 363 return b;
364 } 364 }
365 365
366 /* ------------------------------------------------------------ */ 366 /* ------------------------------------------------------------ */
367 /** 367 /**
368 * @param c An ASCII encoded character 0-9 a-f A-F 368 * @param c An ASCII encoded character 0-9 a-f A-F
369 * @return The byte value of the character 0-16. 369 * @return The byte value of the character 0-16.
370 */ 370 */
371 public static int convertHexDigit( int c ) 371 public static int convertHexDigit( int c )
372 { 372 {
373 int d= ((c & 0x1f) + ((c >> 6) * 0x19) - 0x10); 373 int d= ((c & 0x1f) + ((c >> 6) * 0x19) - 0x10);
374 if (d<0 || d>15) 374 if (d<0 || d>15)
375 throw new NumberFormatException("!hex "+c); 375 throw new NumberFormatException("!hex "+c);
376 return d; 376 return d;
377 } 377 }
378 378
379 /* ------------------------------------------------------------ */ 379 /* ------------------------------------------------------------ */
380 public static void toHex(byte b,Appendable buf) 380 public static void toHex(byte b,Appendable buf)
381 { 381 {
382 try 382 try
383 { 383 {
384 int d=0xf&((0xF0&b)>>4); 384 int d=0xf&((0xF0&b)>>4);
385 buf.append((char)((d>9?('A'-10):'0')+d)); 385 buf.append((char)((d>9?('A'-10):'0')+d));
386 d=0xf&b; 386 d=0xf&b;
387 buf.append((char)((d>9?('A'-10):'0')+d)); 387 buf.append((char)((d>9?('A'-10):'0')+d));
388 } 388 }
389 catch(IOException e) 389 catch(IOException e)
390 { 390 {
391 throw new RuntimeException(e); 391 throw new RuntimeException(e);
392 } 392 }
393 } 393 }
394 394
395 /* ------------------------------------------------------------ */ 395 /* ------------------------------------------------------------ */
396 public static void toHex(int value,Appendable buf) throws IOException 396 public static void toHex(int value,Appendable buf) throws IOException
397 { 397 {
398 int d=0xf&((0xF0000000&value)>>28); 398 int d=0xf&((0xF0000000&value)>>28);
399 buf.append((char)((d>9?('A'-10):'0')+d)); 399 buf.append((char)((d>9?('A'-10):'0')+d));
400 d=0xf&((0x0F000000&value)>>24); 400 d=0xf&((0x0F000000&value)>>24);
401 buf.append((char)((d>9?('A'-10):'0')+d)); 401 buf.append((char)((d>9?('A'-10):'0')+d));
402 d=0xf&((0x00F00000&value)>>20); 402 d=0xf&((0x00F00000&value)>>20);
403 buf.append((char)((d>9?('A'-10):'0')+d)); 403 buf.append((char)((d>9?('A'-10):'0')+d));
404 d=0xf&((0x000F0000&value)>>16); 404 d=0xf&((0x000F0000&value)>>16);
405 buf.append((char)((d>9?('A'-10):'0')+d)); 405 buf.append((char)((d>9?('A'-10):'0')+d));
406 d=0xf&((0x0000F000&value)>>12); 406 d=0xf&((0x0000F000&value)>>12);
407 buf.append((char)((d>9?('A'-10):'0')+d)); 407 buf.append((char)((d>9?('A'-10):'0')+d));
408 d=0xf&((0x00000F00&value)>>8); 408 d=0xf&((0x00000F00&value)>>8);
409 buf.append((char)((d>9?('A'-10):'0')+d)); 409 buf.append((char)((d>9?('A'-10):'0')+d));
410 d=0xf&((0x000000F0&value)>>4); 410 d=0xf&((0x000000F0&value)>>4);
411 buf.append((char)((d>9?('A'-10):'0')+d)); 411 buf.append((char)((d>9?('A'-10):'0')+d));
412 d=0xf&value; 412 d=0xf&value;
413 buf.append((char)((d>9?('A'-10):'0')+d)); 413 buf.append((char)((d>9?('A'-10):'0')+d));
414 414
415 Integer.toString(0,36); 415 Integer.toString(0,36);
416 } 416 }
417 417
418 418
419 /* ------------------------------------------------------------ */ 419 /* ------------------------------------------------------------ */
420 public static void toHex(long value,Appendable buf) throws IOException 420 public static void toHex(long value,Appendable buf) throws IOException
421 { 421 {
422 toHex((int)(value>>32),buf); 422 toHex((int)(value>>32),buf);
423 toHex((int)value,buf); 423 toHex((int)value,buf);
424 } 424 }
425 425
426 /* ------------------------------------------------------------ */ 426 /* ------------------------------------------------------------ */
427 public static String toHexString(byte b) 427 public static String toHexString(byte b)
428 { 428 {
429 return toHexString(new byte[]{b}, 0, 1); 429 return toHexString(new byte[]{b}, 0, 1);
430 } 430 }
431 431
432 /* ------------------------------------------------------------ */ 432 /* ------------------------------------------------------------ */
433 public static String toHexString(byte[] b) 433 public static String toHexString(byte[] b)
434 { 434 {
435 return toHexString(b, 0, b.length); 435 return toHexString(b, 0, b.length);
436 } 436 }
437 437
438 /* ------------------------------------------------------------ */ 438 /* ------------------------------------------------------------ */
439 public static String toHexString(byte[] b,int offset,int length) 439 public static String toHexString(byte[] b,int offset,int length)
440 { 440 {
441 StringBuilder buf = new StringBuilder(); 441 StringBuilder buf = new StringBuilder();
442 for (int i=offset;i<offset+length;i++) 442 for (int i=offset;i<offset+length;i++)
443 { 443 {
444 int bi=0xff&b[i]; 444 int bi=0xff&b[i];
445 int c='0'+(bi/16)%16; 445 int c='0'+(bi/16)%16;
446 if (c>'9') 446 if (c>'9')
447 c= 'A'+(c-'0'-10); 447 c= 'A'+(c-'0'-10);
448 buf.append((char)c); 448 buf.append((char)c);
449 c='0'+bi%16; 449 c='0'+bi%16;
450 if (c>'9') 450 if (c>'9')
451 c= 'a'+(c-'0'-10); 451 c= 'a'+(c-'0'-10);
452 buf.append((char)c); 452 buf.append((char)c);
453 } 453 }
454 return buf.toString(); 454 return buf.toString();
455 } 455 }
456 456
457 /* ------------------------------------------------------------ */ 457 /* ------------------------------------------------------------ */
458 public static byte[] fromHexString(String s) 458 public static byte[] fromHexString(String s)
459 { 459 {
460 if (s.length()%2!=0) 460 if (s.length()%2!=0)
461 throw new IllegalArgumentException(s); 461 throw new IllegalArgumentException(s);
462 byte[] array = new byte[s.length()/2]; 462 byte[] array = new byte[s.length()/2];
463 for (int i=0;i<array.length;i++) 463 for (int i=0;i<array.length;i++)
464 { 464 {
465 int b = Integer.parseInt(s.substring(i*2,i*2+2),16); 465 int b = Integer.parseInt(s.substring(i*2,i*2+2),16);
466 array[i]=(byte)(0xff&b); 466 array[i]=(byte)(0xff&b);
467 } 467 }
468 return array; 468 return array;
469 } 469 }
470 470
471 471
472 public static void dump(Class<?> c) 472 public static void dump(Class<?> c)
473 { 473 {
474 System.err.println("Dump: "+c); 474 System.err.println("Dump: "+c);
475 dump(c.getClassLoader()); 475 dump(c.getClassLoader());
476 } 476 }
477 477
478 public static void dump(ClassLoader cl) 478 public static void dump(ClassLoader cl)
479 { 479 {
480 System.err.println("Dump Loaders:"); 480 System.err.println("Dump Loaders:");
481 while(cl!=null) 481 while(cl!=null)
482 { 482 {
483 System.err.println(" loader "+cl); 483 System.err.println(" loader "+cl);
484 cl = cl.getParent(); 484 cl = cl.getParent();
485 } 485 }
486 } 486 }
487 487
488 488
489 /* ------------------------------------------------------------ */ 489 /* ------------------------------------------------------------ */
490 /** 490 /**
491 * @deprecated 491 * @deprecated
492 */ 492 */
493 public static byte[] readLine(InputStream in) throws IOException 493 public static byte[] readLine(InputStream in) throws IOException
494 { 494 {
495 byte[] buf = new byte[256]; 495 byte[] buf = new byte[256];
496 496
497 int i=0; 497 int i=0;
498 int loops=0; 498 int loops=0;
499 int ch=0; 499 int ch=0;
500 500
501 while (true) 501 while (true)
502 { 502 {
503 ch=in.read(); 503 ch=in.read();
504 if (ch<0) 504 if (ch<0)
505 break; 505 break;
506 loops++; 506 loops++;
507 507
508 // skip a leading LF's 508 // skip a leading LF's
509 if (loops==1 && ch==LF) 509 if (loops==1 && ch==LF)
510 continue; 510 continue;
511 511
512 if (ch==CR || ch==LF) 512 if (ch==CR || ch==LF)
513 break; 513 break;
514 514
515 if (i>=buf.length) 515 if (i>=buf.length)
516 { 516 {
517 byte[] old_buf=buf; 517 byte[] old_buf=buf;
518 buf=new byte[old_buf.length+256]; 518 buf=new byte[old_buf.length+256];
519 System.arraycopy(old_buf, 0, buf, 0, old_buf.length); 519 System.arraycopy(old_buf, 0, buf, 0, old_buf.length);
520 } 520 }
521 buf[i++]=(byte)ch; 521 buf[i++]=(byte)ch;
522 } 522 }
523 523
524 if (ch==-1 && i==0) 524 if (ch==-1 && i==0)
525 return null; 525 return null;
526 526
527 // skip a trailing LF if it exists 527 // skip a trailing LF if it exists
528 if (ch==CR && in.available()>=1 && in.markSupported()) 528 if (ch==CR && in.available()>=1 && in.markSupported())
529 { 529 {
530 in.mark(1); 530 in.mark(1);
531 ch=in.read(); 531 ch=in.read();
532 if (ch!=LF) 532 if (ch!=LF)
533 in.reset(); 533 in.reset();
534 } 534 }
535 535
536 byte[] old_buf=buf; 536 byte[] old_buf=buf;
537 buf=new byte[i]; 537 buf=new byte[i];
538 System.arraycopy(old_buf, 0, buf, 0, i); 538 System.arraycopy(old_buf, 0, buf, 0, i);
539 539
540 return buf; 540 return buf;
541 } 541 }
542 542
543 public static URL jarFor(String className) 543 public static Object call(Class<?> oClass, String method, Object obj, Object[] arg)
544 { 544 throws InvocationTargetException, NoSuchMethodException
545 try 545 {
546 { 546 // Lets just try all methods for now
547 className=className.replace('.','/')+".class"; 547 Method[] methods = oClass.getMethods();
548 // hack to discover jstl libraries 548 for (int c = 0; methods != null && c < methods.length; c++)
549 URL url = Loader.getResource(null,className,false); 549 {
550 String s=url.toString(); 550 if (!methods[c].getName().equals(method))
551 if (s.startsWith("jar:file:")) 551 continue;
552 return new URL(s.substring(4,s.indexOf("!/"))); 552 if (methods[c].getParameterTypes().length != arg.length)
553 } 553 continue;
554 catch(Exception e) 554 if (Modifier.isStatic(methods[c].getModifiers()) != (obj == null))
555 { 555 continue;
556 LOG.trace("",e); 556 if ((obj == null) && methods[c].getDeclaringClass() != oClass)
557 } 557 continue;
558 return null; 558
559 } 559 try
560 560 {
561 public static Object call(Class<?> oClass, String method, Object obj, Object[] arg) 561 return methods[c].invoke(obj,arg);
562 throws InvocationTargetException, NoSuchMethodException 562 }
563 { 563 catch (IllegalAccessException e)
564 // Lets just try all methods for now 564 {
565 Method[] methods = oClass.getMethods(); 565 LOG.trace("",e);
566 for (int c = 0; methods != null && c < methods.length; c++) 566 }
567 { 567 catch (IllegalArgumentException e)
568 if (!methods[c].getName().equals(method)) 568 {
569 continue; 569 LOG.trace("",e);
570 if (methods[c].getParameterTypes().length != arg.length) 570 }
571 continue; 571 }
572 if (Modifier.isStatic(methods[c].getModifiers()) != (obj == null)) 572
573 continue; 573 throw new NoSuchMethodException(method);
574 if ((obj == null) && methods[c].getDeclaringClass() != oClass) 574 }
575 continue;
576
577 try
578 {
579 return methods[c].invoke(obj,arg);
580 }
581 catch (IllegalAccessException e)
582 {
583 LOG.trace("",e);
584 }
585 catch (IllegalArgumentException e)
586 {
587 LOG.trace("",e);
588 }
589 }
590
591 throw new NoSuchMethodException(method);
592 }
593 } 575 }