b7cd956d35915da7c0561b7d08126e2473a91d97
[scilab.git] / scilab / modules / types / src / java / org / scilab / modules / types / ScilabVariables.java
1 /*
2  * Scilab (http://www.scilab.org/) - This file is part of Scilab
3  * Copyright (C) 2011 - DIGITEO - Calixte DENIZET
4  * Copyright (C) 2013 - Scilab Enterprises - Calixte DENIZET
5  *
6  * Copyright (C) 2012 - 2016 - Scilab Enterprises
7  *
8  * This file is hereby licensed under the terms of the GNU GPL v2.0,
9  * pursuant to article 5.3.4 of the CeCILL v.2.1.
10  * This file was originally licensed under the terms of the CeCILL v2.1,
11  * and continues to be available under such terms.
12  * For more information, see the COPYING file which you should have received
13  * along with this program.
14  *
15  */
16
17 package org.scilab.modules.types;
18
19 import java.nio.ByteBuffer;
20 import java.nio.DoubleBuffer;
21 import java.nio.IntBuffer;
22 import java.nio.LongBuffer;
23 import java.nio.ShortBuffer;
24 import java.util.ArrayList;
25 import java.util.HashMap;
26 import java.util.Map;
27 import java.util.Vector;
28
29 /**
30  * Class to handle the Scilab data retrievment and conversion to a ScilabType
31  * object. All the functions sendFoo are used from C++ and should not be used on
32  * the Java side.
33  *
34  * An handler which implements ScilabVariablesHandler must be used to achieve
35  * the retrievment. The id returned by addScilabVariablesHandler must be passed
36  * from C/C++ to functions in the class org_modules_types::ScilabToJava to
37  * guarantee that the correct handler would receive its datas.
38  */
39 public final class ScilabVariables {
40
41     private static final Map<Thread, ArrayList<ScilabType>> lists = new HashMap<Thread, ArrayList<ScilabType>>();
42     private static final Vector<ScilabVariablesHandler> handlers = new Vector<ScilabVariablesHandler>();
43
44     /**
45      * Register a new handler
46      *
47      * @param handler
48      *            the handler
49      * @return the id to use from C/C++
50      */
51     public static final int addScilabVariablesHandler(ScilabVariablesHandler handler) {
52         int i = 0;
53         for (; i < handlers.size(); i++) {
54             ScilabVariablesHandler h = handlers.get(i);
55             if (h == handler) {
56                 return i;
57             } else if (h == null) {
58                 handlers.set(i, handler);
59                 return i;
60             }
61         }
62         handlers.add(handler);
63
64         return i;
65     }
66
67     /**
68      * Unregister an handler (the id must be considered as lost !!)
69      *
70      * @param handler
71      *            the handler to remove
72      */
73     public static final void removeScilabVariablesHandler(ScilabVariablesHandler handler) {
74         if (handler != null) {
75             for (int i = 0; i < handlers.size(); i++) {
76                 if (handlers.get(i) == handler) {
77                     handlers.set(i, null);
78                 }
79             }
80         }
81     }
82
83     /**
84      * Unregister an handler with a given id (the id must be considered as lost
85      * !!)
86      *
87      * @param id
88      *            the handler id to remove
89      */
90     public static final void removeScilabVariablesHandler(int id) {
91         if (id >= 0 && id < handlers.size()) {
92             handlers.set(id, null);
93         }
94     }
95
96     /**
97      * Send double matrix
98      *
99      * @param varName
100      *            the variable name
101      * @param indexes
102      *            an integer array with the indexes of the (sub)*-list which
103      *            will contain the data
104      * @param data
105      *            the data
106      * @param swaped
107      *            true if the matrix is stored row by row
108      * @param handlerId
109      *            the handler id
110      */
111     public static final void sendData(String varName, int[] indexes, double[][] data, boolean swaped, int handlerId) {
112         if (indexes.length != 0) {
113             addElement(indexes, new ScilabDouble(null, data, null, swaped));
114         } else {
115             handlers.get(handlerId).handle(new ScilabDouble(varName, data, null, swaped));
116         }
117     }
118
119     /**
120      * Send double matrix as DoubleBuffer
121      *
122      * @param varName
123      *            the variable name
124      * @param indexes
125      *            an integer array with the indexes of the (sub)*-list which
126      *            will contain the data
127      * @param data
128      *            the data
129      * @param handlerId
130      *            the handler id
131      */
132     public static final void sendDataAsBuffer(String varName, int[] indexes, DoubleBuffer data, int rows, int cols, int handlerId) {
133         if (indexes.length != 0) {
134             addElement(indexes, new ScilabDoubleReference(null, data, null, rows, cols));
135         } else {
136             handlers.get(handlerId).handle(new ScilabDoubleReference(varName, data, null, rows, cols));
137         }
138     }
139
140     /**
141      * Send complex matrix
142      *
143      * @param varName
144      *            the variable name
145      * @param indexes
146      *            an integer array with the indexes of the (sub)*-list which
147      *            will contain the data
148      * @param real
149      *            the real data
150      * @param img
151      *            the imaginary data
152      * @param swaped
153      *            true if the matrix is stored row by row
154      * @param handlerId
155      *            the handler id
156      */
157     public static final void sendData(String varName, int[] indexes, double[][] real, double[][] img, boolean swaped, int handlerId) {
158         if (indexes.length != 0) {
159             addElement(indexes, new ScilabDouble(null, real, img, swaped));
160         } else {
161             handlers.get(handlerId).handle(new ScilabDouble(varName, real, img, swaped));
162         }
163     }
164
165     /**
166      * Send complex matrix as DoubleBuffer
167      *
168      * @param varName
169      *            the variable name
170      * @param indexes
171      *            an integer array with the indexes of the (sub)*-list which
172      *            will contain the data
173      * @param handlerId
174      *            the handler id
175      */
176     public static final void sendDataAsBuffer(String varName, int[] indexes, DoubleBuffer real, DoubleBuffer imag, int rows, int cols, int handlerId) {
177         if (indexes.length != 0) {
178             addElement(indexes, new ScilabDoubleReference(null, real, imag, rows, cols));
179         } else {
180             handlers.get(handlerId).handle(new ScilabDoubleReference(varName, real, imag, rows, cols));
181         }
182     }
183
184     /**
185      * Send int32 matrix
186      *
187      * @param varName
188      *            the variable name
189      * @param indexes
190      *            an integer array with the indexes of the (sub)*-list which
191      *            will contain the data
192      * @param data
193      *            the data
194      * @param swaped
195      *            true if the matrix is stored row by row
196      * @param handlerId
197      *            the handler id
198      */
199     public static final void sendData(String varName, int[] indexes, int[][] data, boolean swaped, int handlerId) {
200         if (indexes.length != 0) {
201             addElement(indexes, new ScilabInteger(null, data, false, swaped));
202         } else {
203             handlers.get(handlerId).handle(new ScilabInteger(varName, data, false, swaped));
204         }
205     }
206
207     /**
208      * Send int32 matrix as IntBuffer
209      *
210      * @param varName
211      *            the variable name
212      * @param indexes
213      *            an integer array with the indexes of the (sub)*-list which
214      *            will contain the data
215      * @param data
216      *            the data
217      * @param handlerId
218      *            the handler id
219      */
220     public static final void sendDataAsBuffer(String varName, int[] indexes, IntBuffer data, int rows, int cols, int handlerId) {
221         if (indexes.length != 0) {
222             addElement(indexes, new ScilabIntegerReference(null, data, rows, cols, false));
223         } else {
224             handlers.get(handlerId).handle(new ScilabIntegerReference(varName, data, rows, cols, false));
225         }
226     }
227
228     /**
229      * Send uint16 matrix
230      *
231      * @param varName
232      *            the variable name
233      * @param indexes
234      *            an integer array with the indexes of the (sub)*-list which
235      *            will contain the data
236      * @param data
237      *            the data
238      * @param swaped
239      *            true if the matrix is stored row by row
240      * @param handlerId
241      *            the handler id
242      */
243     public static final void sendUnsignedData(String varName, int[] indexes, short[][] data, boolean swaped, int handlerId) {
244         if (indexes.length != 0) {
245             addElement(indexes, new ScilabInteger(null, data, true, swaped));
246         } else {
247             handlers.get(handlerId).handle(new ScilabInteger(varName, data, true, swaped));
248         }
249     }
250
251     /**
252      * Send uint16 matrix as ShortBuffer
253      *
254      * @param varName
255      *            the variable name
256      * @param indexes
257      *            an integer array with the indexes of the (sub)*-list which
258      *            will contain the data
259      * @param data
260      *            the data
261      * @param handlerId
262      *            the handler id
263      */
264     public static final void sendUnsignedDataAsBuffer(String varName, int[] indexes, ShortBuffer data, int rows, int cols, int handlerId) {
265         if (indexes.length != 0) {
266             addElement(indexes, new ScilabIntegerReference(null, data, rows, cols, true));
267         } else {
268             handlers.get(handlerId).handle(new ScilabIntegerReference(varName, data, rows, cols, true));
269         }
270     }
271
272     /**
273      * Send int16 matrix
274      *
275      * @param varName
276      *            the variable name
277      * @param indexes
278      *            an integer array with the indexes of the (sub)*-list which
279      *            will contain the data
280      * @param data
281      *            the data
282      * @param swaped
283      *            true if the matrix is stored row by row
284      * @param handlerId
285      *            the handler id
286      */
287     public static final void sendData(String varName, int[] indexes, short[][] data, boolean swaped, int handlerId) {
288         if (indexes.length != 0) {
289             addElement(indexes, new ScilabInteger(null, data, false, swaped));
290         } else {
291             handlers.get(handlerId).handle(new ScilabInteger(varName, data, false, swaped));
292         }
293     }
294
295     /**
296      * Send int16 matrix as ShortBuffer
297      *
298      * @param varName
299      *            the variable name
300      * @param indexes
301      *            an integer array with the indexes of the (sub)*-list which
302      *            will contain the data
303      * @param data
304      *            the data
305      * @param handlerId
306      *            the handler id
307      */
308     public static final void sendDataAsBuffer(String varName, int[] indexes, ShortBuffer data, int rows, int cols, int handlerId) {
309         if (indexes.length != 0) {
310             addElement(indexes, new ScilabIntegerReference(null, data, rows, cols, false));
311         } else {
312             handlers.get(handlerId).handle(new ScilabIntegerReference(varName, data, rows, cols, false));
313         }
314     }
315
316     /**
317      * Send uint8 matrix
318      *
319      * @param varName
320      *            the variable name
321      * @param indexes
322      *            an integer array with the indexes of the (sub)*-list which
323      *            will contain the data
324      * @param data
325      *            the data
326      * @param swaped
327      *            true if the matrix is stored row by row
328      * @param handlerId
329      *            the handler id
330      */
331     public static final void sendUnsignedData(String varName, int[] indexes, byte[][] data, boolean swaped, int handlerId) {
332         if (indexes.length != 0) {
333             addElement(indexes, new ScilabInteger(null, data, true, swaped));
334         } else {
335             handlers.get(handlerId).handle(new ScilabInteger(varName, data, true, swaped));
336         }
337     }
338
339     /**
340      * Send uint8 matrix as ByteBuffer
341      *
342      * @param varName
343      *            the variable name
344      * @param indexes
345      *            an integer array with the indexes of the (sub)*-list which
346      *            will contain the data
347      * @param data
348      *            the data
349      * @param handlerId
350      *            the handler id
351      */
352     public static final void sendUnsignedDataAsBuffer(String varName, int[] indexes, ByteBuffer data, int rows, int cols, int handlerId) {
353         if (indexes.length != 0) {
354             addElement(indexes, new ScilabIntegerReference(null, data, rows, cols, true));
355         } else {
356             handlers.get(handlerId).handle(new ScilabIntegerReference(varName, data, rows, cols, true));
357         }
358     }
359
360     /**
361      * Send boolean matrix
362      *
363      * @param varName
364      *            the variable name
365      * @param indexes
366      *            an integer array with the indexes of the (sub)*-list which
367      *            will contain the data
368      * @param data
369      *            the data
370      * @param swaped
371      *            true if the matrix is stored row by row
372      * @param handlerId
373      *            the handler id
374      */
375     public static final void sendData(String varName, int[] indexes, boolean[][] data, boolean swaped, int handlerId) {
376         if (indexes.length != 0) {
377             addElement(indexes, new ScilabBoolean(null, data, swaped));
378         } else {
379             handlers.get(handlerId).handle(new ScilabBoolean(varName, data, swaped));
380         }
381     }
382
383     /**
384      * Send boolean matrix as reference
385      *
386      * @param varName
387      *            the variable name
388      * @param indexes
389      *            an integer array with the indexes of the (sub)*-list which
390      *            will contain the data
391      * @param data
392      *            the data
393      * @param handlerId
394      *            the handler id
395      */
396     public static final void sendBooleanDataAsBuffer(String varName, int[] indexes, IntBuffer data, int rows, int cols, int handlerId) {
397         if (indexes.length != 0) {
398             addElement(indexes, new ScilabBooleanReference(null, data, rows, cols));
399         } else {
400             handlers.get(handlerId).handle(new ScilabBooleanReference(varName, data, rows, cols));
401         }
402     }
403
404     /**
405      * Send int8 matrix
406      *
407      * @param varName
408      *            the variable name
409      * @param indexes
410      *            an integer array with the indexes of the (sub)*-list which
411      *            will contain the data
412      * @param data
413      *            the data
414      * @param swaped
415      *            true if the matrix is stored row by row
416      * @param handlerId
417      *            the handler id
418      */
419     public static final void sendData(String varName, int[] indexes, byte[][] data, boolean swaped, int handlerId) {
420         if (indexes.length != 0) {
421             addElement(indexes, new ScilabInteger(null, data, false, swaped));
422         } else {
423             handlers.get(handlerId).handle(new ScilabInteger(varName, data, false, swaped));
424         }
425     }
426
427     /**
428      * Send int8 matrix as ByteBuffer
429      *
430      * @param varName
431      *            the variable name
432      * @param indexes
433      *            an integer array with the indexes of the (sub)*-list which
434      *            will contain the data
435      * @param data
436      *            the data
437      * @param handlerId
438      *            the handler id
439      */
440     public static final void sendDataAsBuffer(String varName, int[] indexes, ByteBuffer data, int rows, int cols, int handlerId) {
441         if (indexes.length != 0) {
442             addElement(indexes, new ScilabIntegerReference(null, data, rows, cols, false));
443         } else {
444             handlers.get(handlerId).handle(new ScilabIntegerReference(varName, data, rows, cols, false));
445         }
446     }
447
448     /**
449      * Send int64 or uint64 matrix
450      *
451      * @param varName
452      *            the variable name
453      * @param indexes
454      *            an integer array with the indexes of the (sub)*-list which
455      *            will contain the data
456      * @param data
457      *            the data
458      * @param swaped
459      *            true if the matrix is stored row by row
460      * @param handlerId
461      *            the handler id
462      */
463     public static final void sendData(String varName, int[] indexes, long[][] data, boolean swaped, int handlerId) {
464         if (indexes.length != 0) {
465             addElement(indexes, new ScilabInteger(null, data, false, swaped));
466         } else {
467             handlers.get(handlerId).handle(new ScilabInteger(varName, data, false, swaped));
468         }
469     }
470
471     /**
472      * Send int64 or uint64 matrix as LongBuffer
473      *
474      * @param varName
475      *            the variable name
476      * @param indexes
477      *            an integer array with the indexes of the (sub)*-list which
478      *            will contain the data
479      * @param data
480      *            the data
481      * @param handlerId
482      *            the handler id
483      */
484     public static final void sendDataAsBuffer(String varName, int[] indexes, LongBuffer data, int rows, int cols, int handlerId) {
485         if (indexes.length != 0) {
486             addElement(indexes, new ScilabIntegerReference(null, data, rows, cols, false));
487         } else {
488             handlers.get(handlerId).handle(new ScilabIntegerReference(varName, data, rows, cols, false));
489         }
490     }
491
492     /**
493      * Send uint32 matrix
494      *
495      * @param varName
496      *            the variable name
497      * @param indexes
498      *            an integer array with the indexes of the (sub)*-list which
499      *            will contain the data
500      * @param data
501      *            the data
502      * @param swaped
503      *            true if the matrix is stored row by row
504      * @param handlerId
505      *            the handler id
506      */
507     public static final void sendUnsignedData(String varName, int[] indexes, int[][] data, boolean swaped, int handlerId) {
508         if (indexes.length != 0) {
509             addElement(indexes, new ScilabInteger(null, data, true, swaped));
510         } else {
511             handlers.get(handlerId).handle(new ScilabInteger(varName, data, true, swaped));
512         }
513     }
514
515     /**
516      * Send uint32 matrix as IntBuffer
517      *
518      * @param varName
519      *            the variable name
520      * @param indexes
521      *            an integer array with the indexes of the (sub)*-list which
522      *            will contain the data
523      * @param data
524      *            the data
525      * @param handlerId
526      *            the handler id
527      */
528     public static final void sendUnsignedDataAsBuffer(String varName, int[] indexes, IntBuffer data, int rows, int cols, int handlerId) {
529         if (indexes.length != 0) {
530             addElement(indexes, new ScilabIntegerReference(null, data, rows, cols, true));
531         } else {
532             handlers.get(handlerId).handle(new ScilabIntegerReference(varName, data, rows, cols, true));
533         }
534     }
535
536     /**
537      * Send string matrix
538      *
539      * @param varName
540      *            the variable name
541      * @param indexes
542      *            an integer array with the indexes of the (sub)*-list which
543      *            will contain the data
544      * @param data
545      *            the data
546      * @param swaped
547      *            true if the matrix is stored row by row
548      * @param handlerId
549      *            the handler id
550      */
551     public static final void sendData(String varName, int[] indexes, String[][] data, boolean swaped, int handlerId) {
552         if (indexes.length != 0) {
553             addElement(indexes, new ScilabString(null, data, swaped));
554         } else {
555             handlers.get(handlerId).handle(new ScilabString(varName, data, swaped));
556         }
557     }
558
559     /**
560      * Send double sparse matrix
561      *
562      * @param varName
563      *            the variable name
564      * @param indexes
565      *            an integer array with the indexes of the (sub)*-list which
566      *            will contain the data
567      * @param row
568      *            the row number
569      * @param col
570      *            the col number
571      * @param nbItem
572      *            the number of non null elements
573      * @param nbItemRow
574      *            the number by row of non null elements
575      * @param colPos
576      *            the column position of the non null elements
577      * @param data
578      *            the data
579      * @param handlerId
580      *            the handler id
581      */
582     public static final void sendData(String varName, int[] indexes, int row, int col, int nbItem, int[] nbItemRow, int[] colPos, double[] data, int handlerId) {
583         if (indexes.length != 0) {
584             addElement(indexes, new ScilabSparse(null, row, col, nbItem, nbItemRow, colPos, data, null));
585         } else {
586             handlers.get(handlerId).handle(new ScilabSparse(varName, row, col, nbItem, nbItemRow, colPos, data, null));
587         }
588     }
589
590     /**
591      * Send double sparse matrix as buffer
592      * Useless for now due to Scilab limitations (A=sparse(...);A(1,1)=123; a new A is created so references are lost)
593      *
594      * @param varName
595      *            the variable name
596      * @param indexes
597      *            an integer array with the indexes of the (sub)*-list which
598      *            will contain the data
599      * @param row
600      *            the row number
601      * @param col
602      *            the col number
603      * @param nbItem
604      *            the number of non null elements
605      * @param nbItemRow
606      *            the number by row of non null elements
607      * @param colPos
608      *            the column position of the non null elements
609      * @param data
610      *            the data
611      * @param handlerId
612      *            the handler id
613      */
614     /*public static final void sendDataAsBuffer(String varName, int[] indexes, int row, int col, int nbItem, IntBuffer nbItemRow, IntBuffer colPos, DoubleBuffer data, int handlerId) {
615       if (indexes.length != 0) {
616       addElement(indexes, new ScilabSparseReference(null, row, col, nbItem, nbItemRow, colPos, data, null));
617       } else {
618       handlers.get(handlerId).handle(new ScilabSparseReference(varName, row, col, nbItem, nbItemRow, colPos, data, null));
619       }
620       }*/
621
622     /**
623      * Send complex sparse matrix
624      *
625      * @param varName
626      *            the variable name
627      * @param indexes
628      *            an integer array with the indexes of the (sub)*-list which
629      *            will contain the data
630      * @param row
631      *            the row number
632      * @param col
633      *            the col number
634      * @param nbItem
635      *            the number of non null elements
636      * @param nbItemRow
637      *            the number by row of non null elements
638      * @param colPos
639      *            the column position of the non null elements
640      * @param real
641      *            the real data
642      * @param imag
643      *            the imaginary data
644      * @param handlerId
645      *            the handler id
646      */
647     public static final void sendData(String varName, int[] indexes, int row, int col, int nbItem, int[] nbItemRow, int[] colPos, double[] real, double[] imag, int handlerId) {
648         if (indexes.length != 0) {
649             addElement(indexes, new ScilabSparse(null, row, col, nbItem, nbItemRow, colPos, real, imag));
650         } else {
651             handlers.get(handlerId).handle(new ScilabSparse(varName, row, col, nbItem, nbItemRow, colPos, real, imag));
652         }
653     }
654
655     /**
656      * Send complex sparse matrix as buffer
657      * Useless for now due to Scilab limitations (A=sparse(...);A(1,1)=123; a new A is created so references are lost)
658      *
659      * @param varName
660      *            the variable name
661      * @param indexes
662      *            an integer array with the indexes of the (sub)*-list which
663      *            will contain the data
664      * @param row
665      *            the row number
666      * @param col
667      *            the col number
668      * @param nbItem
669      *            the number of non null elements
670      * @param nbItemRow
671      *            the number by row of non null elements
672      * @param colPos
673      *            the column position of the non null elements
674      * @param real
675      *            the real data
676      * @param imag
677      *            the imaginary data
678      * @param handlerId
679      *            the handler id
680      */
681     /*private static final void sendDataAsBuffer(String varName, int[] indexes, int row, int col, int nbItem, IntBuffer nbItemRow, IntBuffer colPos, DoubleBuffer real, DoubleBuffer imag, int handlerId) {
682       if (indexes.length != 0) {
683       addElement(indexes, new ScilabSparse(null, row, col, nbItem, nbItemRow, colPos, real, imag));
684       } else {
685       handlers.get(handlerId).handle(new ScilabSparse(varName, row, col, nbItem, nbItemRow, colPos, real, imag));
686       }
687       }*/
688
689     /**
690      * Send boolean sparse matrix
691      * Useless for now due to Scilab limitations (A=sparse(...);A(1,1)=123; a new A is created so references are lost)
692      *
693      * @param varName
694      *            the variable name
695      * @param indexes
696      *            an integer array with the indexes of the (sub)*-list which
697      *            will contain the data
698      * @param row
699      *            the row number
700      * @param col
701      *            the col number
702      * @param nbItem
703      *            the number of true elements
704      * @param nbItemRow
705      *            the number by row of true elements
706      * @param colPos
707      *            the column position of the true elements
708      * @param handlerId
709      *            the handler id
710      */
711     private static final void sendData(String varName, int[] indexes, int row, int col, int nbItem, int[] nbItemRow, int[] colPos, int handlerId) {
712         if (indexes.length != 0) {
713             addElement(indexes, new ScilabBooleanSparse(null, row, col, nbItem, nbItemRow, colPos));
714         } else {
715             handlers.get(handlerId).handle(new ScilabBooleanSparse(varName, row, col, nbItem, nbItemRow, colPos));
716         }
717     }
718
719     /**
720      * Send boolean sparse matrix as Buffer
721      *
722      * @param varName
723      *            the variable name
724      * @param indexes
725      *            an integer array with the indexes of the (sub)*-list which
726      *            will contain the data
727      * @param row
728      *            the row number
729      * @param col
730      *            the col number
731      * @param nbItem
732      *            the number of true elements
733      * @param nbItemRow
734      *            the number by row of true elements
735      * @param colPos
736      *            the column position of the true elements
737      * @param handlerId
738      *            the handler id
739      */
740     /*public static final void sendDataAsBuffer(String varName, int[] indexes, int row, int col, int nbItem, IntBuffer nbItemRow, IntBuffer colPos, int handlerId) {
741       if (indexes.length != 0) {
742       addElement(indexes, new ScilabBooleanSparse(null, row, col, nbItem, nbItemRow, colPos));
743       } else {
744       handlers.get(handlerId).handle(new ScilabBooleanSparse(varName, row, col, nbItem, nbItemRow, colPos));
745       }
746       }*/
747
748     /**
749      * Send double polynomial matrix
750      *
751      * @param varName
752      *            the variable name
753      * @param indexes
754      *            an integer array with the indexes of the (sub)*-list which
755      *            will contain the data
756      * @param polyVarName
757      *            the polynomial variable name
758      * @param data
759      *            the data
760      * @param swaped
761      *            true if the matrix is stored row by row
762      * @param handlerId
763      *            the handler id
764      */
765     public static final void sendPolynomial(String varName, int[] indexes, String polyVarName, double[][][] data, boolean swaped, int handlerId) {
766         if (indexes.length != 0) {
767             addElement(indexes, new ScilabPolynomial(null, polyVarName, data, null, swaped));
768         } else {
769             handlers.get(handlerId).handle(new ScilabPolynomial(varName, polyVarName, data, null, swaped));
770         }
771     }
772
773     /**
774      * Send complex polynomial matrix
775      *
776      * @param varName
777      *            the variable name
778      * @param indexes
779      *            an integer array with the indexes of the (sub)*-list which
780      *            will contain the data
781      * @param polyVarName
782      *            the polynomial variable name
783      * @param real
784      *            the real data
785      * @param img
786      *            the imaginary data
787      * @param swaped
788      *            true if the matrix is stored row by row
789      * @param handlerId
790      *            the handler id
791      */
792     public static final void sendPolynomial(String varName, int[] indexes, String polyVarName, double[][][] real, double[][][] img, boolean swaped,
793                                             int handlerId) {
794         if (indexes.length != 0) {
795             addElement(indexes, new ScilabPolynomial(null, polyVarName, real, img, swaped));
796         } else {
797             handlers.get(handlerId).handle(new ScilabPolynomial(varName, polyVarName, real, img, swaped));
798         }
799     }
800
801     /**
802      * Send list, tlist and mlist
803      *
804      * @param varName
805      *            the variable name
806      * @param indexes
807      *            an integer array with the indexes of the (sub)*-list which
808      *            will contain the data
809      * @param type
810      *            a char which must take the values 'l' for list or 'm' for
811      *            mlist or 't' for tlist
812      * @param handlerId
813      *            the handler id
814      */
815     public static final void sendData(String varName, int nbItems, int[] indexes, char type, int handlerId) {
816         String name = null;
817         if (indexes.length == 0) {
818             name = varName;
819         }
820
821         ScilabType var = null;
822         switch (type) {
823             case 'l':
824                 var = new ScilabList(name, nbItems);
825                 break;
826             case 'm':
827                 var = new ScilabMList(name, nbItems);
828                 break;
829             case 't':
830                 var = new ScilabTList(name, nbItems);
831                 break;
832         }
833
834         if (indexes.length == 0) {
835             lists.put(Thread.currentThread(), (ArrayList<ScilabType>) var);
836         } else {
837             addElement(indexes, var);
838         }
839     }
840
841     /**
842      * Call when the list filling is finished a * @param indexes an integer
843      * array with the indexes of the (sub)*-list which will contain the data
844      *
845      * @param handlerId
846      *            the handler id
847      */
848     public static final void closeList(int[] indexes, int handlerId) {
849         Thread t = Thread.currentThread();
850         ArrayList<ScilabType> var = lists.get(t);
851         if (var != null && indexes.length == 0) {
852             handlers.get(handlerId).handle((ScilabType) var);
853             lists.remove(t);
854         }
855     }
856
857     /**
858      * Add an element to the list
859      *
860      * @param indexes
861      *            the indexes where to put the variable
862      * @param var
863      *            the variable to put
864      */
865     private static final void addElement(int[] indexes, ScilabType data) {
866         ArrayList<ScilabType> list = lists.get(Thread.currentThread());
867
868         for (int i = 0; i < indexes.length - 1; i++) {
869             list = (ArrayList<ScilabType>) list.get(indexes[i] - 1);
870         }
871
872         int n = indexes[indexes.length - 1] - 1;
873         if (n < list.size()) {
874             list.set(indexes[indexes.length - 1] - 1, data);
875         } else {
876             list.add(data);
877         }
878     }
879 }