Javasci: fix java build, javadoc warnings
[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 rows number of rows
130      * @param cols number of columns
131      * @param handlerId
132      *            the handler id
133      */
134     public static final void sendDataAsBuffer(String varName, int[] indexes, DoubleBuffer data, int rows, int cols, int handlerId) {
135         if (indexes.length != 0) {
136             addElement(indexes, new ScilabDoubleReference(null, data, null, rows, cols));
137         } else {
138             handlers.get(handlerId).handle(new ScilabDoubleReference(varName, data, null, rows, cols));
139         }
140     }
141
142     /**
143      * Send complex matrix
144      *
145      * @param varName
146      *            the variable name
147      * @param indexes
148      *            an integer array with the indexes of the (sub)*-list which
149      *            will contain the data
150      * @param real
151      *            the real data
152      * @param img
153      *            the imaginary data
154      * @param swaped
155      *            true if the matrix is stored row by row
156      * @param handlerId
157      *            the handler id
158      */
159     public static final void sendData(String varName, int[] indexes, double[][] real, double[][] img, boolean swaped, int handlerId) {
160         if (indexes.length != 0) {
161             addElement(indexes, new ScilabDouble(null, real, img, swaped));
162         } else {
163             handlers.get(handlerId).handle(new ScilabDouble(varName, real, img, swaped));
164         }
165     }
166
167     /**
168      * Send complex matrix as DoubleBuffer
169      *
170      * @param varName
171      *            the variable name
172      * @param indexes
173      *            an integer array with the indexes of the (sub)*-list which
174      *            will contain the data
175      * @param real complex real part data buffer
176      * @param imag complex imaginary part data buffer
177      * @param rows number of rows
178      * @param cols number of columns
179      * @param handlerId
180      *            the handler id
181      */
182     public static final void sendDataAsBuffer(String varName, int[] indexes, DoubleBuffer real, DoubleBuffer imag, int rows, int cols, int handlerId) {
183         if (indexes.length != 0) {
184             addElement(indexes, new ScilabDoubleReference(null, real, imag, rows, cols));
185         } else {
186             handlers.get(handlerId).handle(new ScilabDoubleReference(varName, real, imag, rows, cols));
187         }
188     }
189
190     /**
191      * Send int32 matrix
192      *
193      * @param varName
194      *            the variable name
195      * @param indexes
196      *            an integer array with the indexes of the (sub)*-list which
197      *            will contain the data
198      * @param data
199      *            the data
200      * @param swaped
201      *            true if the matrix is stored row by row
202      * @param handlerId
203      *            the handler id
204      */
205     public static final void sendData(String varName, int[] indexes, int[][] data, boolean swaped, int handlerId) {
206         if (indexes.length != 0) {
207             addElement(indexes, new ScilabInteger(null, data, false, swaped));
208         } else {
209             handlers.get(handlerId).handle(new ScilabInteger(varName, data, false, swaped));
210         }
211     }
212
213     /**
214      * Send int32 matrix as IntBuffer
215      *
216      * @param varName
217      *            the variable name
218      * @param indexes
219      *            an integer array with the indexes of the (sub)*-list which
220      *            will contain the data
221      * @param data
222      *            the data
223      * @param rows number of rows
224      * @param cols number of columns
225      * @param handlerId
226      *            the handler id
227      */
228     public static final void sendDataAsBuffer(String varName, int[] indexes, IntBuffer data, int rows, int cols, int handlerId) {
229         if (indexes.length != 0) {
230             addElement(indexes, new ScilabIntegerReference(null, data, rows, cols, false));
231         } else {
232             handlers.get(handlerId).handle(new ScilabIntegerReference(varName, data, rows, cols, false));
233         }
234     }
235
236     /**
237      * Send uint16 matrix
238      *
239      * @param varName
240      *            the variable name
241      * @param indexes
242      *            an integer array with the indexes of the (sub)*-list which
243      *            will contain the data
244      * @param data
245      *            the data
246      * @param swaped
247      *            true if the matrix is stored row by row
248      * @param handlerId
249      *            the handler id
250      */
251     public static final void sendUnsignedData(String varName, int[] indexes, short[][] data, boolean swaped, int handlerId) {
252         if (indexes.length != 0) {
253             addElement(indexes, new ScilabInteger(null, data, true, swaped));
254         } else {
255             handlers.get(handlerId).handle(new ScilabInteger(varName, data, true, swaped));
256         }
257     }
258
259     /**
260      * Send uint16 matrix as ShortBuffer
261      *
262      * @param varName
263      *            the variable name
264      * @param indexes
265      *            an integer array with the indexes of the (sub)*-list which
266      *            will contain the data
267      * @param data
268      *            the data
269      * @param rows number of rows
270      * @param cols number of columns
271      * @param handlerId
272      *            the handler id
273      */
274     public static final void sendUnsignedDataAsBuffer(String varName, int[] indexes, ShortBuffer data, int rows, int cols, int handlerId) {
275         if (indexes.length != 0) {
276             addElement(indexes, new ScilabIntegerReference(null, data, rows, cols, true));
277         } else {
278             handlers.get(handlerId).handle(new ScilabIntegerReference(varName, data, rows, cols, true));
279         }
280     }
281
282     /**
283      * Send int16 matrix
284      *
285      * @param varName
286      *            the variable name
287      * @param indexes
288      *            an integer array with the indexes of the (sub)*-list which
289      *            will contain the data
290      * @param data
291      *            the data
292      * @param swaped
293      *            true if the matrix is stored row by row
294      * @param handlerId
295      *            the handler id
296      */
297     public static final void sendData(String varName, int[] indexes, short[][] data, boolean swaped, int handlerId) {
298         if (indexes.length != 0) {
299             addElement(indexes, new ScilabInteger(null, data, false, swaped));
300         } else {
301             handlers.get(handlerId).handle(new ScilabInteger(varName, data, false, swaped));
302         }
303     }
304
305     /**
306      * Send int16 matrix as ShortBuffer
307      *
308      * @param varName
309      *            the variable name
310      * @param indexes
311      *            an integer array with the indexes of the (sub)*-list which
312      *            will contain the data
313      * @param data
314      *            the data
315      * @param rows number of rows
316      * @param cols number of columns
317      * @param handlerId
318      *            the handler id
319      */
320     public static final void sendDataAsBuffer(String varName, int[] indexes, ShortBuffer data, int rows, int cols, int handlerId) {
321         if (indexes.length != 0) {
322             addElement(indexes, new ScilabIntegerReference(null, data, rows, cols, false));
323         } else {
324             handlers.get(handlerId).handle(new ScilabIntegerReference(varName, data, rows, cols, false));
325         }
326     }
327
328     /**
329      * Send uint8 matrix
330      *
331      * @param varName
332      *            the variable name
333      * @param indexes
334      *            an integer array with the indexes of the (sub)*-list which
335      *            will contain the data
336      * @param data
337      *            the data
338      * @param swaped
339      *            true if the matrix is stored row by row
340      * @param handlerId
341      *            the handler id
342      */
343     public static final void sendUnsignedData(String varName, int[] indexes, byte[][] data, boolean swaped, int handlerId) {
344         if (indexes.length != 0) {
345             addElement(indexes, new ScilabInteger(null, data, true, swaped));
346         } else {
347             handlers.get(handlerId).handle(new ScilabInteger(varName, data, true, swaped));
348         }
349     }
350
351     /**
352      * Send uint8 matrix as ByteBuffer
353      *
354      * @param varName
355      *            the variable name
356      * @param indexes
357      *            an integer array with the indexes of the (sub)*-list which
358      *            will contain the data
359      * @param data
360      *            the data
361      * @param rows number of rows
362      * @param cols number of columns
363      * @param handlerId
364      *            the handler id
365      */
366     public static final void sendUnsignedDataAsBuffer(String varName, int[] indexes, ByteBuffer data, int rows, int cols, int handlerId) {
367         if (indexes.length != 0) {
368             addElement(indexes, new ScilabIntegerReference(null, data, rows, cols, true));
369         } else {
370             handlers.get(handlerId).handle(new ScilabIntegerReference(varName, data, rows, cols, true));
371         }
372     }
373
374     /**
375      * Send boolean matrix
376      *
377      * @param varName
378      *            the variable name
379      * @param indexes
380      *            an integer array with the indexes of the (sub)*-list which
381      *            will contain the data
382      * @param data
383      *            the data
384      * @param swaped
385      *            true if the matrix is stored row by row
386      * @param handlerId
387      *            the handler id
388      */
389     public static final void sendData(String varName, int[] indexes, boolean[][] data, boolean swaped, int handlerId) {
390         if (indexes.length != 0) {
391             addElement(indexes, new ScilabBoolean(null, data, swaped));
392         } else {
393             handlers.get(handlerId).handle(new ScilabBoolean(varName, data, swaped));
394         }
395     }
396
397     /**
398      * Send boolean matrix as reference
399      *
400      * @param varName
401      *            the variable name
402      * @param indexes
403      *            an integer array with the indexes of the (sub)*-list which
404      *            will contain the data
405      * @param data
406      *            the data
407      * @param rows number of rows
408      * @param cols number of columns
409      * @param handlerId
410      *            the handler id
411      */
412     public static final void sendBooleanDataAsBuffer(String varName, int[] indexes, IntBuffer data, int rows, int cols, int handlerId) {
413         if (indexes.length != 0) {
414             addElement(indexes, new ScilabBooleanReference(null, data, rows, cols));
415         } else {
416             handlers.get(handlerId).handle(new ScilabBooleanReference(varName, data, rows, cols));
417         }
418     }
419
420     /**
421      * Send int8 matrix
422      *
423      * @param varName
424      *            the variable name
425      * @param indexes
426      *            an integer array with the indexes of the (sub)*-list which
427      *            will contain the data
428      * @param data
429      *            the data
430      * @param swaped
431      *            true if the matrix is stored row by row
432      * @param handlerId
433      *            the handler id
434      */
435     public static final void sendData(String varName, int[] indexes, byte[][] data, boolean swaped, int handlerId) {
436         if (indexes.length != 0) {
437             addElement(indexes, new ScilabInteger(null, data, false, swaped));
438         } else {
439             handlers.get(handlerId).handle(new ScilabInteger(varName, data, false, swaped));
440         }
441     }
442
443     /**
444      * Send int8 matrix as ByteBuffer
445      *
446      * @param varName
447      *            the variable name
448      * @param indexes
449      *            an integer array with the indexes of the (sub)*-list which
450      *            will contain the data
451      * @param data
452      *            the data
453      * @param rows number of rows
454      * @param cols number of columns
455      * @param handlerId
456      *            the handler id
457      */
458     public static final void sendDataAsBuffer(String varName, int[] indexes, ByteBuffer data, int rows, int cols, int handlerId) {
459         if (indexes.length != 0) {
460             addElement(indexes, new ScilabIntegerReference(null, data, rows, cols, false));
461         } else {
462             handlers.get(handlerId).handle(new ScilabIntegerReference(varName, data, rows, cols, false));
463         }
464     }
465
466     /**
467      * Send int64 or uint64 matrix
468      *
469      * @param varName
470      *            the variable name
471      * @param indexes
472      *            an integer array with the indexes of the (sub)*-list which
473      *            will contain the data
474      * @param data
475      *            the data
476      * @param swaped
477      *            true if the matrix is stored row by row
478      * @param handlerId
479      *            the handler id
480      */
481     public static final void sendData(String varName, int[] indexes, long[][] data, boolean swaped, int handlerId) {
482         if (indexes.length != 0) {
483             addElement(indexes, new ScilabInteger(null, data, false, swaped));
484         } else {
485             handlers.get(handlerId).handle(new ScilabInteger(varName, data, false, swaped));
486         }
487     }
488
489     /**
490      * Send int64 or uint64 matrix as LongBuffer
491      *
492      * @param varName
493      *            the variable name
494      * @param indexes
495      *            an integer array with the indexes of the (sub)*-list which
496      *            will contain the data
497      * @param data
498      *            the data
499      * @param rows number of rows
500      * @param cols number of columns
501      * @param handlerId
502      *            the handler id
503      */
504     public static final void sendDataAsBuffer(String varName, int[] indexes, LongBuffer data, int rows, int cols, int handlerId) {
505         if (indexes.length != 0) {
506             addElement(indexes, new ScilabIntegerReference(null, data, rows, cols, false));
507         } else {
508             handlers.get(handlerId).handle(new ScilabIntegerReference(varName, data, rows, cols, false));
509         }
510     }
511
512     /**
513      * Send uint32 matrix
514      *
515      * @param varName
516      *            the variable name
517      * @param indexes
518      *            an integer array with the indexes of the (sub)*-list which
519      *            will contain the data
520      * @param data
521      *            the data
522      * @param swaped
523      *            true if the matrix is stored row by row
524      * @param handlerId
525      *            the handler id
526      */
527     public static final void sendUnsignedData(String varName, int[] indexes, int[][] data, boolean swaped, int handlerId) {
528         if (indexes.length != 0) {
529             addElement(indexes, new ScilabInteger(null, data, true, swaped));
530         } else {
531             handlers.get(handlerId).handle(new ScilabInteger(varName, data, true, swaped));
532         }
533     }
534
535     /**
536      * Send uint32 matrix as IntBuffer
537      *
538      * @param varName
539      *            the variable name
540      * @param indexes
541      *            an integer array with the indexes of the (sub)*-list which
542      *            will contain the data
543      * @param data
544      *            the data
545      * @param rows number of rows
546      * @param cols number of columns
547      * @param handlerId
548      *            the handler id
549      */
550     public static final void sendUnsignedDataAsBuffer(String varName, int[] indexes, IntBuffer data, int rows, int cols, int handlerId) {
551         if (indexes.length != 0) {
552             addElement(indexes, new ScilabIntegerReference(null, data, rows, cols, true));
553         } else {
554             handlers.get(handlerId).handle(new ScilabIntegerReference(varName, data, rows, cols, true));
555         }
556     }
557
558     /**
559      * Send string matrix
560      *
561      * @param varName
562      *            the variable name
563      * @param indexes
564      *            an integer array with the indexes of the (sub)*-list which
565      *            will contain the data
566      * @param data
567      *            the data
568      * @param swaped
569      *            true if the matrix is stored row by row
570      * @param handlerId
571      *            the handler id
572      */
573     public static final void sendData(String varName, int[] indexes, String[][] data, boolean swaped, int handlerId) {
574         if (indexes.length != 0) {
575             addElement(indexes, new ScilabString(null, data, swaped));
576         } else {
577             handlers.get(handlerId).handle(new ScilabString(varName, data, swaped));
578         }
579     }
580
581     /**
582      * Send double sparse matrix
583      *
584      * @param varName
585      *            the variable name
586      * @param indexes
587      *            an integer array with the indexes of the (sub)*-list which
588      *            will contain the data
589      * @param row
590      *            the row number
591      * @param col
592      *            the col number
593      * @param nbItem
594      *            the number of non null elements
595      * @param nbItemRow
596      *            the number by row of non null elements
597      * @param colPos
598      *            the column position of the non null elements
599      * @param data
600      *            the data
601      * @param handlerId
602      *            the handler id
603      */
604     public static final void sendData(String varName, int[] indexes, int row, int col, int nbItem, int[] nbItemRow, int[] colPos, double[] data, int handlerId) {
605         if (indexes.length != 0) {
606             addElement(indexes, new ScilabSparse(null, row, col, nbItem, nbItemRow, colPos, data, null));
607         } else {
608             handlers.get(handlerId).handle(new ScilabSparse(varName, row, col, nbItem, nbItemRow, colPos, data, null));
609         }
610     }
611
612     /**
613      * Send double sparse matrix as buffer
614      * Useless for now due to Scilab limitations (A=sparse(...);A(1,1)=123; a new A is created so references are lost)
615      *
616      * @param varName
617      *            the variable name
618      * @param indexes
619      *            an integer array with the indexes of the (sub)*-list which
620      *            will contain the data
621      * @param row
622      *            the row number
623      * @param col
624      *            the col number
625      * @param nbItem
626      *            the number of non null elements
627      * @param nbItemRow
628      *            the number by row of non null elements
629      * @param colPos
630      *            the column position of the non null elements
631      * @param data
632      *            the data
633      * @param handlerId
634      *            the handler id
635      */
636     /*public static final void sendDataAsBuffer(String varName, int[] indexes, int row, int col, int nbItem, IntBuffer nbItemRow, IntBuffer colPos, DoubleBuffer data, int handlerId) {
637       if (indexes.length != 0) {
638       addElement(indexes, new ScilabSparseReference(null, row, col, nbItem, nbItemRow, colPos, data, null));
639       } else {
640       handlers.get(handlerId).handle(new ScilabSparseReference(varName, row, col, nbItem, nbItemRow, colPos, data, null));
641       }
642       }*/
643
644     /**
645      * Send complex sparse matrix
646      *
647      * @param varName
648      *            the variable name
649      * @param indexes
650      *            an integer array with the indexes of the (sub)*-list which
651      *            will contain the data
652      * @param row
653      *            the row number
654      * @param col
655      *            the col number
656      * @param nbItem
657      *            the number of non null elements
658      * @param nbItemRow
659      *            the number by row of non null elements
660      * @param colPos
661      *            the column position of the non null elements
662      * @param real
663      *            the real data
664      * @param imag
665      *            the imaginary data
666      * @param handlerId
667      *            the handler id
668      */
669     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) {
670         if (indexes.length != 0) {
671             addElement(indexes, new ScilabSparse(null, row, col, nbItem, nbItemRow, colPos, real, imag));
672         } else {
673             handlers.get(handlerId).handle(new ScilabSparse(varName, row, col, nbItem, nbItemRow, colPos, real, imag));
674         }
675     }
676
677     /**
678      * Send complex sparse matrix as buffer
679      * Useless for now due to Scilab limitations (A=sparse(...);A(1,1)=123; a new A is created so references are lost)
680      *
681      * @param varName
682      *            the variable name
683      * @param indexes
684      *            an integer array with the indexes of the (sub)*-list which
685      *            will contain the data
686      * @param row
687      *            the row number
688      * @param col
689      *            the col number
690      * @param nbItem
691      *            the number of non null elements
692      * @param nbItemRow
693      *            the number by row of non null elements
694      * @param colPos
695      *            the column position of the non null elements
696      * @param real
697      *            the real data
698      * @param imag
699      *            the imaginary data
700      * @param handlerId
701      *            the handler id
702      */
703     /*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) {
704       if (indexes.length != 0) {
705       addElement(indexes, new ScilabSparse(null, row, col, nbItem, nbItemRow, colPos, real, imag));
706       } else {
707       handlers.get(handlerId).handle(new ScilabSparse(varName, row, col, nbItem, nbItemRow, colPos, real, imag));
708       }
709       }*/
710
711     /**
712      * Send boolean sparse matrix
713      * Useless for now due to Scilab limitations (A=sparse(...);A(1,1)=123; a new A is created so references are lost)
714      *
715      * @param varName
716      *            the variable name
717      * @param indexes
718      *            an integer array with the indexes of the (sub)*-list which
719      *            will contain the data
720      * @param row
721      *            the row number
722      * @param col
723      *            the col number
724      * @param nbItem
725      *            the number of true elements
726      * @param nbItemRow
727      *            the number by row of true elements
728      * @param colPos
729      *            the column position of the true elements
730      * @param handlerId
731      *            the handler id
732      */
733     private static final void sendData(String varName, int[] indexes, int row, int col, int nbItem, int[] nbItemRow, int[] colPos, int handlerId) {
734         if (indexes.length != 0) {
735             addElement(indexes, new ScilabBooleanSparse(null, row, col, nbItem, nbItemRow, colPos));
736         } else {
737             handlers.get(handlerId).handle(new ScilabBooleanSparse(varName, row, col, nbItem, nbItemRow, colPos));
738         }
739     }
740
741     /**
742      * Send boolean sparse matrix as Buffer
743      *
744      * @param varName
745      *            the variable name
746      * @param indexes
747      *            an integer array with the indexes of the (sub)*-list which
748      *            will contain the data
749      * @param row
750      *            the row number
751      * @param col
752      *            the col number
753      * @param nbItem
754      *            the number of true elements
755      * @param nbItemRow
756      *            the number by row of true elements
757      * @param colPos
758      *            the column position of the true elements
759      * @param handlerId
760      *            the handler id
761      */
762     /*public static final void sendDataAsBuffer(String varName, int[] indexes, int row, int col, int nbItem, IntBuffer nbItemRow, IntBuffer colPos, int handlerId) {
763       if (indexes.length != 0) {
764       addElement(indexes, new ScilabBooleanSparse(null, row, col, nbItem, nbItemRow, colPos));
765       } else {
766       handlers.get(handlerId).handle(new ScilabBooleanSparse(varName, row, col, nbItem, nbItemRow, colPos));
767       }
768       }*/
769
770     /**
771      * Send double polynomial matrix
772      *
773      * @param varName
774      *            the variable name
775      * @param indexes
776      *            an integer array with the indexes of the (sub)*-list which
777      *            will contain the data
778      * @param polyVarName
779      *            the polynomial variable name
780      * @param data
781      *            the data
782      * @param swaped
783      *            true if the matrix is stored row by row
784      * @param handlerId
785      *            the handler id
786      */
787     public static final void sendPolynomial(String varName, int[] indexes, String polyVarName, double[][][] data, boolean swaped, int handlerId) {
788         if (indexes.length != 0) {
789             addElement(indexes, new ScilabPolynomial(null, polyVarName, data, null, swaped));
790         } else {
791             handlers.get(handlerId).handle(new ScilabPolynomial(varName, polyVarName, data, null, swaped));
792         }
793     }
794
795     /**
796      * Send complex polynomial matrix
797      *
798      * @param varName
799      *            the variable name
800      * @param indexes
801      *            an integer array with the indexes of the (sub)*-list which
802      *            will contain the data
803      * @param polyVarName
804      *            the polynomial variable name
805      * @param real
806      *            the real data
807      * @param img
808      *            the imaginary data
809      * @param swaped
810      *            true if the matrix is stored row by row
811      * @param handlerId
812      *            the handler id
813      */
814     public static final void sendPolynomial(String varName, int[] indexes, String polyVarName, double[][][] real, double[][][] img, boolean swaped,
815                                             int handlerId) {
816         if (indexes.length != 0) {
817             addElement(indexes, new ScilabPolynomial(null, polyVarName, real, img, swaped));
818         } else {
819             handlers.get(handlerId).handle(new ScilabPolynomial(varName, polyVarName, real, img, swaped));
820         }
821     }
822
823     /**
824      * Send list, tlist and mlist
825      *
826      * @param varName
827      *            the variable name
828      * @param nbItems number of element in the list
829      * @param indexes
830      *            an integer array with the indexes of the (sub)*-list which
831      *            will contain the data
832      * @param type
833      *            a char which must take the values 'l' for list or 'm' for
834      *            mlist or 't' for tlist
835      * @param handlerId
836      *            the handler id
837      */
838     public static final void sendData(String varName, int nbItems, int[] indexes, char type, int handlerId) {
839         String name = null;
840         if (indexes.length == 0) {
841             name = varName;
842         }
843
844         ScilabType var = null;
845         switch (type) {
846             case 'l':
847                 var = new ScilabList(name, nbItems);
848                 break;
849             case 'm':
850                 var = new ScilabMList(name, nbItems);
851                 break;
852             case 't':
853                 var = new ScilabTList(name, nbItems);
854                 break;
855         }
856
857         if (indexes.length == 0) {
858             lists.put(Thread.currentThread(), (ArrayList<ScilabType>) var);
859         } else {
860             addElement(indexes, var);
861         }
862     }
863
864     /**
865      * Call when the list filling is finished a * @param indexes an integer
866      * array with the indexes of the (sub)*-list which will contain the data
867      *
868      * @param indexes to close
869      * @param handlerId
870      *            the handler id
871      */
872     public static final void closeList(int[] indexes, int handlerId) {
873         Thread t = Thread.currentThread();
874         ArrayList<ScilabType> var = lists.get(t);
875         if (var != null && indexes.length == 0) {
876             handlers.get(handlerId).handle((ScilabType) var);
877             lists.remove(t);
878         }
879     }
880
881     /**
882      * Add an element to the list
883      *
884      * @param indexes
885      *            the indexes where to put the variable
886      * @param var
887      *            the variable to put
888      */
889     private static final void addElement(int[] indexes, ScilabType data) {
890         ArrayList<ScilabType> list = lists.get(Thread.currentThread());
891
892         for (int i = 0; i < indexes.length - 1; i++) {
893             list = (ArrayList<ScilabType>) list.get(indexes[i] - 1);
894         }
895
896         int n = indexes[indexes.length - 1] - 1;
897         if (n < list.size()) {
898             list.set(indexes[indexes.length - 1] - 1, data);
899         } else {
900             list.add(data);
901         }
902     }
903 }