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 }