001 /*
002 $Id: ScriptBytecodeAdapter.java,v 1.8 2005/05/11 01:17:39 phk Exp $
003
004 Copyright 2003 (C) James Strachan and Bob Mcwhirter. All Rights Reserved.
005
006 Redistribution and use of this software and associated documentation
007 ("Software"), with or without modification, are permitted provided
008 that the following conditions are met:
009
010 1. Redistributions of source code must retain copyright
011 statements and notices. Redistributions must also contain a
012 copy of this document.
013
014 2. Redistributions in binary form must reproduce the
015 above copyright notice, this list of conditions and the
016 following disclaimer in the documentation and/or other
017 materials provided with the distribution.
018
019 3. The name "groovy" must not be used to endorse or promote
020 products derived from this Software without prior written
021 permission of The Codehaus. For written permission,
022 please contact info@codehaus.org.
023
024 4. Products derived from this Software may not be called "groovy"
025 nor may "groovy" appear in their names without prior written
026 permission of The Codehaus. "groovy" is a registered
027 trademark of The Codehaus.
028
029 5. Due credit should be given to The Codehaus -
030 http://groovy.codehaus.org/
031
032 THIS SOFTWARE IS PROVIDED BY THE CODEHAUS AND CONTRIBUTORS
033 ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT
034 NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
035 FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
036 THE CODEHAUS OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
037 INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
038 (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
039 SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
040 HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
041 STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
042 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
043 OF THE POSSIBILITY OF SUCH DAMAGE.
044
045 */
046 package org.codehaus.groovy.runtime;
047
048 import groovy.lang.*;
049
050 import java.util.Iterator;
051 import java.util.List;
052 import java.util.ArrayList;
053 import java.util.Map;
054 import java.util.regex.Matcher;
055 import java.util.regex.Pattern;
056
057 /**
058 * A static helper class to make bytecode generation easier and act as a facade over the Invoker.
059 *
060 * @author <a href="mailto:james@coredevelopers.net">James Strachan</a>
061 * @version $Revision: 1.8 $
062 */
063 public class ScriptBytecodeAdapter {
064 public static final Object[] EMPTY_ARGS = {
065 };
066 /*
067 private static final Object[] EMPTY_MAIN_ARGS = new Object[]{new String[0]};
068
069 private static final Invoker singleton = new Invoker();
070
071 private static final Integer ZERO = new Integer(0);
072 private static final Integer MINUS_ONE = new Integer(-1);
073 private static final Integer ONE = new Integer(1);*/
074
075
076 private static Object unwrap(GroovyRuntimeException gre) throws Throwable{
077 Throwable th = gre;
078 if (th.getCause()!=null && th.getCause()!=gre) th=th.getCause();
079 if (th!=gre && (th instanceof GroovyRuntimeException)) unwrap((GroovyRuntimeException) th);
080 throw th;
081 }
082
083 public static Object invokeMethod(Object object, String methodName, Object arguments) throws Throwable{
084 try {
085 return InvokerHelper.invokeMethod(object, methodName, arguments);
086 } catch (GroovyRuntimeException gre) {
087 return unwrap(gre);
088 }
089 }
090
091 public static Object invokeMethodSafe(Object object, String methodName, Object arguments) throws Throwable{
092 if (object != null) return invokeMethod(object, methodName, arguments);
093 return null;
094 }
095
096 public static Object invokeMethodSpreadSafe(Object object, String methodName, Object arguments) throws Throwable{
097 if (object != null) {
098 if (object instanceof List) {
099 List list = (List) object;
100 List answer = new ArrayList();
101 Iterator it = list.iterator();
102 for (; it.hasNext();) {
103 answer.add(invokeMethodSafe(it.next(), methodName, arguments));
104 }
105 return answer;
106 }
107 else
108 return invokeMethodSafe(object, methodName, arguments);
109 }
110 return null;
111 }
112
113 public static Object invokeStaticMethod(String type, String methodName, Object arguments) throws Throwable{
114 try {
115 return InvokerHelper.invokeStaticMethod(type, methodName, arguments);
116 } catch (GroovyRuntimeException gre) {
117 return unwrap(gre);
118 }
119 }
120
121 public static Object invokeConstructor(String type, Object arguments) throws Throwable{
122 try {
123 return InvokerHelper.invokeConstructor(type, arguments);
124 } catch (GroovyRuntimeException gre) {
125 return unwrap(gre);
126 }
127 }
128
129 public static Object invokeConstructorOf(Class type, Object arguments) throws Throwable{
130 try {
131 return InvokerHelper.invokeConstructorOf(type, arguments);
132 } catch (GroovyRuntimeException gre) {
133 return unwrap(gre);
134 }
135 }
136
137 public static Object invokeNoArgumentsConstructorOf(Class type) throws Throwable{
138 return invokeConstructorOf(type, EMPTY_ARGS);
139 }
140
141 public static Object invokeClosure(Object closure, Object arguments) throws Throwable {
142 return invokeMethod(closure, "doCall", arguments);
143 }
144
145 public static Object invokeSuperMethod(Object object, String methodName, Object arguments) throws Throwable{
146 try {
147 return InvokerHelper.invokeSuperMethod(object, methodName, arguments);
148 } catch (GroovyRuntimeException gre) {
149 return unwrap(gre);
150 }
151 }
152
153 public static Object invokeNoArgumentsMethod(Object object, String methodName) throws Throwable {
154 return invokeMethod(object, methodName, EMPTY_ARGS);
155 }
156
157 public static Object invokeNoArgumentsMethodSafe(Object object, String methodName) throws Throwable {
158 if (object != null) return invokeNoArgumentsMethod(object, methodName);
159 return null;
160 }
161
162 public static Object invokeNoArgumentsMethodSpreadSafe(Object object, String methodName) throws Throwable {
163 if (object != null) {
164 if (object instanceof List) {
165 List list = (List) object;
166 List answer = new ArrayList();
167 Iterator it = list.iterator();
168 for (; it.hasNext();) {
169 answer.add(invokeNoArgumentsMethod(it.next(), methodName));
170 }
171 return answer;
172 }
173 else
174 return invokeNoArgumentsMethod(object, methodName);
175 }
176 return null;
177 }
178
179 public static Object invokeStaticNoArgumentsMethod(String type, String methodName) throws Throwable {
180 return invokeStaticMethod(type, methodName, EMPTY_ARGS);
181 }
182
183 public static int asInt(Object value) throws Throwable {
184 try {
185 return InvokerHelper.asInt(value);
186 } catch (GroovyRuntimeException gre) {
187 unwrap(gre);
188 // return never reached
189 return -1;
190 }
191 }
192
193 /**
194 * Provides a hook for type coercion of the given object to the required type
195 *
196 * @param type of object to convert the given object to
197 * @param object the object to be converted
198 * @return the original object or a new converted value
199 * @throws Throwable
200 */
201 public static Object asType(Object object, Class type) throws Throwable {
202 try {
203 return InvokerHelper.asType(object, type);
204 } catch (GroovyRuntimeException gre) {
205 return unwrap(gre);
206 }
207 }
208
209
210
211 // Attributes
212 //-------------------------------------------------------------------------
213 public static Object getAttribute(Object object, String attribute) throws Throwable {
214 try {
215 return InvokerHelper.getAttribute(object, attribute);
216 } catch (GroovyRuntimeException gre) {
217 return unwrap(gre);
218 }
219 }
220
221 public static Object getAttributeSafe(Object object, String attribute) throws Throwable {
222 if (object != null) return getAttribute(object, attribute);
223 return null;
224 }
225
226 public static Object getAttributeSpreadSafe(Object object, String attribute) throws Throwable {
227 if (object != null) {
228 if (object instanceof List) {
229 List list = (List) object;
230 List answer = new ArrayList();
231 Iterator it = list.iterator();
232 for (; it.hasNext(); ) {
233 answer.add(getAttributeSafe(it.next(), attribute));
234 }
235 return answer;
236 }
237 else
238 return getAttributeSafe(object, attribute);
239 }
240 return null;
241 }
242
243 public static void setAttribute(Object object, String attribute, Object newValue) throws Throwable {
244 try {
245 InvokerHelper.setAttribute(object, attribute, newValue);
246 } catch (GroovyRuntimeException gre) {
247 unwrap(gre);
248 }
249 }
250 /**
251 * This is so we don't have to reorder the stack when we call this method.
252 * At some point a better name might be in order.
253 * @throws Throwable
254 */
255 public static void setAttribute2(Object newValue, Object object, String property) throws Throwable {
256 setAttribute(object, property, newValue);
257 }
258
259 /**
260 * This is so we don't have to reorder the stack when we call this method.
261 * At some point a better name might be in order.
262 * @throws Throwable
263 */
264 public static void setAttributeSafe2(Object newValue, Object object, String property) throws Throwable {
265 setAttribute2(newValue, object, property);
266 }
267
268
269
270 // Properties
271 //-------------------------------------------------------------------------
272 public static Object getProperty(Object object, String property) throws Throwable {
273 try {
274 return InvokerHelper.getProperty(object, property);
275 } catch (GroovyRuntimeException gre) {
276 return unwrap(gre);
277 }
278 }
279
280 public static Object getPropertySafe(Object object, String property) throws Throwable {
281 if (object != null) return getProperty(object, property);
282 return null;
283 }
284
285 public static Object getPropertySpreadSafe(Object object, String property) throws Throwable {
286 if (object != null) {
287 if (object instanceof List) {
288 List list = (List) object;
289 List answer = new ArrayList();
290 Iterator it = list.iterator();
291 for (; it.hasNext(); ) {
292 answer.add(getPropertySafe(it.next(), property));
293 }
294 return answer;
295 }
296 else
297 return getPropertySafe(object, property);
298 }
299 return null;
300 }
301
302 public static void setProperty(Object object, String property, Object newValue) throws Throwable {
303 try {
304 InvokerHelper.setProperty(object, property, newValue);
305 } catch (GroovyRuntimeException gre) {
306 unwrap(gre);
307 }
308 }
309
310 /**
311 * This is so we don't have to reorder the stack when we call this method.
312 * At some point a better name might be in order.
313 * @throws Throwable
314 */
315 public static void setProperty2(Object newValue, Object object, String property) throws Throwable {
316 setProperty(object, property, newValue);
317 }
318
319 /**
320 * This is so we don't have to reorder the stack when we call this method.
321 * At some point a better name might be in order.
322 * @throws Throwable
323 */
324 public static void setPropertySafe2(Object newValue, Object object, String property) throws Throwable {
325 setProperty2(newValue, object, property);
326 }
327
328
329 /**
330 * This is so we don't have to reorder the stack when we call this method.
331 * At some point a better name might be in order.
332 * @throws Throwable
333 */
334 public static void setGroovyObjectProperty(Object newValue, GroovyObject object, String property) throws Throwable {
335 try {
336 object.setProperty(property, newValue);
337 } catch (GroovyRuntimeException gre) {
338 unwrap(gre);
339 }
340 }
341
342 public static Object getGroovyObjectProperty(GroovyObject object, String property) throws Throwable {
343 try {
344 return object.getProperty(property);
345 } catch (GroovyRuntimeException gre) {
346 return unwrap(gre);
347 }
348 }
349
350
351 /**
352 * Returns the method pointer for the given object name
353 */
354 public static Closure getMethodPointer(Object object, String methodName) {
355 return InvokerHelper.getMethodPointer(object, methodName);
356 }
357
358 // Coercions
359 //-------------------------------------------------------------------------
360 public static Iterator asIterator(Object collection) throws Throwable {
361 try {
362 return InvokerHelper.asIterator(collection);
363 } catch (GroovyRuntimeException gre) {
364 return (Iterator) unwrap(gre);
365 }
366 }
367
368 public static boolean asBool(Object object) throws Throwable {
369 try {
370 return InvokerHelper.asBool(object);
371 } catch (GroovyRuntimeException gre) {
372 unwrap(gre);
373 //return never reached
374 return false;
375 }
376 }
377
378 public static boolean notBoolean(boolean bool) {
379 return !bool;
380 }
381
382 public static boolean notObject(Object object) throws Throwable {
383 return !asBool(object);
384 }
385
386 public static Pattern regexPattern(Object regex) throws Throwable {
387 try {
388 return InvokerHelper.regexPattern(regex);
389 } catch (GroovyRuntimeException gre) {
390 return (Pattern) unwrap(gre);
391 }
392 }
393
394 public static Object spreadList(Object value) throws Throwable {
395 try {
396 return InvokerHelper.spreadList(value);
397 } catch (GroovyRuntimeException gre) {
398 return unwrap(gre);
399 }
400 }
401
402 public static Object spreadMap(Object value) throws Throwable {
403 try {
404 return InvokerHelper.spreadMap(value);
405 } catch (GroovyRuntimeException gre) {
406 return unwrap(gre);
407 }
408 }
409
410 public static Object negate(Object value) throws Throwable {
411 try {
412 return InvokerHelper.negate(value);
413 } catch (GroovyRuntimeException gre) {
414 return unwrap(gre);
415 }
416 }
417
418 public static Object bitNegate(Object value) throws Throwable {
419 try {
420 return InvokerHelper.bitNegate(value);
421 } catch (GroovyRuntimeException gre) {
422 return unwrap(gre);
423 }
424 }
425
426 /**
427 * @param a array of primitives
428 * @param type component type of the array
429 * @return
430 * @throws Throwable
431 */
432 public static Object[] convertPrimitiveArray(Object a, Class type) throws Throwable {
433 try {
434 return InvokerHelper.convertPrimitiveArray(a,type);
435 } catch (GroovyRuntimeException gre) {
436 return (Object[])unwrap(gre);
437 }
438 }
439
440 public static Object convertToPrimitiveArray(Object a, Class type) throws Throwable {
441 try {
442 return InvokerHelper.convertToPrimitiveArray(a,type);
443 } catch (GroovyRuntimeException gre) {
444 return unwrap(gre);
445 }
446 }
447
448 public static boolean compareIdentical(Object left, Object right) {
449 return left == right;
450 }
451
452 public static boolean compareEqual(Object left, Object right) throws Throwable{
453 try {
454 return InvokerHelper.compareEqual(left, right);
455 } catch (GroovyRuntimeException gre) {
456 unwrap(gre);
457 // return never reached
458 return false;
459 }
460 }
461
462 public static boolean compareNotEqual(Object left, Object right) throws Throwable{
463 return !compareEqual(left, right);
464 }
465
466 public static Integer compareTo(Object left, Object right) throws Throwable{
467 try {
468 return InvokerHelper.compareTo(left, right);
469 } catch (GroovyRuntimeException gre) {
470 return (Integer) unwrap(gre);
471 }
472 }
473
474 public static Matcher findRegex(Object left, Object right) throws Throwable{
475 try {
476 return InvokerHelper.findRegex(left, right);
477 } catch (GroovyRuntimeException gre) {
478 return (Matcher) unwrap(gre);
479 }
480 }
481
482 public static boolean matchRegex(Object left, Object right) throws Throwable{
483 try {
484 return InvokerHelper.matchRegex(left, right);
485 } catch (GroovyRuntimeException gre) {
486 unwrap(gre);
487 // return never reached
488 return false;
489 }
490 }
491
492 public static boolean compareLessThan(Object left, Object right) throws Throwable{
493 return compareTo(left, right).intValue() < 0;
494 }
495
496 public static boolean compareLessThanEqual(Object left, Object right) throws Throwable{
497 return compareTo(left, right).intValue() <= 0;
498 }
499
500 public static boolean compareGreaterThan(Object left, Object right) throws Throwable{
501 return compareTo(left, right).intValue() > 0;
502 }
503
504 public static boolean compareGreaterThanEqual(Object left, Object right) throws Throwable{
505 return compareTo(left, right).intValue() >= 0;
506 }
507
508 public static boolean isCase(Object switchValue, Object caseExpression) throws Throwable{
509 return asBool(invokeMethod(caseExpression, "isCase", new Object[]{switchValue}));
510 }
511
512 public static Tuple createTuple(Object[] array) throws Throwable{
513 return new Tuple(array);
514 }
515
516 public static List createList(Object[] values) throws Throwable{
517 return InvokerHelper.createList(values);
518 }
519
520 public static Map createMap(Object[] values) throws Throwable{
521 return InvokerHelper.createMap(values);
522 }
523
524 public static List createRange(Object from, Object to, boolean inclusive) throws Throwable{
525 try {
526 return InvokerHelper.createRange(from,to,inclusive);
527 } catch (GroovyRuntimeException gre) {
528 return (List) unwrap(gre);
529 }
530 }
531
532 public static void assertFailed(Object expression, Object message) {
533 InvokerHelper.assertFailed(expression,message);
534 }
535
536 public static Object box(boolean value) {
537 return value ? Boolean.TRUE : Boolean.FALSE;
538 }
539
540 public static Object box(byte value) {
541 return new Byte(value);
542 }
543
544 public static Object box(char value) {
545 return new Character(value);
546 }
547
548 public static Object box(short value) {
549 return new Short(value);
550 }
551
552 public static Object box(int value) {
553 return integerValue(value);
554 }
555
556 public static Object box(long value) {
557 return new Long(value);
558 }
559
560 public static Object box(float value) {
561 return new Float(value);
562 }
563
564 public static Object box(double value) {
565 return new Double(value);
566 }
567
568 /**
569 * get the Integer object from an int. Cached version is used for small ints.
570 *
571 * @param v
572 * @return
573 */
574 public static Integer integerValue(int v) {
575 return InvokerHelper.integerValue(v);
576 }
577
578 public static byte byteUnbox(Object value) throws Throwable {
579 Number n = (Number) asType(value, Byte.class);
580 return n.byteValue();
581 }
582
583 public static char charUnbox(Object value) throws Throwable {
584 Character n = (Character) asType(value, Character.class);
585 return n.charValue();
586 }
587
588 public static short shortUnbox(Object value) throws Throwable {
589 Number n = (Number) asType(value, Short.class);
590 return n.shortValue();
591 }
592
593 public static int intUnbox(Object value) throws Throwable {
594 Number n = (Number) asType(value, Integer.class);
595 return n.intValue();
596 }
597
598 public static boolean booleanUnbox(Object value) throws Throwable {
599 Boolean n = (Boolean) asType(value, Boolean.class);
600 return n.booleanValue();
601 }
602
603 public static long longUnbox(Object value) throws Throwable {
604 Number n = (Number) asType(value, Long.class);
605 return n.longValue();
606 }
607
608 public static float floatUnbox(Object value) throws Throwable {
609 Number n = (Number) asType(value, Float.class);
610 return n.floatValue();
611 }
612
613 public static double doubleUnbox(Object value) throws Throwable {
614 Number n = (Number) asType(value, Double.class);
615 return n.doubleValue();
616 }
617
618 public static MetaClass getMetaClass(Object object) {
619 return InvokerHelper.getMetaClass(object);
620 }
621
622 /*
623 public static void removeClass(Class clazz) {
624 getInstance().removeMetaClass(clazz);
625 Introspector.flushFromCaches(clazz);
626 }
627
628 public static Invoker getInstance() {
629 return singleton;
630 }
631
632 public static Collection asCollection(Object collection) {
633 return getInstance().asCollection(collection);
634 }
635
636 public static List asList(Object args) {
637 return getInstance().asList(args);
638 }
639
640 public static String toString(Object arguments) {
641 return getInstance().toString(arguments);
642 }
643
644 public static String toTypeString(Object[] arguments) {
645 return getInstance().toTypeString(arguments);
646 }
647
648 public static String inspect(Object self) {
649 return getInstance().inspect(self);
650 }
651
652
653
654 public static Object runScript(Class scriptClass, String[] args) {
655 Binding context = new Binding(args);
656 Script script = createScript(scriptClass, context);
657 return invokeMethod(script, "run", EMPTY_ARGS);
658 }
659
660 public static Script createScript(Class scriptClass, Binding context) {
661 try {
662 final GroovyObject object = (GroovyObject) scriptClass.newInstance();
663 Script script = null;
664 if (object instanceof Script) {
665 script = (Script) object;
666 } else {
667 // it could just be a class, so lets wrap it in a Script wrapper
668 // though the bindings will be ignored
669 script = new Script() {
670 public Object run() {
671 object.invokeMethod("main", EMPTY_MAIN_ARGS);
672 return null;
673 }
674 };
675 setProperties(object, context.getVariables());
676 }
677 script.setBinding(context);
678 return script;
679 } catch (Exception e) {
680 throw new GroovyRuntimeException("Failed to create Script instance for class: " + scriptClass + ". Reason: " + e,
681 e);
682 }
683 }
684 */
685
686 /**
687 * Sets the properties on the given object
688 *
689 * @param object
690 * @param map
691 */
692 /* public static void setProperties(Object object, Map map) {
693 getMetaClass(object).setProperties(object, map);
694 }
695
696 public static String getVersion() {
697 String version = null;
698 Package p = Package.getPackage("groovy.lang");
699 if (p != null) {
700 version = p.getImplementationVersion();
701 }
702 if (version == null) {
703 version = "";
704 }
705 return version;
706 }*/
707
708 /**
709 * Allows conversion of arrays into a mutable List
710 *
711 * @return the array as a List
712 */
713 /*protected static List primitiveArrayToList(Object array) {
714 int size = Array.getLength(array);
715 List list = new ArrayList(size);
716 for (int i = 0; i < size; i++) {
717 list.add(Array.get(array, i));
718 }
719 return list;
720 }*/
721
722 /**
723 * Writes the given object to the given stream
724 */
725 /* public static void write(Writer out, Object object) throws IOException {
726 if (object instanceof String) {
727 out.write((String) object);
728 } else if (object instanceof Writable) {
729 Writable writable = (Writable) object;
730 writable.writeTo(out);
731 } else if (object instanceof InputStream || object instanceof Reader) {
732 // Copy stream to stream
733 Reader reader;
734 if (object instanceof InputStream) {
735 reader = new InputStreamReader((InputStream) object);
736 } else {
737 reader = (Reader) object;
738 }
739 char[] chars = new char[8192];
740 int i;
741 while ((i = reader.read(chars)) != -1) {
742 out.write(chars, 0, i);
743 }
744 reader.close();
745 } else {
746 out.write(toString(object));
747 }
748 }
749
750 public static int[] convertToIntArray(Object a) {
751 int[] ans = null;
752
753 // conservative coding
754 if (a.getClass().getName().equals("[I")) {
755 ans = (int[]) a;
756 } else {
757 Object[] ia = (Object[]) a;
758 ans = new int[ia.length];
759 for (int i = 0; i < ia.length; i++) {
760 ans[i] = ((Number) ia[i]).intValue();
761 }
762 }
763 return ans;
764 }
765
766 public static boolean[] convertToBooleanArray(Object a) {
767 boolean[] ans = null;
768
769 // conservative coding
770 if (a.getClass().getName().equals("[Z")) {
771 ans = (boolean[]) a;
772 } else {
773 Object[] ia = (Object[]) a;
774 ans = new boolean[ia.length];
775 for (int i = 0; i < ia.length; i++) {
776 ans[i] = ((Boolean) ia[i]).booleanValue();
777 }
778 }
779 return ans;
780 }
781
782 public static byte[] convertToByteArray(Object a) {
783 byte[] ans = null;
784
785 // conservative coding
786 if (a.getClass().getName().equals("[B")) {
787 ans = (byte[]) a;
788 } else {
789 Object[] ia = (Object[]) a;
790 ans = new byte[ia.length];
791 for (int i = 0; i < ia.length; i++) {
792 if (ia[i] != null)
793 ans[i] = ((Number) ia[i]).byteValue();
794 }
795 }
796 return ans;
797 }
798
799 public static short[] convertToShortArray(Object a) {
800 short[] ans = null;
801
802 // conservative coding
803 if (a.getClass().getName().equals("[S")) {
804 ans = (short[]) a;
805 } else {
806 Object[] ia = (Object[]) a;
807 ans = new short[ia.length];
808 for (int i = 0; i < ia.length; i++) {
809 ans[i] = ((Number) ia[i]).shortValue();
810 }
811 }
812 return ans;
813 }
814
815 public static char[] convertToCharArray(Object a) {
816 char[] ans = null;
817
818 // conservative coding
819 if (a.getClass().getName().equals("[C")) {
820 ans = (char[]) a;
821 } else {
822 Object[] ia = (Object[]) a;
823 ans = new char[ia.length];
824 for (int i = 0; i < ia.length; i++) {
825 ans[i] = ((Character) ia[i]).charValue();
826 }
827 }
828 return ans;
829 }
830
831 public static long[] convertToLongArray(Object a) {
832 long[] ans = null;
833
834 // conservative coding
835 if (a.getClass().getName().equals("[J")) {
836 ans = (long[]) a;
837 } else {
838 Object[] ia = (Object[]) a;
839 ans = new long[ia.length];
840 for (int i = 0; i < ia.length; i++) {
841 ans[i] = ((Number) ia[i]).longValue();
842 }
843 }
844 return ans;
845 }
846
847 public static float[] convertToFloatArray(Object a) {
848 float[] ans = null;
849
850 // conservative coding
851 if (a.getClass().getName().equals("[F")) {
852 ans = (float[]) a;
853 } else {
854 Object[] ia = (Object[]) a;
855 ans = new float[ia.length];
856 for (int i = 0; i < ia.length; i++) {
857 ans[i] = ((Number) ia[i]).floatValue();
858 }
859 }
860 return ans;
861 }
862
863 public static double[] convertToDoubleArray(Object a) {
864 double[] ans = null;
865
866 // conservative coding
867 if (a.getClass().getName().equals("[D")) {
868 ans = (double[]) a;
869 } else {
870 Object[] ia = (Object[]) a;
871 ans = new double[ia.length];
872 for (int i = 0; i < ia.length; i++) {
873 ans[i] = ((Number) ia[i]).doubleValue();
874 }
875 }
876 return ans;
877 }
878 */
879
880 /*
881
882 private static Integer[] SMALL_INTEGERS;
883 private static int INT_CACHE_OFFSET = 128, INT_CACHE_LEN = 256;
884
885 static {
886 SMALL_INTEGERS = new Integer[INT_CACHE_LEN];
887 for (int i = 0; i < SMALL_INTEGERS.length; i++) {
888 SMALL_INTEGERS[i] = new Integer(i - INT_CACHE_OFFSET);
889 }
890 }*/
891 }