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 }