Bug 13027 fixed: There was no autowrap into array in JIMS
[scilab.git] / scilab / modules / external_objects_java / src / java / org / scilab / modules / external_objects_java / ScilabJavaArray.java
1 /*
2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  * Copyright (C) 2010 - 2011 - Calixte DENIZET <calixte@contrib.scilab.org>
4  *
5  * This file must be used under the terms of the CeCILL.
6  * This source file is licensed as described in the file COPYING, which
7  * you should have received as part of this distribution.  The terms
8  * are also available at
9  * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
10  *
11  */
12
13 package org.scilab.modules.external_objects_java;
14
15 import java.lang.reflect.Array;
16 import java.lang.reflect.Field;
17 import java.lang.reflect.Method;
18 import java.util.ArrayList;
19 import java.util.HashMap;
20 import java.util.LinkedList;
21 import java.util.List;
22 import java.util.Map;
23 import java.util.logging.Level;
24
25 /**
26  * Tools for arrays
27  *
28  * @author Calixte DENIZET
29  */
30 @SuppressWarnings(value = {"unchecked", "serial"})
31 public final class ScilabJavaArray {
32
33     static final Map<Class, Class> mappings = new HashMap<Class, Class>(8);
34     private static final Map<String, Class> baseType = new HashMap<String, Class>(8);
35
36     static {
37         mappings.put(Double.class, double.class);
38         mappings.put(Integer.class, int.class);
39         mappings.put(Boolean.class, boolean.class);
40         mappings.put(Short.class, short.class);
41         mappings.put(Byte.class, byte.class);
42         mappings.put(Character.class, char.class);
43         mappings.put(Long.class, long.class);
44         mappings.put(Float.class, float.class);
45
46         baseType.put("double", double.class);
47         baseType.put("int", int.class);
48         baseType.put("boolean", boolean.class);
49         baseType.put("short", short.class);
50         baseType.put("long", long.class);
51         baseType.put("float", float.class);
52         baseType.put("char", char.class);
53         baseType.put("byte", byte.class);
54     }
55
56     /**
57      * Create a wrapper for a Java Array object
58      * @param className the class to use
59      * @param dims the dimensions of the resulting array
60      * @param the id of the array
61      */
62     public static int newInstance(String className, int[] dims) throws ScilabJavaException {
63         Class cl = null;
64
65         if (ScilabJavaObject.debug) {
66             StringBuffer buf = new StringBuffer();
67             buf.append("(");
68             if (dims.length > 0) {
69                 int i = 0;
70                 for (; i < dims.length - 1; i++) {
71                     buf.append(Integer.toString(dims[i]));
72                     buf.append(",");
73                 }
74                 buf.append(Integer.toString(dims[i]));
75             }
76             buf.append(")");
77             ScilabJavaObject.logger.log(Level.INFO, "Array creation: base class is \'" + className + "\' with dims=" + buf.toString());
78         }
79
80         cl = baseType.get(className);
81         if (cl == null) {
82             try {
83                 int id = ScilabClassLoader.loadJavaClass(className, false);
84                 if (id == 0) {
85                     cl = (Class) ScilabJavaObject.arraySJO[id].object;
86                 } else {
87                     cl = Class.forName(className);
88                 }
89             } catch (ClassNotFoundException e) {
90                 throw new ScilabJavaException("Cannot find the class " + className);
91             }
92         }
93
94         return new ScilabJavaObject(Array.newInstance(cl, dims)).id;
95     }
96
97     /**
98      * Get an element in an array
99      * @param array the array
100      * @param index the index of the element to get
101      * @return the element
102      */
103     public static Object get(Object array, int[] index) throws ScilabJavaException {
104         Object obj = array;
105         for (int i = 0; i < index.length; i++) {
106             if (obj != null && obj.getClass().isArray()) {
107                 if (index[i] >= 0 && index[i] < Array.getLength(obj)) {
108                     obj = Array.get(obj, index[i]);
109                 } else {
110                     throw new ScilabJavaException("Problem in retrieving " + i + "-th element: " + index[i] + ">" + (Array.getLength(obj) - 1));
111                 }
112             } else if (obj instanceof List) {
113                 List list = (List) obj;
114                 if (index[i] >= 0 && index[i] < list.size()) {
115                     obj = list.get(index[i]);
116                 } else {
117                     throw new ScilabJavaException("Problem in retrieving " + i + "-th element: " + index[i] + ">" + (list.size() - 1));
118                 }
119             } else {
120                 throw new ScilabJavaException("Problem in retrieving " + i + "-th element: it is not an array");
121             }
122         }
123
124         return obj;
125     }
126
127     /**
128      * Set an element in an array
129      * @param array the array
130      * @param index the index of the element to set
131      * @param x the element
132      */
133     public static void set(Object array, int[] index, Object x) throws ScilabJavaException {
134         Object obj = array;
135         int i = 0;
136         for (; i < index.length - 1; i++) {
137             if (obj != null && obj.getClass().isArray()) {
138                 if (index[i] >= 0 && index[i] < Array.getLength(obj)) {
139                     obj = Array.get(obj, index[i]);
140                 } else {
141                     throw new ScilabJavaException("Problem in retrieving " + i + "-th element: " + index[i] + ">" + (Array.getLength(obj) - 1));
142                 }
143             } else if (obj instanceof List) {
144                 List list = (List) obj;
145                 if (index[i] >= 0 && index[i] < list.size()) {
146                     obj = list.get(index[i]);
147                 } else {
148                     throw new ScilabJavaException("Problem in retrieving " + i + "-th element: " + index[i] + ">" + (list.size() - 1));
149                 }
150             } else {
151                 throw new ScilabJavaException("Problem in retrieving " + i + "-th element: it is not an array");
152             }
153         }
154
155         if (obj != null && obj.getClass().isArray()) {
156             if (index[i] >= 0 && index[i] < Array.getLength(obj)) {
157                 try {
158                     Array.set(obj, index[i], x);
159                 } catch (IllegalArgumentException e) {
160                     throw new ScilabJavaException("Array " + obj + " cannot contain object which is an instance of " + x.getClass());
161                 }
162             } else {
163                 throw new ScilabJavaException("Problem in setting " + index[i] + "-th element: " + index[i] + ">" + (Array.getLength(obj) - 1));
164             }
165         } else if (obj instanceof List) {
166             List list = (List) obj;
167             if (index[i] >= 0 && index[i] < list.size()) {
168                 list.set(index[i], x);
169             } else if (index[i] == list.size()) {
170                 list.add(x);
171             } else {
172                 throw new ScilabJavaException("Problem in retrieving " + i + "-th element: " + index[i] + ">" + (list.size() - 1));
173             }
174         } else {
175             throw new ScilabJavaException("Problem in retrieving " + i + "-th element: it is not an array");
176         }
177     }
178
179     /**
180      * Unbox a Double array
181      * @param a an array
182      * @return an unboxed array
183      */
184     public static double[] toPrimitive(final Double[] a) {
185         double[] arr = new double[a.length];
186         for (int i = 0; i < a.length; i++) {
187             arr[i] = a[i];
188         }
189
190         return arr;
191     }
192
193     /**
194      * Unbox a Float array
195      * @param a an array
196      * @return an unboxed array
197      */
198     public static float[] toPrimitive(final Float[] a) {
199         float[] arr = new float[a.length];
200         for (int i = 0; i < a.length; i++) {
201             arr[i] = a[i];
202         }
203
204         return arr;
205     }
206
207     /**
208      * Unbox an Integer array
209      * @param a an array
210      * @return an unboxed array
211      */
212     public static int[] toPrimitive(final Integer[] a) {
213         int[] arr = new int[a.length];
214         for (int i = 0; i < a.length; i++) {
215             arr[i] = a[i];
216         }
217
218         return arr;
219     }
220
221     /**
222      * Unbox a Character array
223      * @param a an array
224      * @return an unboxed array
225      */
226     public static char[] toPrimitive(final Character[] a) {
227         char[] arr = new char[a.length];
228         for (int i = 0; i < a.length; i++) {
229             arr[i] = a[i];
230         }
231
232         return arr;
233     }
234
235     /**
236      * Unbox a Double array
237      * @param a an array
238      * @return an unboxed array
239      */
240     public static byte[] toPrimitive(final Byte[] a) {
241         byte[] arr = new byte[a.length];
242         for (int i = 0; i < a.length; i++) {
243             arr[i] = a[i];
244         }
245
246         return arr;
247     }
248
249     /**
250      * Unbox a Short array
251      * @param a an array
252      * @return an unboxed array
253      */
254     public static short[] toPrimitive(final Short[] a) {
255         short[] arr = new short[a.length];
256         for (int i = 0; i < a.length; i++) {
257             arr[i] = a[i];
258         }
259
260         return arr;
261     }
262
263     /**
264      * Unbox a Long array
265      * @param a an array
266      * @return an unboxed array
267      */
268     public static long[] toPrimitive(final Long[] a) {
269         long[] arr = new long[a.length];
270         for (int i = 0; i < a.length; i++) {
271             arr[i] = a[i];
272         }
273
274         return arr;
275     }
276
277     /**
278      * Unbox a Boolean array
279      * @param a an array
280      * @return an unboxed array
281      */
282     public static boolean[] toPrimitive(final Boolean[] a) {
283         boolean[] arr = new boolean[a.length];
284         for (int i = 0; i < a.length; i++) {
285             arr[i] = a[i];
286         }
287
288         return arr;
289     }
290
291     /**
292      * Convert a Double (or other type of the same kind) multiarray into a primitive double multiarray.
293      * (Take care: it is not a high performance function !!! if you have a better implementation, send it to me...)
294      * @param the array to convert, allowed types are: Double, Float, Integer, Character, Byte, Boolean, Short, Long
295      * @return the primitive array.
296      */
297     public static Object toPrimitive(final Object a) {
298         Class base = a.getClass();
299         if (base.isArray()) {
300             Class[] types = getPrimClasses(base);
301             if (types == null) {
302                 return a;
303             }
304
305             if (types.length == 0) {
306                 try {
307                     Method m = ScilabJavaArray.class.getDeclaredMethod("toPrimitive", base);
308                     return m.invoke(null, a);
309                 } catch (Exception e) {
310                     return null;
311                 }
312             }
313
314             return toPrimitive(a, types.length - 1, types);
315         }
316
317         return a;
318     }
319
320     /**
321      * Recursively convert an array Double[][][] into an array double[][][]
322      * @param a the array
323      * @param pos the position in the array types
324      * @param types an array containing the intermediate array class (see getPrimClass)
325      * @return the converted array
326      */
327     private static Object toPrimitive(final Object a, int pos, Class[] types) {
328         Object[] arr = (Object[]) a;
329         Object[] o = (Object[]) Array.newInstance(types[pos], arr.length);
330
331         if (pos != 0) {
332             for (int i = 0; i < arr.length; i++) {
333                 o[i] = toPrimitive(arr[i], pos - 1, types);
334             }
335         } else {
336             try {
337                 Method m = ScilabJavaArray.class.getDeclaredMethod("toPrimitive", a.getClass().getComponentType());
338                 for (int i = 0; i < arr.length; i++) {
339                     o[i] = m.invoke(null, arr[i]);
340                 }
341             } catch (Exception e) {
342                 return null;
343             }
344         }
345
346         return o;
347     }
348
349     public static int[] toIntArray(double[] o) {
350         int[] ret = new int[o.length];
351         for (int i = 0; i < o.length; i++) {
352             ret[i] = (int) o[i];
353         }
354
355         return ret;
356     }
357
358     /**
359      * Box a double array
360      * @param a an array
361      * @return a boxed array
362      */
363     public static Double[] fromPrimitive(final double[] a) {
364         Double[] arr = new Double[a.length];
365         for (int i = 0; i < a.length; i++) {
366             arr[i] = a[i];
367         }
368
369         return arr;
370     }
371
372     /**
373      * Box a float array
374      * @param a an array
375      * @return a boxed array
376      */
377     public static Float[] fromPrimitive(final float[] a) {
378         Float[] arr = new Float[a.length];
379         for (int i = 0; i < a.length; i++) {
380             arr[i] = a[i];
381         }
382
383         return arr;
384     }
385
386     /**
387      * Box an int array
388      * @param a an array
389      * @return a boxed array
390      */
391     public static Integer[] fromPrimitive(final int[] a) {
392         Integer[] arr = new Integer[a.length];
393         for (int i = 0; i < a.length; i++) {
394             arr[i] = a[i];
395         }
396
397         return arr;
398     }
399
400     /**
401      * Box a char array
402      * @param a an array
403      * @return a boxed array
404      */
405     public static Character[] fromPrimitive(final char[] a) {
406         Character[] arr = new Character[a.length];
407         for (int i = 0; i < a.length; i++) {
408             arr[i] = a[i];
409         }
410
411         return arr;
412     }
413
414     /**
415      * Box a double array
416      * @param a an array
417      * @return a boxed array
418      */
419     public static Byte[] fromPrimitive(final byte[] a) {
420         Byte[] arr = new Byte[a.length];
421         for (int i = 0; i < a.length; i++) {
422             arr[i] = a[i];
423         }
424
425         return arr;
426     }
427
428     /**
429      * Box a short array
430      * @param a an array
431      * @return a boxed array
432      */
433     public static Short[] fromPrimitive(final short[] a) {
434         Short[] arr = new Short[a.length];
435         for (int i = 0; i < a.length; i++) {
436             arr[i] = a[i];
437         }
438
439         return arr;
440     }
441
442     /**
443      * Box a long array
444      * @param a an array
445      * @return a boxed array
446      */
447     public static Long[] fromPrimitive(final long[] a) {
448         Long[] arr = new Long[a.length];
449         for (int i = 0; i < a.length; i++) {
450             arr[i] = a[i];
451         }
452
453         return arr;
454     }
455
456     /**
457      * Box a boolean array
458      * @param a an array
459      * @return a boxed array
460      */
461     public static Boolean[] fromPrimitive(final boolean[] a) {
462         Boolean[] arr = new Boolean[a.length];
463         for (int i = 0; i < a.length; i++) {
464             arr[i] = a[i];
465         }
466
467         return arr;
468     }
469
470     /**
471      * Convert a double (or other type of the same kind) multiarray into a primitive Double multiarray.
472      * (Take care: it is not a high performance function !!! if you have a better implementation, send it to me...)
473      * @param the array to convert, allowed types are: double, float, int, char, byte, boolean, short, long
474      * @return the primitive array.
475      */
476     public static Object fromPrimitive(final Object a) {
477         Class base = a.getClass();
478         if (base.isArray()) {
479             Class[] types = getFromPrimClasses(base);
480             if (types == null) {
481                 return a;
482             }
483
484             if (types.length == 0) {
485                 try {
486                     Method m = ScilabJavaArray.class.getDeclaredMethod("fromPrimitive", base);
487                     return m.invoke(null, a);
488                 } catch (Exception e) {
489                     return null;
490                 }
491             }
492
493             return fromPrimitive(a, types.length - 1, types);
494         }
495
496         return a;
497     }
498
499     /**
500      * Recursively convert an array double[][][] into an array Double[][][]
501      * @param a the array
502      * @param pos the position in the array types
503      * @param types an array containing the intermediate array class (see getPrimClass)
504      * @return the converted array
505      */
506     private static Object fromPrimitive(final Object a, int pos, Class[] types) {
507         Object[] arr = (Object[]) a;
508         Object[] o = (Object[]) Array.newInstance(types[pos], arr.length);
509
510         if (pos != 0) {
511             for (int i = 0; i < arr.length; i++) {
512                 o[i] = fromPrimitive(arr[i], pos - 1, types);
513             }
514         } else {
515             try {
516                 Method m = ScilabJavaArray.class.getDeclaredMethod("fromPrimitive", a.getClass().getComponentType());
517                 for (int i = 0; i < arr.length; i++) {
518                     o[i] = m.invoke(null, arr[i]);
519                 }
520             } catch (Exception e) {
521                 return null;
522             }
523         }
524
525         return o;
526     }
527
528     /**
529      * Get array base type
530      * @param c the Class
531      * @return the base
532      */
533     public static Class getArrayBaseType(Class c) {
534         Class base = c;
535         while (base.isArray()) {
536             base = base.getComponentType();
537         }
538
539         return base;
540     }
541
542     /**
543      * Get array info: base Class and number of dimensions
544      * @param c the Class
545      * @return info
546      */
547     public static Object[] getArrayInfo(Class c) {
548         Class base = c;
549         int dims = 0;
550         while (base.isArray()) {
551             base = base.getComponentType();
552             dims++;
553         }
554
555         return new Object[] {base, new Integer(dims)};
556     }
557
558     /**
559      * Get an array of primitive arrays classes. For example, double[][][][] will give {Double[], Double[][], Double[][][]}.
560      * @param c the base class
561      * @return an array of classes
562      */
563     private static Class[] getFromPrimClasses(Class c) {
564         int nbDims = 0;
565         Class base = c;
566         while (base.isArray()) {
567             base = base.getComponentType();
568             nbDims++;
569         }
570
571         base = ScilabJavaObject.primTypes.get(base);
572         if (base == null) {
573             return null;
574         }
575
576         Class[] cl = new Class[nbDims - 1];
577         if (cl.length != 0) {
578             cl[0] = Array.newInstance(base, 0).getClass();
579             for (int i = 1; i < nbDims - 1; i++) {
580                 cl[i] = Array.newInstance(cl[i - 1], 0).getClass();
581             }
582         }
583
584         return cl;
585     }
586
587     /**
588      * Get an array of primitive arrays classes. For example, Double[][][][] will give {double[], double[][], double[][][]}.
589      * @param c the base class
590      * @return an array of classes
591      */
592     private static Class[] getPrimClasses(Class c) {
593         int nbDims = 0;
594         Class base = c;
595         while (base.isArray()) {
596             base = base.getComponentType();
597             nbDims++;
598         }
599
600         base = mappings.get(base);
601         if (base == null) {
602             return null;
603         }
604
605         Class[] cl = new Class[nbDims - 1];
606         if (cl.length != 0) {
607             cl[0] = Array.newInstance(base, 0).getClass();
608             for (int i = 1; i < nbDims - 1; i++) {
609                 cl[i] = Array.newInstance(cl[i - 1], 0).getClass();
610             }
611         }
612
613         return cl;
614     }
615
616     /**
617      * Convert a bi-dimensional array into one-dim one
618      * @param x the bi-dim array
619      * @return a one-dim array
620      */
621     public static byte[] toOneDim(byte[][] x) {
622         if (x.length == 0 || x[0].length == 0) {
623             return new byte[0];
624         }
625
626         final int len = x[0].length;
627         final byte[] ret = new byte[x.length * len];
628         for (int i = 0, s = 0; i < x.length; i++, s += len) {
629             System.arraycopy(x[i], 0, ret, s, len);
630         }
631
632         return ret;
633     }
634
635     /**
636      * Convert a bi-dimensional array into one-dim one
637      * @param x the bi-dim array
638      * @return a one-dim array
639      */
640     public static short[] toOneDim(short[][] x) {
641         if (x.length == 0 || x[0].length == 0) {
642             return new short[0];
643         }
644
645         final int len = x[0].length;
646         final short[] ret = new short[x.length * len];
647         for (int i = 0, s = 0; i < x.length; i++, s += len) {
648             System.arraycopy(x[i], 0, ret, s, len);
649         }
650
651         return ret;
652     }
653
654     /**
655      * Convert a bi-dimensional array into one-dim one
656      * @param x the bi-dim array
657      * @return a one-dim array
658      */
659     public static int[] toOneDim(int[][] x) {
660         if (x.length == 0 || x[0].length == 0) {
661             return new int[0];
662         }
663
664         final int len = x[0].length;
665         final int[] ret = new int[x.length * len];
666         for (int i = 0, s = 0; i < x.length; i++, s += len) {
667             System.arraycopy(x[i], 0, ret, s, len);
668         }
669
670         return ret;
671     }
672
673     /**
674      * Convert a bi-dimensional array into one-dim one
675      * @param x the bi-dim array
676      * @return a one-dim array
677      */
678     public static long[] toOneDim(long[][] x) {
679         if (x.length == 0 || x[0].length == 0) {
680             return new long[0];
681         }
682
683         final int len = x[0].length;
684         final long[] ret = new long[x.length * len];
685         for (int i = 0, s = 0; i < x.length; i++, s += len) {
686             System.arraycopy(x[i], 0, ret, s, len);
687         }
688
689         return ret;
690     }
691
692     /**
693      * Convert a bi-dimensional array into one-dim one
694      * @param x the bi-dim array
695      * @return a one-dim array
696      */
697     public static float[] toOneDim(float[][] x) {
698         if (x.length == 0 || x[0].length == 0) {
699             return new float[0];
700         }
701
702         final int len = x[0].length;
703         final float[] ret = new float[x.length * len];
704         for (int i = 0, s = 0; i < x.length; i++, s += len) {
705             System.arraycopy(x[i], 0, ret, s, len);
706         }
707
708         return ret;
709     }
710
711     /**
712      * Convert a bi-dimensional array into one-dim one
713      * @param x the bi-dim array
714      * @return a one-dim array
715      */
716     public static double[] toOneDim(double[][] x) {
717         if (x.length == 0 || x[0].length == 0) {
718             return new double[0];
719         }
720
721         final int len = x[0].length;
722         final double[] ret = new double[x.length * len];
723         for (int i = 0, s = 0; i < x.length; i++, s += len) {
724             System.arraycopy(x[i], 0, ret, s, len);
725         }
726
727         return ret;
728     }
729
730     /**
731      * Convert a bi-dimensional array into one-dim one
732      * @param x the bi-dim array
733      * @return a one-dim array
734      */
735     public static char[] toOneDim(char[][] x) {
736         if (x.length == 0 || x[0].length == 0) {
737             return new char[0];
738         }
739
740         final int len = x[0].length;
741         final char[] ret = new char[x.length * len];
742         for (int i = 0, s = 0; i < x.length; i++, s += len) {
743             System.arraycopy(x[i], 0, ret, s, len);
744         }
745
746         return ret;
747     }
748
749     /**
750      * Convert a bi-dimensional array into one-dim one
751      * @param x the bi-dim array
752      * @return a one-dim array
753      */
754     static Object toOneDim(Object x) {
755         Class base = getArrayBaseType(x.getClass());
756
757         if (base.isPrimitive()) {
758             try {
759                 Method m = ScilabJavaArray.class.getDeclaredMethod("toOneDim", x.getClass());
760                 return m.invoke(null, x);
761             } catch (Exception e) {
762                 return null;
763             }
764         } else {
765             Object[][] xx = (Object[][]) x;
766
767             if (xx.length == 0 || xx[0].length == 0) {
768                 return Array.newInstance(base, 0);
769             }
770
771             final int len = xx[0].length;
772             final Object ret = Array.newInstance(base, xx.length * len);
773             for (int i = 0, s = 0; i < xx.length; i++, s += len) {
774                 System.arraycopy(xx[i], 0, ret, s, len);
775             }
776
777             return ret;
778         }
779     }
780
781     /**
782      * Convert a one-dimensional array into bi-dim one
783      * @param x the one-dim array
784      * @return a bi-dim array
785      */
786     static Object toBiDim(Object x) {
787         Object ret = Array.newInstance(x.getClass(), 1);
788         Array.set(ret, 0, x);
789
790         return ret;
791     }
792
793     /**
794      * Convert a one-dimensional array into bi-dim one
795      * @param x the one-dim array
796      * @return a bi-dim array
797      */
798     static Object singleToOneDim(Class base, Object x) {
799         Object ret = Array.newInstance(base, 1);
800         Array.set(ret, 0, x);
801
802         return ret;
803     }
804
805     /**
806      * Convert a list to an array of primitive type
807      * @return an array
808      */
809     public static double[] toDoubleArray(List<Double> l) {
810         double[] arr = new double[l.size()];
811         int i = 0;
812         for (Double d : l) {
813             arr[i++] = d;
814         }
815
816         return arr;
817     }
818
819     /**
820      * Convert a list to an array of primitive type
821      * @return an array
822      */
823     public static float[] toFloatArray(List<Float> l) {
824         float[] arr = new float[l.size()];
825         int i = 0;
826         for (Float f : l) {
827             arr[i++] = f;
828         }
829
830         return arr;
831     }
832
833     /**
834      * Convert a list to an array of primitive type
835      * @return an array
836      */
837     public static byte[] toByteArray(List<Byte> l) {
838         byte[] arr = new byte[l.size()];
839         int i = 0;
840         for (Byte b : l) {
841             arr[i++] = b;
842         }
843
844         return arr;
845     }
846
847     /**
848      * Convert a list to an array of primitive type
849      * @return an array
850      */
851     public static short[] toShortArray(List<Short> l) {
852         short[] arr = new short[l.size()];
853         int i = 0;
854         for (Short s : l) {
855             arr[i++] = s;
856         }
857
858         return arr;
859     }
860
861     /**
862      * Convert a list to an array of primitive type
863      * @return an array
864      */
865     public static int[] toIntArray(List<Integer> l) {
866         int[] arr = new int[l.size()];
867         int i = 0;
868         for (Integer in : l) {
869             arr[i++] = in;
870         }
871
872         return arr;
873     }
874
875     /**
876      * Convert a list to an array of primitive type
877      * @return an array
878      */
879     public static long[] toLongArray(List<Long> l) {
880         long[] arr = new long[l.size()];
881         int i = 0;
882         for (Long lo : l) {
883             arr[i++] = lo;
884         }
885
886         return arr;
887     }
888
889     /**
890      * Convert a list to an array of primitive type
891      * @return an array
892      */
893     public static String[] toStringArray(List<String> l) {
894         return l.toArray(new String[l.size()]);
895     }
896
897     /**
898      * Convert a list to an array of primitive type
899      * @return an array
900      */
901     public static boolean[] toBooleanArray(List<Boolean> l) {
902         boolean[] arr = new boolean[l.size()];
903         int i = 0;
904         for (Boolean b : l) {
905             arr[i++] = b;
906         }
907
908         return arr;
909     }
910
911     /**
912      * Convert a list to an array of primitive type
913      * @return an array
914      */
915     public static char[] toCharArray(List<Character> l) {
916         char[] arr = new char[l.size()];
917         int i = 0;
918         for (Character c : l) {
919             arr[i++] = c;
920         }
921
922         return arr;
923     }
924
925     /**
926      * Convert a list to an array of primitive type
927      * @return an array
928      */
929     public static List toList(Object obj) {
930         if (obj.getClass().isArray()) {
931             Class base = obj.getClass().getComponentType();
932             if (ScilabJavaObject.primTypes.containsKey(base)) {
933                 obj = fromPrimitive(obj);
934             }
935             ArrayList list = new ArrayList();
936             try {
937                 Field _elementData = ArrayList.class.getDeclaredField("elementData");
938                 Field _size = ArrayList.class.getDeclaredField("size");
939                 _elementData.setAccessible(true);
940                 _size.setAccessible(true);
941                 _elementData.set(list, obj);
942                 _size.set(list, ((Object[]) obj).length);
943             } catch (Exception e) {
944                 e.printStackTrace();
945             }
946
947             return list;
948         }
949
950         List l = new LinkedList();
951         l.add(obj);
952
953         return l;
954     }
955 }